Il CMS? FDT!

Il che va benissimo finche' si tratta di gestire un sito relativamente piccolo. Ma dopo un po' diventa un casino perche' se vuoi cambiare una virgola dell'impostazione del sito (tipo, lo stile del titolo), lo devi cambiare su tutte le pagine, il che e' lento, noioso e porta a commettere un sacco di errori.

Vabbe', e' per questo che gli esseri umani hanno inventato i 'CMS' (Content Manglement System), che altro non sono che degli editor di testo specializzati per gestire il 'contenuto' in modo tale che l'autore possa concentrarsi sullo scrivere la roba e meno sull'organizzazione della cosa.

Solo che... non sono riuscito veramente a trovarne uno che facesse quello che volevo io.

1. Deve consentirmi di organizzare ogni singola pagina come mi pare a me.

   Io voglio la possibilita' di avere diverse 'pagine', ognuna delle quali (ipoteticamente) potrebbe avere uno stile diverso.

2. Non voglio editor del menga

   Io voglio potermi scrivere il mio testo direttamente in html, non voglio dover scrivere roba come '***test***' per avere il testo in grassetto o roba come '=== titolo ===' per un titolo. Cosa c'e' che non va nello scrivere <b> e <h1>?

3. Voglio poter gestire il sito in 'sezioni'

   Che sono poi praticamente l'equivalente delle directory. Quindi voglio potermi riferire ad un documento come /documenti/qualcosa o /storie/08/story1 e via cosi'. Questo mi permette di organizzare le cose in modo piu' logico e mi consente di creare in modo facile elenchi di documenti da presentare sul sito.

Ok, una lista non troppo pretenziosa, giusto? Purtroppo tutti i CMS che ho visto non la contemplano.

Quasi tutti i CMS che mi sono trovato a considerare sono 'tarati' per un tipico 'blog', cioe' una impostazione a 'post' consequenziali, suddivisi magari in categorie ed in date, ma sempre consequenziali. Il che va benissimo se vuoi un blog, ma va malissimo per me.

Quello che effettivamente volevo io, era un sistema per poter avere dei 'blocchi' di testo standard da poter 'incorporare' o 'includere' in un 'template' in modo rapido, ed un paio di funzioni per 'elencare' il contenuto di alcune directory in modo formattato. Insomma una versione di 'Server Side Include ++'.

Il risultato e' stato che mi sono messo li' ed ho scritto il mio CMS FDT (Fai Da Te).

In questo modo, non c'e' modo per un eventuale 'cracker' di impastarmi il database perche' non c'e' nessuna "insert" o "update" nel codice da sfruttare. Tutte le funzioni di 'modifica' dei dati possono essere messe su un server differente e fare le modifiche off-line o protette da autenticazione.

Il sistema sara' quindi composto da 3 parti:

1. presentazione contenuti
2. editing/gestione
3. aggiunta commenti da parte degli utenti

Devo ammettere che ho tentennato un bel po' prima di decidermi ad aggiungere l'ultimo pezzo, semplicemente perche' i "commenti" non mi hanno mai interessato molto, ma alla fine ho ceduto e l'ho aggiunta.

Per rendere le cose piu' semplici ho deciso che le 3 parti usano lo stesso file di configurazione, in modo che si configura una volta per tutte.

Ho anche pensato se usare o meno un database, in effetti una versione 0.1 era priva di database ed usava semplici files di testo come base dati, ma alla fine ho deciso che la gestione risultava molto piu' rapida e semplice usando un database di backend. Dopo un po' di masturbazioni mentali ho deciso di usare la seguente struttura per il database:

Come si puo' vedere, io aborrisco la "notazione polacca" ed evito di chiamare le mie tabelle "tbl_xxx", perche' LO SO CHE SONO FOXXUTE TABELLE!. La struttura delle varie tabelle e' la seguente:

authors/includes/templates

