Transcript

1 Pagina 1 di 25 File in allegato: CMS_News 11,6 Kb Introduzione La maggior parte dei siti web a scopo informativo, come portali tematici o comunità online, necessitano di un sistema per la gestione dei propri contenuti, detti anche CMS (Content Management System), oggi, il sistema piu' utilizzato per tenere sempre aggionati i propri utenti e' quello di *News*, che permette la visualizzazione delle ultime notizie riguardanti diversi argomenti trattati, direttamente nella homepage del sito, provviste di un titolo, di una data di pubblicazione e di una breve descrizione. Successivamente l'utente stesso, potra' leggere la notizia completa oppure consultare tutte le altre notizie relative a quell'argomento stesso. In questo Tutorial, oltre a realizzare un completo sistema per gestire le Notizie del nostro sito, cercheremo di capire quali sono i passaggi fondamentali per iniziare a sviluppare un nostro CMS. Un giornale online Cosa c'entra il giornale? Bene, se abbiamo in mente di sviluppare un gestore di notizie dobbiamo fare affidamento a dei casi reali che saranno successivamente trasformati in formato elettronico. In questo caso, prendiamo in considerazione la struttura di una rivista o di un qualiasi giornale. La domanda che ora ci poniamo e' "cosa costituisce un giornale?", la risposta e' semplice, beh, da articoli e dai rispettivi autori, almeno nella maggior parte dei casi. Sicuramente ogni ogni articolo sara' cosi strutturato: 1. Titolo 2. Introduzione 3. Articolo completo 4. Data di pubblicazione 5. Argomento di interesse (es. Calcio) 6. Autore Mentre ogni autore presentera' questi dati: 1. Nome 2. Cognome 3. Indirizzo di posta elettronica 4. Eventuali Note Probabilmente questi sono i dati piu' importanti che potrebbero costituire un articolo e/o un autore, ma in questo tutorial ci baseremo su questi. Progettare il Database Tutti i dati che saranno elaborati e serviti dal nostro sistema dovranno essere salvati in un database mysql (se stiamo parlando di PHP, mi sembra ovvio utilizzare mysql :-)) quindi, prima di iniziare a scrivere del codice, e' bene soffermarci sulla probabile struttura che il database, presenterà. Le tabelle, quindi le entità che costituiranno il Database sono principalmente 3: -> Autori -> Articoli -> Sezioni Perche' *principalmente*? In effetti il nostro database dovra' contenere anche una quarta entità relativa ai dati di accesso per l'amministrazione del sistema, che chiameremo: *login*. Una volta individuate le entità (in questo caso, Articolo, Autore e Sezioni), pensiamo a come gestire gli autori, gli articoli e le Sezioni, per facilitarne la gestione, suggerisco sempre di attribuire a tutte le entità un campo chiave univoco di tipo numerico e auto incrementale, in questo modo, avremo per ogni autore, per ogni articoli e per ogni sezione un numero identificativo generato in modo del tutto automatico, spesso chiamato: *ID*. A questo punto, quindi, preoccupiamoci di realizzare un valido modello relazionale, da seguire per la creazione del Database, in questo schema potremo facilmente notare che tipo di relazione associare alle varie entità.