Le tabelle authors, includes e templates hanno tutte la stessa struttura, per semplicita' di gestione ho deciso di tenerle in tabelle separate.

pages

Questa e' la tabella che contiene le vere e proprie 'pagine', come si nota, il template (tpl) e' definito nella singola pagina, questo mi consente di avere ogni pagina con un template suo. La lingua (lang) mi consente di avere lo stesso documento in lingua diversa. La chiave primaria della tabella (doc+id+lang) mi consente di dividere le pagine per 'documento' e 'lingua'. Notare anche che quella che io ho chiamato 'sezione' o 'directory' precedentemente e' riportata nella tabella come 'doc'. Perche' "doc"? Boh! E' uscita cosi'...

comments

Questa e' l'unica tabella ad avere una chiave primaria auto-incrementante, dato che io penso che siano una cattiva idea.

Mettiamo che l'URL sia del tipo http://.../questo/e/quello/pagina.html

Lo script che processa il tutto si legge quale lingua il browser dell'utente preferisce facendo la scansione della variabile HTTP_ACCEPT_LANGUAGE che e' passata dal browser nella richiesta, quindi si legge quale documento il browser vuole e separa il PATH dal nome del documento vero e proprio (nel nostro esempio il path sarebbe questo/e/quello mentre il documento e' pagina.html).

Il passo successivo e' cercare una pagina identificata da doc='questo/e/quello' e id='pagina.html' e con la lingua giusta.

Se la pagine esiste nella lingua giusta, si legge il corrispondente record e si procede con l'elaborazione, se non esiste, si pesca la pagina con la lingua di default (se esiste) se non esiste manco quella occorre restituire un 'documento non trovato' o similare.

Una volta trovato il record (o quello di 'non trovato'), si legge il contenuto della pagina (campo 'content') ed il template (tpl), quindi si carica il template indicato e si procede ad analizzare il template.

L'unione del template e del contenuto produce la pagina vera e propria.

La pagina (ed il template) possono contenere degli "include" (o 'autori') che vengono letti al volo ed inseriti.

Il risultato viene rimandato al browser per la visualizzazione.

E' importante notare in questa struttura che e' la pagina che indica quale template usare, ma e' il template che deve 'includere' il contenuto della pagina in qualche modo. Se il template non richiama il contenuto della pagina la pagina non viene mai visualizzata.

Un template 'di esempio' potrebbe essere semplicemente qualche cosa del tipo:

<html>
<head>

<title><!--title--></title>
</head>
<body>
<!--text-->
</body>
</html>

Come si puo' capire, questo sistema lascia molto campo libero nel come fare le cose. Sopratutto quando si aggiunge la possibilita' di includere altri pezzi di documento. Un template piu' complesso potrebbe essere il seguente:

<html>
<head>
<title><!--title--></title>
</head>
<body>
<!--include=top-->

<table width=100%>
<tr>
<td>
<!--include=leftcolumn-->
</td>
<td>
<!--text-->
</td>
</tr>

</table>
<!--include=bottom-->
</body>
</html>

Il codice comincia con il leggere il file di configurazione e connettersi al database dopo di che procede a fare il parsing dei parametri passati e vede quale e' il documento da visualizzare, cerca il documento e carica in memoria il documento o un genrico 'notfound'. Quindi procede a caricare il template (o un template di default) ed al termine legge il template una linea alla volta. Se la linea non contiene nessun 'tag' speciale, viene visualizzata cosi' come e', se contiene un tag, il tag viene elaborato. Il tag '<--text-->' fa si' che il contenuto del documento venga elaborato nello stesso modo.

Il documento risultante e' ritornato al browser.

Di seguito le parti 'salienti' del codice con qualche commento.

NOTA il codice e' stato scritto piu' per leggibilita' che per efficienza.

Ricerca del linguaggio preferito dal browser (in ordine di importanza), se non si trova una corrispondenza, viene usato il linguaggio di default (definito nel file di configurazione).

# get the "preferred" languages from the browser, I'll check later if the
# language can be used or not.
my @lang;
my $x;
my $y=0;
foreach $x(split(/,/,$ENV{'HTTP_ACCEPT_LANGUAGE'})) {
        $x=~s/(..).*/\1/;
        $lang[$y++]=$x;
}
# if I got no languages, use the default one
if($y==0) {
        $lang[0]=$deflang;
}

Prende l'url del documento e lo divide in 'path' e nome del documento

# get the 'section' from the document name (if any)
if( $doc =~ /\// ) {
        $section=$doc;
        $section=~s/^(.*)\/[^\/]+$/\1/;
        $section=~s/^\///;
        $section=~s/\/$//;
        $doc=~s/.*\/([^\/]+)$/\1/;

        # if no doc, get the default one
        if( $doc =~ // ) {
                $doc=$defdoc;
        }
        # if no section, get the default one
        if ( $section =~ /^$doc$/ ) {
                $section=$defsection;
        }
} else {
        # if there is no '/' in the URL, it can be a section or it can
        # be a document in the root... try to locate a section with the
        # same name.
        if(thereisasection($doc)>0) {
                $section=$doc;
                $doc=$defdoc;
        } else {
                $section=$defsection;
        }
}

Processa il documento, che puo' essere un template o un documento.

# process the document, that can be a template, a content or whatever
sub processdoc()
{

        my $c=shift();
        my @lines = split( /\n/, $c);
        my $line;
        my $group;
        my $print;
        my $prev;
        my $next;
        my $striphtml=0;

        # process one line at a time
        foreach $line (@lines) {

                # replace some variables into the line
                $print=1;
                $line=~s/<!--title-->/$title/;
                $line=~s/<!--data-->/$pdt/;
                $line=~s/<!--DATE-->/$date/;
                $line=~s/<!--DOC-->/\//;

                # check if the line is an assignment and load the value
                if($line=~/<!--[^=-]+-->/) {
                        my $var=$line;
                        $var=~s/^.*<!--([^=-]+)-->.*$/\1/;
                        if($FORM{"$var"}) {
                                $line=~s/<!--$var-->/$FORM{"$var"}/g;
                        }
                }

                # check if the line has special meanings

                # pointer to a previous document
                if( $line =~ /<!--prev-->/ ) {
                        $prev=&getprevious();
                        $line =~ s/<!--prev-->/$next/;

                }

                # pointer to a next document
                if( $line =~ /<!--next-->/ ) {
                        $next=&getnext();
                        $line =~ s/<!--next-->/$next/;
                }

                # include an 'include'
                if( $line =~ /<!--include=/ ) {
                        my $inc=$line;
                        $inc=~s/<!--include=(.*)-->.*$/\1/;
                        $inc=&include($inc);
                        &processdoc($inc);
                        $print=0;
                }

                # author's data
                if( $line =~ /<!--author-->/ ) {
                        print &author($author);
                        $print=0;
                }

                # here goes the document/content
                if( $line =~ /<!--text-->/ ) {
                        &processdoc($dc);
                        $print=0;
                }

                # show comments on this document
                if( $line =~ /<!--comments-->/ ) {
                        &showcomments();
                        $print=0;
                }

                # process a list of pages
                if($line=~/<!--process=/) {
                        $group=$line;
                        $group=~s/<!--process=(.*)-->.*/\1/;
                        &process($group);
                        $print=0;
                }

                # show a list of comments 'blog style'
                if($line=~/<!--journal=/) {
                        $group=$line;
                        $group=~s/<!--journal=(.*)-->.*/\1/;
                        &journal($group);
                        $print=0;
                }

                # list a series of pages
                if($line=~/<!--list=/) {
                        $group=$line;
                        $group=~s/<!--list=(.*)-->.*/\1/;
                        &list($group);
                        $print=0;
                }

                # turn on or off html-tag stripping, useful for the '<pre>'
                # block
                if($line=~/<!--HTML-->/) {
                        if($striphtml==1) {
                                $striphtml=0;
                        } else {
                                $striphtml=1;
                        }
                        $print=0;
                }

                # no special meanings? print the line!
                if($print) {

                        # should I strip html-tags?
                        if($striphtml==1) {
                                $line=~s/</& lt;/g;
                                $line=~s/>/& gt;/g;
                        }
                        print "$line\n";
                }
        }
}

Da notare in questa sezione: all'inizio, la linea viene processata per sostituire certi tag con dei valori precalcolati (la data di sistema, la data di pubblicazione...), quindi ogni linea viene processata una alla volta ed eventuali tag sono rimpiazzati con altre cose. In particolare i tag <--prev--> e <--next--> sono sostituiti con due hyperlink che puntano rispettivamente al documento successivo e precedente, perche' questo funzioni il nome del documento deve essere del tipo 'nomeNNN' dove 'NNN' e' un numero progressivo.

Legge un blocco di testo dalla tabella "authors", dato che gli "includes" sono identici, si puo' desumere come sia l'equivalente funzione "include".

# load a bit of text from the authors' table
sub author()
{
        my $q="select content from $auth where id='".$author."' and ";
        $q.="lang='".$slang."'";
        my $sth=$dbh->prepare($q);
        $sth->execute;
        my $r=$sth->fetchrow_hashref();
        my $dc=$r->{'content'};
        $sth->finish();
        return $dc;

}

Produce una lista dai titoli delle pagine, utile per creare elenchi di link cliccabili. Una funzione similare e' la 'process()' che fa la stessa cosa ma applicando una diversa formattazione.

# generate a list of pages from the db
sub list()
{
        my $group=shift();

        my $q="select title,doc,id from $pages where doc='".$group."' and ";
        $q.="lang='".$slang."' and id!='index' and pub=1 order by id,pdt";

        my $sth=$dbh->prepare($q);
        $sth->execute;
        while( my $r=$sth->fetchrow_hashref()) {
                print "<a href='/".$group."/".$r->{'id'}."'>";
                print $r->{'title'};
                print "</a><br>\n";
        }
        $sth->finish();
}

Il codice e' un po' troppo lungo per commentarlo, e comunque non contiene niente di eclatante.

Per costruire l'ID del documento la mia form di inserimento legge l'ID della pagina (fornito dal CMS stesso sotto forma del tag '<!--doc-->'), la form di inserimento deve quindi contenere un campo 'hidden' del tipo:

<input type='hidden' name='id' value='<!--doc-->'>

L'unica cosa che ho fatto per prevenire lo spam e' stata passare il contenuto a SpamAssassin. Ho anche notato un certo 'trend' nella robaccia che arrivava, quindi un piccolo cambiamento nel codice mi ha consentino di rimuovere il 100% dello spam via commenti senza problemi. Almeno fino ad ora... ultime parole famose eh?

Perche' il tutto funzioni correttamente, il sistema si aspetta anche di avere 3 pagine di 'risposta', una 'good' per i commenti corretti, e due 'bad' (bad e bad2) per i commenti sbagliati/troppo lunghi.

Scaricate il codice ed altra roba da qui.

Per usare il codice vi serve PERL (doh!), con i seguenti moduli aggiuntivi: CGI, Mail::SpamAssassin, Date::Format, Date::Parse e Config::General. No, non c'e' nessun 'install' che faccia il lavoro per voi, dovrete andare di CPAN ed installare i moduli richiesti se non li avete.

Vi serve MySQL, ovviamente, insieme al codice del CMS c'e' un file .sql per riempire il database con dei dati di prova. Il database di esempio contiene due templates e due pagine, la pagina 'notfound' di default ed una 'home page'. Create un database, importate i dati, assegnate un'utente con diritti di lettura e scrittura e buon divertimento.

Mettere doc.pl, doc.conf, s1.pl e c2.pl nella vostra cgi-bin, assicuratevi che siano eseguibili. Modificate doc.conf in modo che punti al database giusto con lo username e la password giusta. Come test, richiamate semplicemente dalla linea di comando ./doc.pl, dovreste vedere una caterva di roba a video (la pagina di default), se vedete invece degli errori leggeteli e cercate di risolvere il problema (vi manca qualche pezzo di perl, il path di perl e' sbagliato nello script, l'utente che avete impostato nella configurazione non e' in grado di leggere il database).

Se volete usare SpamAssassin per verificare i commenti ricordatevi di creare la directory .spamassassin per l'utente che esegue il web server e di creare un file di configurazione user_prefs per controllare cosa viene bloccato e cosa no. Suggerisco di tenere MISSING_HB_SEP, MISSING_HEADERS e MISSING_SUBJECT a zero, in quanto i commenti non hanno headers ne' soggetto...

Se tutto funziona, provate a richiamare lo script via browser digitando http://ilvostrositoqui/cgi-bin/doc.pl, dovreste vedere la vostra pagina.

Se volete fare le cose di fino, potete usare mod_rewrite e mod_proxy per ottenere una riscrittura 'trasparente' dell'url. Una cosa cosi':

RewriteCond     %{REQUEST_URI}  /.*\.html$
RewriteCond     %{REQUEST_URI}  !/img.*$
RewriteCond     %{REQUEST_URI}  !/images.*$
RewriteRule     ^/(.*)\.html$   /$1             [R]

RewriteCond     %{REQUEST_URI}  !/cgi-bin.*$
RewriteCond     %{REQUEST_URI}  !/icons.*$
RewriteCond     %{REQUEST_URI}  !/img.*$
RewriteCond     %{REQUEST_URI}  !/image.*$
RewriteCond     %{REQUEST_URI}  !.*\.zip$
RewriteCond     %{REQUEST_URI}  !.*\.gz$
RewriteCond     %{REQUEST_URI}  !.*\.bz2$
RewriteCond     %{REQUEST_URI}  !.*\.img$
RewriteCond     %{REQUEST_URI}  !.*\.rss$
RewriteRule     ^/(.*)$ /cgi-bin/doc.pl?doc=$1  [P,NE,L]

Esegue la riscrittura trasparente degli URL, in modo che un url come http:///ilvostrosito/ viene automaticamente riscritto come http://ilvostrosito/cgi-bin/doc.pl e richiama il CMS in automatico.

Vi consiglio di proteggere con password la parte 'attiva' del cms, usando una semplice regoletta come la seguente in .htaccess o nel file di configuazione di Apache:

<FilesMatch "c.\.pl">
	AuthType Basic
	AuthName "CMS Interface"
	AuthUserFile /dove/volete/htpasswd
	Require valid-user
</FilesMatch>

Create il file htpasswd (ovviamente) ed in questo modo la parte attiva sara' protetta da occhi e mani indiscrete.

Se si fanno cazzate (tipo mettere un tag 'text' nel documento), si possono creare dei cicli infiniti, il che puo' mandare in palla il sistema. Questo e' un bug noto, che ho pensato inizialmente a come risolvere ma alla fine ho lasciato li'.

L'editor e' estremamente limitato, in effetti e' cosi' limitato da essere quasi inutile come editor. Questo perche' io non voglio un editor. Di solito cio' che faccio e' scrivere le pagine con un vero editor (tipo VIM), aggiungendo i tag che voglio, vedo come salta fuori la pagina aprendola direttamente con un browser, faccio tutte le correzioni del caso e quando sono soddisfatto faccio un bel copy & paste direttamente nel database.

Un bug nella gestione delle lingue e' stato corretto, precedentemente solo la prima lingua richiesta dal browser era gestita, adesso anche le successive. Quindi se una delle lingue per cui esiste un documento e' nell'elenco richiesto dal browser quella lingua sara' selezionata.

Per evitare problemi con i tag HTML nell'editing, ho aggiunto una funzione 'download' che consente di visualizzare il contenuto della pagina in formato plain-text, in questo modo eventuali tag non sono alterati.

Ho aggiunto un tag <!--whatsupdoc=sezione--> che consente di avere gli ultimi due documenti pubblicati nella sezione indicata, questo mi consente di avere gli "ultimi aggiornamenti" in primo piano senza diventare matto a cercarli.

Max length of comments: 1000 chars.

si, be'... dopo aver corretto vari bugs...

Per la cronaca io ci sono cascata e prima di leggere qui sono andata su google a cercare "cms fdt".

non sei la sola

quella di uccidere...

perchè se avessi voglia di modificarlo per me potrebbe bastare citarti come "ispirazione", ma se poi qualcun'altro prendesse da me i sorgenti (non mi sembrerebbe giusto nei tuoi confronti non rilasciare le modifiche)?

quajo', fai un po' come ti pare, io i sorgenti li distribuisco agratisse, basta che nessuno venga da me a lamentarsi

si dice ca$$o, non $fallo

grassie.

veramente, se io cerco 'cms fdt' su google, la mia pagina e' il terzo o il quarto risultato...

e NON ho dubbi che funzionera'...

Grande D.!

grazie

Config::General e' usato per leggere il file di configurazione, se non c'e', l'alternativa e' copiare i parametri nel codice (in tutti i .pl) e quindi ignorare il file di configurazione. Date:: dovrebbe esserci sempre, che cappero di installazione di Perl e' se non hai Date:: ?? Comunque viene usato per la gestione della data (date2str et simila), per SpamAssassin e' usato solo dal modulo di aggiunta dei commenti, rimuovilo e non serve piu'.

sono sicurissimo che puoi inventarti qualche cosa di meglio

Comunque dopo aver letto gli scarabocchi che stanno nei sorgenti dei vari cms per i miei progetti web uso una struttura di questo genere.
url: sitoweb.url/pagina/variabili
url rewriting: traduce in index.php?qualchecosa
mainfile: index.php analizza controlla auth, pastrocchia stats, acchiappa head , pagina da elenco e foot.

In questo modo ho le fx principali "centralizzate" odio il copia-incolla

cmq davide, hai litigato con php da bambino, o sei follemente innamorato di perl?

no, ci sto litigando tutti i giorni con il PHP e con tutti gli ex-vbscriptisti-aspisti che si sono riciclati in 'guru' del PHP. Cosi' ti ritrovi con una merdacchiosa applicazione che assorbe il 210% del processore facendo 1000 query per visualizzare una jpeg.

wtf?

cosi' a naso risponderei di no

Quando l'ho visto avevo gia' finito

2) Praticamente la struttura "a directory" la vedi solo da un punto di vista delle chiamate al server, corretto? In verità, ad aprire le budella dei dati non la si ritrova visto che è tutto nei campi doc del database... Mmmmmh, mi spiace, ma non mi piace moltissimo...

A che scopo strutturare il database in un modo 'gerarchico' quando ottieni lo stesso risultato dal punto di vista operativo?

E' per quello che esistono i SSI (server side include).

huh?

Al momento nonostante molti attacchi non ho mai avuto problemi di hacker. Anche perchè non uso DB !!! Chi è curioso può vedere il timido "risultato" qui : www.perquelliche.it.

La presenza o assenza di un db non ha niente a che fare con l'hackabilita' o meno di un sito

Molto interessante la parte degli articoli ... appena posso vedo di implementarla anche sul mio sito ma ... il tempo è tiranno...
Complimenti e ... continuerò a seguirti ...

PS: anch'io sono stato tenteto di andare su google a vedere !!!

Add a comment (max 1000 chars)