2 Pagina 2 di 25 Commentiamo lo schema Soffermiamoci sullo schema proposto, probabilmente i nomi assegnati alle varie entità (tabelle) potrebbero non essere di vostro gradimento, ma vediamo perche' e' consigliabile seguire uno schema del genere. In passato, come ho proposto in altri miei tutorials che trattavano Database, associavo sempre ad ogni tabella, nomi del genere *tbl_prodotti*, *tbl_autori*, etc... Insomma, aggiungendo il prefisso *tbl_* e successivamente completavo specificando il plurale dei dati presenti nella tabella. Ovviamente, questo tipo di interpretazione non e' sbagliata ma personalmente preferisco seguire lo schema sopra proposto, per una serie di validi motivi, eccoli qui: presenta una migliore leggibilità dall'occhio umano; cerchiamo di porre tutto al singolare, visto e considerato che rappresenteremo entità appartenenti al mondo reale; utilizziamo dei prefissi differenti per ogni colonna delle nostre tabelle, questi individuano facilmente il tipo di dato contenuto, ad esempio: int (intero numerico), str (stringa) e dtm (data ora) e ne denoterà una migliore gestione da parte del programmatore stesso, durante la fase di programmazione; infine, notiamo il suffiso ID posto alla fine di alcune colonne per evidenziare la presenza di chiavi (campi contatori di tipo auto incrementale), interne o esterne che esse siano. Lo schema, inoltre potra' essere facilmente letto e intepretato da tutti, non solo dal programmatore ma anche da terzi, fornendo loro una piccola interpretazione, a differenza invece di tanti schemi quasi incomprensibili da *comuni mortali*. Tutto questo perchè lo schema rappresenta al meglio le entità del mondo reale. Sviluppare il sistema Dopo una breve introduzione ed una piccola parentesi riguardo la corretta progettazione del Database, e' arrivato il momento di iniziare a scrivere un po di codice, ma prima vediamo da quali files sara' costituito il nostro sistema per la gestione di News. Ma ci stiamo dimenticando qualcosa? si, effettivamente non ho specificato da quali sezioni sara' costituito il sistema e successivamente parleremo dei files. Le aree principali che costituiscono ogni CMS, sono 2, una di *Front-End*, quindi, lato pubblico, ciò che vede l'utente durante la navigazione del sito, e un'altra di *Back-End*, la sezione riservata esclusivamente all'amministratore del sistema. Introduzione ai CMS Come accennavo nell'introduzione, l'acronimo CMS sta per Content Management System, ovvero Sistema per la gestione dei contenuti. Di questi sistemi, oggi e' possibile trovarne tanti in rete, ad esempio, esistono CMS specifici a determinati casi, come: Blogs, Forums, Gallerie di Immagini, Gestori di Files, Gestori di News, E- Commerce e tanti altri ancora. In alternativa ai CMS specifici, per gli utenti che necessitano diverse funzionalita' in un unico sistema, sono nati gli ACMS (Advanced Content Management System) la loro peculiarita' è quella di gestire diversi CMS contemporaneamente in un unico Sistema e quindi, con una sola sezione di Back-End, ad esempio sono in grado di offrire all'utente finale (amministratore del sito), sia un completo gestore di News che un altro per le Immagini, il tutto, amministrabile da un'unica sezione. Alcuni dei ACMS oggi piu diffusi, sono: phpnuke, Xoops, Mambo, MaxWebPortal, PostNuke e ASPNuke. In questo Tutorial, ovviamente, andremo a realizzare un semplice CMS per News e non ci imbatteremo in sistemi avanzati. Probabilmente un Tutorial non basterebbe a contenere tutto quello che c'e' da dire su questo argomento, ma un libro da 300/400 pagine sarebbe l'ideale ;-)

3 Pagina 3 di 25 Infine, vorrei mostrare le diverse strutture di questi sistemi, giusto per farci una migliore idea sulle differenze che intercorrono tra CMS e ACMS. In primo luogo analizzeremo la struttura dei CMS per passare successivamente a quella dei ACMS: Perfetto, una volta che abbiamo introdotto il funzionamento dei CMS, specificato e descritto le due aree di Front-End e di Back-End, non ci resta che passare dunque alla visualizzazione della struttura dei files che costituiranno il sistema per la gestione delle News. Un file per il setup del sistema -> /setup.php Files di uso comune -> /includes/db_conn.php -> /includes/funzioni_php.php -> /includes/verify.php Sezione di Back-End: -> /admin -> /admin/index.php -> /admin/pages/amministratore.php -> /admin/pages/autori.php -> /admin/pages/articoli.php -> /admin/pages/sezioni.php Sezione di Front-End: -> /index.php -> /menu.php -> /pager.php -> /pages/last_news.php -> /pages/info_autore.php

4 Pagina 4 di 25 -> /pages/leggi_news.php -> /pages/sezione_news.php Grosso modo, questi saranno tutti files necessari al corretto funzionamento del nostro sistema, durante la lettura di questo Tutorial, inizieremo la realizzazione della sezione di *Back-End*, quindi lato amministrativo per poi passare a quella di *Front-End*. Ovviamente nel tutorial non saranno presenti tutti i listati completi per ogni file poiche' la lettura potrebbe diventare noiosa. Mi limitero' ad illustrare esclusivamente la funzione dei files piu' importanti e come dovranno essere strutturati per offrire al programmatore stesso una migliore gestione del codice. Per chi comunque, volesse risalire al codice completo del CMS, può farlo semplicemente scaricando il file in allegato, all'inizio del tutorial. Il file di Setup? La maggior parte dei CMS, dispongono di un proprio file per installare il sistema, in definitiva, questo file non fa altro che preparare il Database, le Tabelle e infine popolarle con dei dati *standard*, rendendo in pochi instanti il sistema attivo e funzionante. Ma ora, dopo tante parole e' arrivato il momento di buttar giu' qualche riga, iniziamo col visualizzare il codice completo del file Setup.php File: Setup.PHP (Codice completo) Codice PHP:

5 Pagina 5 di 25

6 Pagina 6 di 25

7 Pagina 7 di 25

8 Pagina 8 di 25

9 Pagina 9 di 25

10 Pagina 10 di 25

11 Pagina 11 di 25

12 Pagina 12 di 25

13 Pagina 13 di 25 <?php /*CMS - News * Giuseppe Leone (Master85) * Copyright (c) MasterDrive.it 2005 */ /*File di Setup * Suddiviso a Steps: * 1: Crea db_news * 2: Crea tabella "Articolo" * 3: Crea tabella "Autore" * 4. Crea tabella "Sezione" * 5: Crea tabella "Login" * 6: Popola tabella "Autore" * 7: Popola tabella "Sezione" * 8: Popola tabella "Login" * 9: Fine Setup */ //Connesione a MySQL mysql_connect("localhost", "root") or die("non riesco a connettermi"); //Creazione Database $strsql = "CREATE DATABASE `db_news`"; mysql_query($strsql); //Creazione Tabella mysql_select_db("db_news") or die("non riesco a selezionare il Database"); //Query CREATE TABLE - Articolo $strsql = 'CREATE TABLE `articolo` ('. ' `intarticoloid` INT NOT NULL AUTO_INCREMENT, '. ' `intsezioneid` INT NOT NULL, '. ' `intautoreid` INT NOT NULL, '. ' `strtitolo` VARCHAR(100) NOT NULL, '. ' `strintroduzione` VARCHAR(255) NOT NULL, '. ' `strarticolo` TEXT NOT NULL, '. ' `dtmpubblicazione` INT(12) NOT NULL,'. ' PRIMARY KEY (`intarticoloid`)'. ' )'; //Creo la tabella mysql_query($strsql); //Query CREATE TABLE - Autore $strsql = 'CREATE TABLE `autore` ('. ' `intautoreid` INT NOT NULL AUTO_INCREMENT, '. ' `strnome` VARCHAR(25) NOT NULL, '. ' `strcognome` VARCHAR(25) NOT NULL, '. ' `str ` VARCHAR(100) NOT NULL, '. ' `strnote` VARCHAR(255) NOT NULL,'. ' PRIMARY KEY (`intautoreid`)'. ' )'; //Creo la tabella mysql_query($strsql); //Query CREATE TABLE - Sezione $strsql = 'CREATE TABLE `sezione` ('. ' `intsezioneid` INT NOT NULL AUTO_INCREMENT, '. ' `strnome` VARCHAR(25) NOT NULL,'. ' PRIMARY KEY (`intsezioneid`)'. ' )'; //Creo la tabella mysql_query($strsql);

14 Pagina 14 di 25 Questo file andra' eseguito una sola volta e a procedura completata, quindi, sistema installato e funzionante, consiglio vivamente di cancellarlo. Ricordiamoci inoltre i dati di accesso che abbiamo specificato durante la creazione del Database. In questo caso, ho utilizzato come Username: giuseppe e come password: mypass. La sezione di Back-End Una volta che abbiamo preparato il Database, le Tabelle e successivamente popolate con dei records di esempio, dobbiamo pensare alla realizzazione della sezione di Back-End. Ovviamente il codice non verra' mostrato completamente in questo tutorial, come accennavo in precedenza. Ma per tutti i curiosi, ho messo a disposizione il codice completo e funzionante di questo sistema in formato *.zip. Tornando al sistema di Back-End, mi limitero' ad illustrare il funzionamento e la struttura principale *generica* per ogni file. Ma prima di ciò, consiglio di dare uno sguardo a questo schema che illustrera' in semplici passaggi il funzionamento del lato di Back-End. Come si puo' ben notare, la sezione di back-end è principalmente basata su di un file *index.php*. Commentiamo quindi lo schema sopra proposto: Possiamo dire che il file /admin/index.php è suddiviso in 3 sezioni distinte e separate. La prima è necessaria all'inclusione dei vari files di utilizzo comune, come ad esempio la connessione al database e il file di verifica utente. La seconda, si preoccupa di selezionare e infine servire le determinate aree amministrative, nel caso in cui l'utente abbia effettuato il login, correttamente. Mentre la terza e ultima sezione, restituisce a video un semplice pannello di login nel caso in cui l'utente abbia effettuato il logout o non sia ancora loggato. Visualizzo di seguito il codice sorgente completo delle varie sezioni che compongono il file index.php: 1 Sezione - File: /includes/db_conn.php (codice sorgente completo) Codice PHP: <?php //Connessione al Database db_news mysql_connect("localhost", "root") or die("non riesco a connettermi"); mysql_select_db("db_news") or die("non trovo il Database");?> 2 Sezione - File: /includes/verify.php (codice sorgente completo) Codice PHP:

15 Pagina 15 di 25 <?php //Avvio o continuo la sessione session_start(); //Controllo che la sessione sia attiva if(!isset($_session['id_user'])){ //Controllo se l' utente vuole loggarsi $username $password //Controllo se l' username e la password non sono vuoti if((!strlen($username) == 0) and (!strlen($password) == 0)){ //Effettuo il controllo dei dati $strsql = "SELECT * FROM login"; $strsql.= " WHERE struser = '".$username."' AND strpass = MD5('".$password."')"; $result = mysql_query($strsql); $row = mysql_fetch_row($result); //Controllo se l' utente e' stato trovato if(!strlen($row[0]) == 0){ //Effettuo il login $_SESSION['intUserID'] = $row[0]; //Libero la memoria mysql_free_result($result); if(@$_get['logout'] == 1){ //Effettuo il Logout $_SESSION = array(); //Desetto tutte le variabili di sessione session_destroy(); //Distruggo le sessioni?> 3 Sezione - File: /admin/index.php (codice sorgente completo) Codice PHP:

16 Pagina 16 di 25 <?php require_once('../includes/db_conn.php');?> <?php require_once('../includes/verify.php');?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>amministrazione News</title> </head> <body> <?php //Controllo che l' utente sia loggato if(isset($_session['id_user'])) { //Recupero la pagina da visualizzare $page //Effettuo lo switch switch($page) { case 'amministratore': require_once('pages/amministratore.php'); break; case 'autore': require_once('pages/autore.php'); break; case 'sezione': require_once('pages/sezione.php'); break; case 'articolo': require_once('pages/articolo.php'); break; default: require_once('pages/menu.php'); break; else{ //Visualizzo il LOGIN?> <table align="center"> <form method="post" action="index.php"> <tr height="20"> <td colspan="2" align="center" bgcolor="#e9e9e9">login Amministrazione</td> </tr> <tr> <td>username:</td> <td><input type="text" name="txt_username"></td> </tr> <tr> <td>password:</td> <td><input type="password" name="txt_password"></td> </tr>

17 Pagina 17 di 25 Come funziona la pagina /admin/index.php? Ammettiamo di essere già loggati e quindi la pagina index.php deve essere in grado si fornirci una determinata area di amministrazione. Nel caso in cui non è stata ancora selezionata una determinata area da visualizzare, la pagina index.php ne visualizzerà una di default (vedere nella struttura switch, il caso default). Inoltre, se l'utente fornisse alla pagina index.php un'area che il sistema non è in grado di riconoscere, verrà sempre visualizzata la pagina presente nel caso di default. Ma l'area da selezionare da cosa è determinata? Il tutto è dovuto ad una varibile $page passata tramite GET alla pagina index.php, ad esempio: index.php?page=amministratore, in questo caso, l'area da visualizzare sarà *amministratore*. Una volta esaminata la struttura del file index.php è arrivato il momento di studiare il funzionamento delle varie aree amministrative. Se facciamo caso al codice sopra proposto, potremo notare che per ogni area amministrativa da visualizzare viene inclusa una pagina, ma qui, la domanda sorge spontanea: "Come fa una pagina a gestire più funzionalità allo stesso tempo?" Ecco come, ogni pagina a sua volta sarà suddivisa in sotto sezioni che verranno individuate da una variabile $azione, in base al valore assunto da questa variabile, la pagina visualizzerà un contenuto diverso. Di seguito visualizzo il codice sorgente completo dell'area amministrativa, *amministratore.php*. Tutti questi files saranno contenuti in una directory /admin/pages File: /admin/pages/amministratore.php (codice corgente completo) Codice PHP:

18 Pagina 18 di 25 <a href="index.php">menù amministrazione</a> <hr> <?php //Prelevo l' azione $action //Azione di default if(strlen($action) == 0){?> <script language="javascript"> function CheckForm(form){ //Boolean var booreturn = true; //strmessage var strmessage = "Attenzione, compilare i seguenti campi:\n" //recupero dati var username = form.txt_new_username.value; var userpass_1 = form.txt_new_password.value; var userpass_2 = form.txt_new_password_2.value; //Effettuo i controlli if(username == ""){ strmessage += "* Nuovo Username\n"; booreturn = false; if(userpass_1 == ""){ strmessage += "* Nuova Password\n"; booreturn = false; if(userpass_2 == ""){ strmessage += "* Ripeti Password\n"; booreturn = false; //Controllo le due password if(booreturn){ if(userpass_1!= userpass_2){ strmessage = "Attenzione\n"; strmessage += "* Le due pasword non coincidono"; booreturn = false; //Ritorno booreturn if(booreturn == false){ alert (strmessage); return booreturn; </script> <h1>modifica dati di Accesso</h1> <form method="post" action="index.php?page=amministratore&action=registra" onsubmit="return CheckForm( Nuovo Username: <input type="text" name="txt_new_username" maxlength="25"> <p>nuova Password: <input type="password" name="txt_new_password" maxlength="25"> <p>ripeti Password: <input type="password" name="txt_new_password_2" maxlength="25"> <p> <input type="submit" value="applica modifiche"> </form> <?php //Registra Modifiche if($action == "registra"){ //Recupero i nuovi dati utente $struser = $_POST['txt_new_username']; $strpass = $_POST['txt_new_password']; //Query SQL UPDATE

19 Pagina 19 di 25 Con la stessa metodologia con cui è stata sviluppata questa pagina verranno create anche tutte le altre. Ripeto, che per questioni di *spazio* non posso pubblicare in questo tutorial il codice sorgente di tutte le pagine del pannello di amministrazione. A questo punto, una volta che abbiamo capito come sviluppare nuove sezioni amministrative, è arrivato il momento di dare uno sguardo al lato di Front-End del nostro CMS. La sezione di Front-End Dire che siamo quasi agli *sgoccioli* di questo tutorial forse è troppo, comunque possiamo dire di essere a metà strada :-) e di aver capito il funzionamento principale del nostro CMS: Sezioni suddivise in moduli e moduli suddivisi in azioni, ecco come funziona principalmente il sistema. Comunque, senza perdere altro tempo in chiacchiere, iniziamo con lo sviluppo della sezione di Front-End. Solitamente i CMS di News non rchiedono una sezione di Front-End complicata e utilizzo di funzioni PHP particolari, tutto quello di cui avremo bisogno è visualizzare tutte le ultime news nella pagina principale (/last_news.php) oppure le news suddivise nelle rispettive sezioni (/pages/sezione_news.php). Rendiamo meglio l'idea osservando la struttura della Home Page del nostro CMS: Per questo tutorial, ho deciso di utilizzare una semplice struttura costituita da una tabella suddivisa in due colonne. Una prima, contenente il menu di navigazione, mentre la seconda, includerà il file /pager.php che si preoccuperà di selezionare e fornire le pagine richieste al nostro CMS. Una volta analizzata la struttura /index.php non ci resta che mostrare un po di codice della stessa pagina e successivamente visualizzare /menu.php e /pager.php: File: /index.php (Codice sorgente completo) Codice PHP:

20 Pagina 20 di 25 <?php require_once("includes/db_conn.php"); require_once("includes/funzioni_php.php");?> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> <title>articoli</title> </head> <body> <table width="80%" align="center" border="1"> <tr> <td width="20%" valign="top"> <?php require_once("menu.php");?> </td> <td width="80%" valign="top"> <?php require_once("pager.php");?> </td> </tr> </table> </body> </html> Come possiamo ben notare, nella parte superiore della pagina vengono inclusi due files: /includes/db_conn.php (la connessione al Database) che abbiamo visto in precedenza, e un nuovo file: /includes/funzioni_php.php, a cosa serve questo file? Solitamente, la maggior parte dei programmatori dedica un file.php esclusivamente al mantenimento di tutte le funzioni comuni, utilizzate durante la navigazione del sito, per non dover fare un *copia/incolla* di codice appesantendo notevolmente tutte le pagine complicandone la gestione delle stesse. Questo file, nel nostro caso conterra' la funzione per interpretare il testo appartenente all'articolo stesso, ad esempio tutti i pseudo tags (anche chiamati BBCodes. Argomento gia' discusso in altre guide presenti in questa sezione) come accade nei forum di discussione più diffusi oggi su internet per consentire all'utente di formattare come meglio crede il testo pubblicato. Quindi, osserviamo il contenuto del file /includes/funzioni_php.php: File: /includes/funzioni_php.php (codice sorgente completo) Codice PHP:

21 Pagina 21 di 25 <?php //Funzione per interpretare il testo function finterpreta($string) { //No HTML $string = trim(str_replace("<", "<", $string)); $string = trim(str_replace(">", ">", $string)); //CHR 13 $string = trim(str_replace(chr(13), "<br>;", $string)); $string = trim(str_replace(";", "", $string)); //BBCODE $string = trim(str_replace("[g]", "<b>", $string)); $string = trim(str_replace("[/g]", "</b>", $string)); $string = trim(str_replace("[c]", "<i>", $string)); $string = trim(str_replace("[/c]", "</i>", $string)); $string = trim(str_replace("[s]", "<u>", $string)); $string = trim(str_replace("[/s]", "</u>", $string)); $string = trim(str_replace("[hr]", "<hr>", $string)); $string = trim(str_replace("[li]", "<li>", $string)); $string = trim(str_replace("[image=", "<img border='0' src='", $string)); $string = trim(str_replace("[url=", "<a href='", $string)); $string = trim(str_replace("[/url]", "</a>", $string)); $string = trim(str_replace("[al=left]", "<div align='left'>", $string)); $string = trim(str_replace("[al=center]", "<div align='center'>", $string)); $string = trim(str_replace("[al=right]", "<div align='right'>", $string)); $string = trim(str_replace("[/al]", "</div>", $string)); $string = trim(str_replace("[posta=", "<a href=mailto:", $string)); $string = trim(str_replace("[/posta]", "</a>", $string)); $string = trim(str_replace("[colore=", "<font color=", $string)); $string = trim(str_replace("[/colore]", "</font>", $string)); $string = trim(str_replace("]", "'>", $string));?> //Ritorno il valore return $string; Perfetto, dopo questa piccola parentesi sulla formattazione del testo e quindi sui BBCodes, continuiamo ad analizzare la pagina /index.php. Restano ancora altri due file che costituiscono questa pagina: /menu.php e /pager.php. Il file menu.php visualizza le sezioni disponibili e offre un url per visionare solamente gli articoli delle sezioni interessate: File: /menu.php (Codice sorgente completo) Codice PHP:

22 Pagina 22 di 25 <?php //Visualizzo le sezioni $strsql = "SELECT DISTINCT articolo.intsezioneid,". " sezione.intsezioneid,". " sezione.strnome FROM articolo". " INNER JOIN sezione". " ON articolo.intsezioneid = sezione.intsezioneid". " ORDER BY sezione.strnome ASC"; $result = mysql_query($strsql); //url torna in Homepage echo "<a href=\"index.php\">homepage</a><br>\n"; //Elenco le sezioni while($row = mysql_fetch_array($result)){ $intsezioneid = $row['intsezioneid']; $strnome = $row['strnome']; echo "<a href=\"index.php?page=sezione&id=$intsezioneid\">$strnome</a><br>\n"; //Libero la memoria mysql_free_result($result);?> Mentre il file /pager.php provvede come accennato in precedenza al recupero ed alla visualizzazione delle pagine (moduli) interessati, ecco il codice completo, potrebbe ricordare vagamente /admin/index.php, in concetto è sempre lo stesso. File: /pager.php (Codice sorgente completo) Codice PHP:

23 Pagina 23 di 25 <?php //Recupero la pagina da visualizzare $page //Effettuo lo switch switch($page) { case 'sezione': require_once('pages/sezione_news.php'); break; case 'articolo': require_once('pages/leggi_news.php'); break; case 'autore': require_once('pages/info_autore.php'); break;?> default: require_once('pages/last_news.php'); break; Come si nota dal codice, il *caso* di default di questa struttura switch restituisce la pagina /pages/last_news.php che provvederà alla visualizzazione degli ultimi 10 articoli inseriti nel Database. I moduli di Front-End Una volta che abbiamo studiato il funzionamento del CMS e avere scritto i files principali che costituiscono la sezione di Front-End, non ci resta che sviluppare alcuni dei Moduli (pagine) che il CMS provvederà a visualizzare. Sembra ovvio, analizzare in primo luogo la pagina (modulo) /pages/last_news.php, come accennavo in precedenza, si occuperà della visualizzazione degli ultimi 10 articoli inseriti: File: /pages/last_news.php (codice sorgente completo) Codice PHP:

24 Pagina 24 di 25 <?php echo "<h1>ultime News Pubblicate</h1>\n"; //Query SQL per visualizzare le ultime News $strsql = "SELECT articolo.intarticoloid, ". " articolo.intsezioneid, ". " articolo.intautoreid, ". " articolo.strtitolo, ". " articolo.strintroduzione, ". " articolo.dtmpubblicazione, ". " sezione.intsezioneid, " //Evito conflitti con strnome di autore. " sezione.strnome AS strsezionenome, " *.*.*.*.*.*.*.*.*. " autore.intautoreid, ". " autore.strcognome, ". " autore.strnome FROM ((articolo". " INNER JOIN sezione ON". " articolo.intsezioneid = sezione.intsezioneid)". " INNER JOIN autore ON". " articolo.intautoreid = autore.intautoreid)". " ORDER BY articolo.dtmpubblicazione DESC". " LIMIT 0, 10"; //Eseguo la query SQL $result = mysql_query($strsql); //Scorro gli ultimi 10 articoli inseriti while($row = mysql_fetch_array($result)){ //Recupero i Dati essenziali $intarticoloid = $row['intarticoloid']; $intsezioneid = $row['intsezioneid']; $intautoreid = $row['intautoreid']; $strtitolo = $row['strtitolo']; $strintroduzione = $row['strintroduzione']; $dtmpubblicazione = $row['dtmpubblicazione']; $strsezionenome = $row['strsezionenome']; $strcognome = $row['strcognome']; $strnome = $row['strnome']; //Visualizzo a video l'articolo echo "<a href=\"index.php?page=articolo&id=$intarticoloid\">$strtitolo</a>\n<br>"; echo "Pubblicato: ".date("d-m-y", $dtmpubblicazione)." "; echo "da: $strnome $strcognome<hr>"; echo finterpreta($strintroduzione)."<p>"; //Libero la memoria mysql_free_result($result);?> Commenti: L'unica particolarità di questo codice è la query SQL, per eseguire una interrogazione dal Database che fosse in grado di estrapolare tutti i dati più significativi per elencare gli ultimi articoli, nel nostro caso, abbiamo utilizzato le INNER JOIN, quindi, ci preoccupiamo di collegare le vari tabelle (entità) del database per mezzo di un campo *comune*, ad esempio: articolo.intsezioneid con sezione.intsezioneid per recuperare tutti i dati relativi alla sezione di appartenenza dell'articolo. Inoltre, altra particolarità e' la riga: sezione.strnome AS strsezionenome in questo caso, abbiamo associato al campo *virtuale* strsezionenome il valore di sezione.strnome. Tutto ciò, per evitare conflitti con il campo autore.strnome poichè i due, presentano la stessa denominazione. Conclusioni

25 Pagina 25 di 25 Come conclusioni? Il tutorial finsce qui? Già! Una volta che abbiamo studiato il meccanismo del sistema e visualizzato il codice della pagina /pages/last_news.php, non credo sia necessario andare oltre con la visualizzazione del codice delle altre pagine, in fondo, tutto quello che dobbiamo fare per lo sviluppo di altri moduli (pagine) per la visualizzazione degli articoli di una determinata sezione oppure per la lettura di un singolo articolo, è semplicemente andare a modificare la query SQL e qualche riga di codice PHP. Tutto qui. Ovviamente in questo tutorial ho voluto introdurre gli aspetti principali che individuano il funzionamento dei CMS, ma ovviamente su questo argomento ci si potrebbe scrivere benissimo un testo completo, esistono ancora tanti altri metodi e concetti per lo sviluppo di CMS che variano da programmatore a programmatore... A questo punto, tutto quello che mi resta da dire è: "Buona programmazione!" e alla prossima :-)