dblog

Anti-spam nei commenti (senza captcha)

0.00 avg. rating (0% score) - 0 votes

Niente immagini incomprensibili, niente javascript, niente captcha, niente complicazioni: tutto semplice e trasparente. Si tratta di un metodo contro lo spam nei commenti che sto provando in questi giorni sul mio blog con buoni risultati e con uno sforzo di realizzazione davvero minimo.

L’idea non e’ mia, ma di Merlinox, e si basa sul fatto che gli spammer bot compilano tutti i campi del form per evitare i controlli sui dati obbligatori. Secondo questo concetto basta inserire nel form un campo nascosto tramite CSS in modo che le persone non possano vederlo (quindi non lo compileranno) mentre i bot lo andranno a popolare. A questo punto è sufficiente verificare il contenuto del campo di controllo: quando è valorizzato si tratta di un commento di spam.

Come realizzarlo su dBlog (o altri sistemi)?

E’ molto semplice, bastano un paio di passaggi. Prima di tutto bisogna inserire nel form dei commenti in articolo.asp, appena sotto “<form…”, questo codice:

<div style=”visibility:hidden;”>
Il seguente campo NON deve essere compilato.
<input type=”text” name=”campoNascosto” value=”” style=”width:1px;height:1px;font-size:1px;” />
</div>

infine nel file commenti_invio.asp occorre verificare la presenza di un valore nel campo e in questo caso negare l’invio. Appena sotto “If Abilita_Commenti Then” si può inserire:

If Request.Form(“campoNascosto”) = “” Then
‘esegui il resto dello script già presente
Else
‘genera un errore o utilizza uno di quelli già presenti nello script
End If

Negli ultimi giorni non ho ricevuto commenti di spam, insomma sembra funzionare. Un grazie a Merlinox che ha sviluppato il plug-in apposito per WordPress chiamato Hiddy, ma che di fatto si può velocemente adattare a qualsiasi piattaforma.

Google Sitemaps per dBlog

0.00 avg. rating (0% score) - 0 votes

Qualche tempo fa Google ha rilasciato un sistema, chiamato Google Sitemaps, che permette ai webmaster di indicare allo spider quali sono le pagine che compongono il proprio sito web, in maniera da agevolare e velocizzare l’indicizzazione, fornendo anche dettagli sull’importanza di ogni singola pagina. Google indica questo servizio come un “esperimento”, ma gli dedica spazio e risorse, tanto che nel giro di poche ore il file XML generato viene subito dato in pasto ai crawler.

Un Sitemaps che si rispetti deve essere sempre aggiornato fornendo i link a tutti gli ultimi contenuti del blog, proprio per questo motivo è scomodo doverlo modificare ad ogni aggiornamento. La soluzione è quella di creare uno script che esegua per noi questo compito in automatico.

Ecco quindi come creare un Google Sitemaps in ASP per il vostro dBlog. Prima di tutto è necessario informarsi sul progetto leggendo le pagine ufficiali in italiano, poi occorre:

  1. creare nella root del vostro blog un file chiamato sitemaps.asp ed inserire il codice che segue
  2. creare un account o eseguire l’accesso al servizio dalla pagina ufficiale di Google Sitemaps
  3. per inserire il link del vostro sitemaps e seguire la procedura indicata
  4. attendere e verificare che lo spider Google venga ad analizzare il vostro file per la prima volta

Ecco il codice da inserire nello script ASP sitemaps.asp e da posizionare nella root (cartella principale) del vostro hosting:

<!–#include virtual=”/mdb-database/inc_costanti.asp”–>
<!–#include virtual=”/dblog/inc_db.asp”–>
<!–#include virtual=”/dblog/inc_funzioni.asp”–>
<%
‘dBlog 2.0 CMS Open Source
‘FUNZIONE: questo script si occupa di generare la Google SiteMaps

‘Nell’ordine: <loc>, max 2048 caratteri <lastmod>, formato ISO8601 <changefreq>, validi always, hourly, daily, weekly, monthly, yearly, never <priority>, da 0.1 a 1.0 default 0.5
Function NodoURL(URL, UltimaModifica, FrequenzaModifica, Priorita)
Dim Risultato

Risultato = “”
Risultato = Risultato & ” <url>” & VbCrLf
Risultato = Risultato & ”  <loc>”& URL &”</loc>” & VbCrLf
Risultato = Risultato & ”  <lastmod>”& UltimaModifica &”</lastmod>” & VbCrLf
Risultato = Risultato & ”  <changefreq>”& FrequenzaModifica &”</changefreq>” & VbCrLf
Risultato = Risultato & ”  <priority>”& Priorita &”</priority>” & VbCrLf
Risultato = Risultato & ” </url>” & VbCrLf

NodoURL = Risultato
End Function

Function DataISO(Data)
Dim Risultato, Anno, Mese, Giorno

Risultato = “”

If IsDate(Data) Then
Anno = cStr(Year(Data))
Mese = cStr(Month(Data))
If Len(Mese) = 1 Then
Mese = “0” & Mese
End If
Giorno = cStr(Day(Data))
If Len(Giorno) = 1 Then
Giorno = “0” & Giorno
End If

Risultato = Anno & “-” & Mese & “-” & Giorno
End If

DataISO = Risultato
End Function

Function RecuperaDataDaFile(PercorsoRelativo)
Dim Risultato, FSO, F

Risultato = “”
Set FSO = CreateObject(“Scripting.FileSystemObject”)
If FSO.FileExists(Server.MapPath(PercorsoRelativo)) Then
Set F = FSO.GetFile(Server.MapPath(PercorsoRelativo))
Risultato = DataISO(F.DateLastModified)
End If
Set F = Nothing
Set FSO = Nothing

RecuperaDataDaFile = Risultato
End Function

Dim SQL, RS, DataUltimoContributo, DataUltimoArticolo, DataUltimaFotografia, DataUltimoLinkLog, ArrayGiorniPieni, I, DataGiaPresente

DataUltimoContributo = DataToStr(Date())
DataUltimoArticolo = DataToStr(Date())
DataUltimaFotografia = DataToStr(Date())
DataUltimoLinkLog = DataToStr(Date())

SQL = ” SELECT TOP 1 Data FROM Articoli WHERE NOT Articoli.Bozza AND Articoli.Data <= ‘”& DataToStr(Date()) &”‘ ORDER BY Articoli.Data DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

If NOT RS.EOF Then
DataUltimoArticolo = RS(“Data”)
End If

RS.Close
Set RS = Nothing

SQL = ” SELECT TOP 1 Data FROM Fotografie WHERE NOT Fotografie.Bozza AND Fotografie.Data <= ‘”& DataToStr(Date()) &”‘ ORDER BY Fotografie.Data DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

If NOT RS.EOF Then
DataUltimaFotografia = RS(“Data”)
End If

RS.Close
Set RS = Nothing

SQL = ” SELECT TOP 1 Data FROM LinkLog WHERE LinkLog.Data <= ‘”& DataToStr(Date()) &”‘ ORDER BY LinkLog.Data DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

If NOT RS.EOF Then
DataUltimoLinkLog = RS(“Data”)
End If

RS.Close
Set RS = Nothing

If DataUltimoContributo <= DataUltimoArticolo Then
DataUltimoContributo = DataUltimoArticolo
End If
If DataUltimoContributo <= DataUltimaFotografia Then
DataUltimoContributo = DataUltimaFotografia
End If
If DataUltimoContributo <= DataUltimoLinkLog Then
DataUltimoContributo = DataUltimoLinkLog
End If

DataUltimoArticolo = StrToData(DataUltimoArticolo)
DataUltimoArticolo = DataISO(DataUltimoArticolo)
DataUltimaFotografia = StrToData(DataUltimaFotografia)
DataUltimaFotografia = DataISO(DataUltimaFotografia)
DataUltimoLinkLog = StrToData(DataUltimoLinkLog)
DataUltimoLinkLog = DataISO(DataUltimoLinkLog)
DataUltimoContributo = StrToData(DataUltimoContributo)
DataUltimoContributo = DataISO(DataUltimoContributo)

Response.ContentType = “text/xml”
Response.Write “<?xml version=””1.0″” encoding=””UTF-8″”?>” & VbCrLf
Response.Write “<urlset xmlns=””http://www.google.com/schemas/sitemap/0.84“”>” & VbCrLf

‘\
Response.Write NodoURL(URL_Sito & “/default.asp”, RecuperaDataDaFile(“/default.asp”), “monthly”, “0.9”)

‘\dblog
SQL = ” SELECT Articoli.Sezione FROM Articoli WHERE Articoli.Data <= ‘”& DataToStr(Date()) &”‘ AND Articoli.Bozza = False GROUP BY Articoli.Sezione “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “storico.asp?s=” & Server.URLEncode(RS(“Sezione”)), DataUltimoArticolo, “daily”, “0.7”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

SQL = ” SELECT ID, Titolo, Data FROM Articoli WHERE Articoli.Data <= ‘”& DataToStr(Date()) &”‘ AND NOT Articoli.Bozza ORDER BY Articoli.Data DESC, Articoli.Ora DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “articolo.asp?articolo=” & RS(“ID”), DataISO(StrToData(RS(“Data”))), “hourly”, “1.0”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

SQL = ” SELECT Nick  FROM Autori ORDER BY Autori.Nick “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “autori.asp?chi=” & Server.URLEncode(RS(“Nick”)), DataUltimoContributo, “monthly”, “0.6”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

Response.Write NodoURL(URL_Blog & “classifica.asp”, DataUltimoContributo, “hourly”, “0.5”)
Response.Write NodoURL(URL_Blog & “default.asp”, DataUltimoContributo, “always”, “1.0”)
Response.Write NodoURL(URL_Blog & “feedatom.asp”, DataUltimoContributo, “hourly”, “1.0”)
Response.Write NodoURL(URL_Blog & “feedrss.asp”, DataUltimoContributo, “hourly”, “1.0”)

SQL = ” SELECT Sezione FROM Fotografie WHERE Fotografie.Data <= ‘”& DataToStr(Date()) &”‘ GROUP BY Sezione ORDER BY Sezione ASC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “foto.asp?s=” & Server.URLEncode(RS(“Sezione”)), DataUltimaFotografia, “daily”, “0.7”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

SQL = ” SELECT Fotografie.ID, Fotografie.Data FROM Fotografie WHERE Fotografie.Data <= ‘”& DataToStr(Date()) &”‘ AND NOT Fotografie.Bozza ORDER BY Fotografie.Data DESC, Fotografie.Ora DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “fotografia.asp?id=” & RS(“ID”), DataISO(StrToData(RS(“Data”))), “hourly”, “1.0”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

Response.Write NodoURL(URL_Blog & “linklog.asp”, DataUltimoContributo, “hourly”, “0.7”)

ReDim ArrayGiorniPieni(0, -1)

SQL = ” SELECT Data FROM Articoli WHERE NOT Articoli.Bozza AND Articoli.Data <= ‘”& DataToStr(Date()) &”‘ ORDER BY Articoli.Data DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
ReDim Preserve ArrayGiorniPieni(0, UBound(ArrayGiorniPieni, 2) + 1)
ArrayGiorniPieni(0, UBound(ArrayGiorniPieni, 2)) = RS(“Data”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

SQL = ” SELECT Data FROM Fotografie WHERE NOT Fotografie.Bozza AND Fotografie.Data <= ‘”& DataToStr(Date()) &”‘ ORDER BY Fotografie.Data DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
DataGiaPresente = False
For I = 0 To UBound(ArrayGiorniPieni, 2)
If ArrayGiorniPieni(0, I) = RS(“Data”) Then
DataGiaPresente = True
Exit For
End If
Next

If NOT DataGiaPresente Then
ReDim Preserve ArrayGiorniPieni(0, UBound(ArrayGiorniPieni, 2) + 1)
ArrayGiorniPieni(0, UBound(ArrayGiorniPieni, 2)) = RS(“Data”)
End If

RS.MoveNext
Loop

RS.Close
Set RS = Nothing

For I = 0 To UBound(ArrayGiorniPieni, 2)
Response.Write NodoURL(URL_Blog & “pubblicazioni.asp?d=” & ArrayGiorniPieni(0, I), DataISO(StrToData(ArrayGiorniPieni(0, I))), “daily”, “0.7”)
Next

SQL = ” SELECT ID FROM Sondaggio ORDER BY Sondaggio.ID DESC “
Set RS = Server.CreateObject(“ADODB.Recordset”)
RS.Open SQL, Conn, 1, 3

Do While NOT RS.EOF
Response.Write NodoURL(URL_Blog & “risultati.asp?id=” & RS(“ID”), DataUltimoContributo, “hourly”, “0.6”)
RS.MoveNext
Loop

RS.Close
Set RS = Nothing

Response.Write “</urlset>”

Conn.Close
Set Conn = Nothing
%>

Si tratta di un codice esemplificativo ma funzionante, per qualsiasi miglioramento o segnalazione utilizzate il Forum tecnico (discontinued) dove già si discute della cosa.

SEO: un Mod Rewrite in ASP

0.00 avg. rating (0% score) - 0 votes

Sappiamo tutti che i principali motori di ricerca non gradiscono indicizzare le pagine che contengono dei parametri nell’indirizzo (url), in particolare pagine dinamiche con parametri numerici, come gli ID.

Per risolvere questo problema gli sviluppatori hanno adottato diverse tecniche tra cui quella di modificare dinamicamente l’indirizzo di una pagina web in maniera da farla sembrare “statica” e senza parametri. Questa soluzione si chiama “rewrite” ed indica l’utilizzo di un software, installato sul Web Server, in grado di modificare l’url di una pagina web con lo scopo (prevalente) di migliorare l’indicizzazione sui motori di ricerca.

Grazie all’utilizzo di questo metodo possiamo partire da un indirizzo come

http://www.dblog.it/dblog/articolo.asp?articolo=510

per arrivare ad ottenere un indirizzo come

http://www.dblog.it/dblog/viva-il-peru.asp

sicuramente più apprezzato dagli spider perché non ci sono parametri numerici ed inoltre il nome del file contiene alcune parole importanti per identificare il contenuto della pagina stessa.

Questa tecnica viene sfruttata principalmente sul Web Server Apache perché dispone di un rewrite engine chiamato “mod_rewrite“. Sui Web Server IIS invece occorre installare un filtro ISAPI come ad esempio il motore “ISAPI_rewrite” o “URL Replacer“. Ma nel caso in cui il provider non abbia la minima intenzione di installare questi software su Internet Information Server? Nessun problema: rimbocchiamoci le maniche e proviamo a confezionare la nostra soluzione 🙂

Per sviluppare un semplice motore di URL Rewriting in ASP con VBSCript dobbiamo partire da una considerazione di fondo: non potendo gestire la traduzione dinamica degli indirizzi web né la loro interpretazione (compiti demandati ad una libreria del Web Server IIS a cui, tramite ASP, non abbiamo accesso) un possibile escamotage consiste nella creazione di pagine fittizie collegate al contenuto reale.

L’idea è quella di sfruttare i contenuti dinamici memorizzati nel database, ma far credere agli spider che non sia così; allo stesso tempo dobbiamo però mantenere la comodità di una struttura gestibile da Pannello di controllo remoto. Per offrire questa garanzia non possiamo salvare il testo all’interno delle pagine fittizie, bisogna trovare un modo per collegarle al DataBase. Una soluzione è quella di salvare l’ID dell’articolo come variabile direttamente nella pagina fittizia e poi sfruttare una query per recuperare i dati e mostrarli nella pagina. Idee confuse? 😀 Passiamo a qualcosa di più pratico per semplificare.

Per una struttura di articoli servono:
– un database con la tabella articoli
– nella tabella articoli un campo ID univoco/contatore, un campo titolo e un campo testo
– una cartella con permessi di scrittura (es. \public) dove salvare le pagine fittizie

Supponendo di sfruttare un database già disponibile e di aver inserito la connessione nel file chiamato inc_db.asp, possiamo passare alla creazione del nostro primo script, il più importante, da salvare nella root insieme ad inc_db.asp:

inc_pagina.asp

<!–#include virtual=”/inc_db.asp”–><%

If VarID <= 0 Then

VarID = 0

End If SQL = ” SELECT Titolo, Testo FROM Tabella WHERE Tabella.ID = “& VarID &” “

Set RS = Server.CreateObject(“ADODB.Recordset”)

RS.Open SQL, Conn, 1, 3

If NOT RS.EOF Then

RSTitolo = RS(“Titolo”)

RSTesto = RS(“Testo”)

Else

RSTitolo = “”

RSTesto = “”

End If

RS.Close

Set RS = Nothing

Conn.Close

Set Conn = Nothing

%>

<html>

<head>

<title><%=RSTitolo%></title>

</head>

<body>

<strong><%=RSTitolo%></strong>

<br /><%=RSTesto%>

</body>

</html>

Lo script inc_pagina.asp verrà automaticamente incluso nelle pagine fittizie e lavorerà in modo da sfruttare la variabile VarID, valorizzata in maniera statica dentro ognuna di queste pagine. In sostanza non fa nient’altro che leggere la VarID ed utilizzarla per recuperare Titolo/Testo dalla tabella Articoli, per poi mostrarli nella pagina come se si trattasse di un semplice HTML statico.

Nella cartella \public avremo ovviamente salvato tutte le pagine fittizie i cui nomi saranno composti secondo la sintassi IDNumerico-titolo-dell-articolo.asp, ad esempio:

510-viva-il-peru.asp

<%VarID = 510

%>

<!–#include virtual=”/inc_pagina.asp”–>

Mancano infine i due script nel Pannello di controllo per la creazione di un nuovo articolo e la modifica di uno già esistente. Nel primo caso è molto semplice: si procederà con il classico inserimento nel DataBase ed aggiungeremo la successiva creazione della pagina fittizia.

aggiungi.asp

 ‘…’In precedenza abbiamo inserito il record nel DataBase Set FSO = CreateObject(“Scripting.FileSystemObject”)

Set Documento = FSO.OpenTextFile(Server.MapPath(“/public/”) & “\” & ConvertiTitoloInNomeScript(FTitolo, IDArticolo), 2, True)

ContenutoFile = “”

ContenutoFile = ContenutoFile & “<” & “%” & vbCrLf

ContenutoFile = ContenutoFile & “VarID = “& IDArticolo &”” & vbCrLf

ContenutoFile = ContenutoFile & “%” & “>” & vbCrLf

ContenutoFile = ContenutoFile & “<!–#include virtual=””/inc_pagina.asp””–>”

Documento.Write ContenutoFile

Set FSO = Nothing

In sostanza si crea un normale file di testo con estensione .asp nella cartella \public e si inserisce dentro una stringa di testo che andrà a comporre il codice ASP, come se l’avessimo scritto a mano. La funzione ConvertiTitoloInNomeScript si occupa invece di creare il nome per il file partendo dal Titolo dell’articolo e dall’ID, per recuperarlo in modo univoco quando necessario. Ecco un primo esempio, assolutamente da ampliare, per questa funzione:

Function NoHTML(Stringa)Set RegEx = New RegExp

RegEx.Pattern = “<[^>]*>”

RegEx.Global = True

RegEx.IgnoreCase = True

NoHTML = RegEx.Replace(Stringa, “”)

End Function

Function ConvertiTitoloInNomeScript(Titolo, IDArticolo)

Risultato = Titolo

Risultato = NoHTML(Risultato)

Risultato = LCase(Risultato)

Risultato = Replace(Risultato, ” “, “-“)

Risultato = Replace(Risultato, “\”, “-“)

Risultato = Replace(Risultato, “/”, “-“)

Risultato = Replace(Risultato, “:”, “-“)

Risultato = Replace(Risultato, “*”, “-“)

Risultato = Replace(Risultato, “?”, “-“)

Risultato = Replace(Risultato, “<“, “-“)

Risultato = Replace(Risultato, “>”, “-“)

Risultato = Replace(Risultato, “|”, “-“)

Risultato = Replace(Risultato, “”””, “”)

Risultato = Replace(Risultato, “‘”, “-“)

‘…ulteriori controlli a piacere, il migliore include solo a..z e 0..9

Risultato = IDArticolo & “-” & Risultato & “.asp”

ConvertiTitoloInNomeScript = Risultato

End Function

Infine la pagina di modifica di un articolo già presente nel DataBase conterrà del codice aggiuntivo solo nel caso in cui venga modificato il Titolo. Nello specifico dovrà eseguire una query per caricare i dati necessari (quindi ID e Titolo dell’articolo) ad identificare in modo univoco la pagina fittizia collegata, procedere alla cancellazione della vecchia pagina e quindi alla creazione di quella nuova, così:

modifica.asp

 ‘…’In precedenza abbiamo controllato che il titolo sia stato modificato e quindi effettuato la query di Update Set FSO = CreateObject(“Scripting.FileSystemObject”)

If FSO.FileExists(Server.MapPath(“/public/”) & “\” & ConvertiTitoloInNomeScript(FTitoloVecchio, QSID)) Then

Set Documento = FSO.GetFile(Server.MapPath(“/public/”) & “\” & ConvertiTitoloInNomeScript(FTitoloVecchio, QSID))

Documento.Delete

Set Documento = Nothing

End If

Set Documento = FSO.OpenTextFile(Server.MapPath(“/public/”) & “\” & ConvertiTitoloInNomeScript(FTitolo, QSID), 2, True)

ContenutoFile = “”

ContenutoFile = ContenutoFile & “<” & “%” & vbCrLf

ContenutoFile = ContenutoFile & “VarID = “& QSID &”” & vbCrLf

ContenutoFile = ContenutoFile & “%” & “>” & vbCrLf

ContenutoFile = ContenutoFile & “<!–#include virtual=””/inc_pagina.asp””–>”

Documento.Write ContenutoFile

Set Documento = Nothing

Set FSO = Nothing

Nella nuova veste del mio blog personale ho utilizzato proprio questa tecnica, modellandola sulle mie necessità e per adesso non ho riscontrato nessun tipo di problema.
Mi piacerebbe sentire cosa ne pensate, a voi la parola.

Qui una versione scaricabile del codice Mod Rewrite ASP.
Nel sito di Wikipedia maggiori dettagli sul Mod Rewrite (in inglese).

Nuova grafica

0.00 avg. rating (0% score) - 0 votes

Ed ecco finalmente pubblicato il nuovo layout del mio blog personale: non ce la facevo più, eheh! La prima cosa che salta all’occhio è il passaggio a 3 colonne, ma navigando meglio vi accorgerete che si tratta solo della home page. Ho spostato un po’ di contenuti cercando di privilegiare i commenti e l’interazione, visto che siamo ufficialmente nell’era del web 2.0 😀

Il mio blog personale... prima     Il mio blog personale... ora!

La fotografia nell’intestazione ora è fissa, ma cambierà con gli eventi… l’idea iniziale era di farla cambiare ogni ora, simulando lo scorrere del tempo, ma non ho mica trovato 24 fotografie decenti di sole e luna. Qualcuno mi suggerisce una buona fonte?

La ricerca è stata posizionata in alto all’interno di ogni pagina del sito ed ho aggiunto una semplice routine simile al “Forse cercavi…” di Google (sottolineo il simile con fare ironico). La capacità di suggerire alternative valide dovrebbe migliorare col tempo, man mano che vengono effettuate delle ricerca sul blog.

Le categorie degli articoli e delle foto adesso dispongono di un comodo contatore per sapere quanti oggetti aspettarsi dopo il clic di ingresso. Appena sotto troviamo la Tag cloud che mostra i tag associati agli articoli con maggiore frequenza (minimo 2 volte), grazie a questo spazio si può risalire grossomodo agli argomenti principali del blog. Poi una serie di link interni ed ovviamente i Feed.

Sempre in home page vengono mostrati gli ultimi 7 post (articoli) che, grazie alla dimensione diversa dei font, offrono un primo breve percorso cronologico di quello che è già stato archiviato nelle sezioni del blog. Inoltre i contenuti sono sempre posizionati in maniera da poter iniziare a leggere senza far scorrere la pagina ed hanno uno spazio maggiore in larghezza di circa 60-70 pixel. Una intera colonna è stata poi dedicata agli ultimi commenti, con una preview testuale e il link all’articolo o alla fotografia di riferimento, cercando di stimolare la discussione.

Appena sotto ecco un’altra novità: le ultime immagini pubblicate nel fotoblog, che assume quindi maggiore importanza rispetto alla precedente versione del blog. Di seguito il linklog che perde valore rispetto a prima (era posizionato in alto) perché non prevede ancora spazi interattivi, ma viene solo utilizzato come area di segnalazione.

In home page manca ancora una sezione, ma si tratterà di una semplice area di invito all’utilizzo di dBlog CMS Open Source con link al download, manuale, forum, laboratorio, etc. Invece come ultimo modulo prende forma un blogroll degno di questo nome, seguito dalle note di copyright e l’indicazione della piattaforma utilizzata. La dimensione della home page è diminuita di 25-30 Kb ed anche il numero di schermate è stato dimezzato.

Nelle sottopagine lascio a voi scoprire qualche novità, vi segnalo quella più importante ovvero l’integrazione di una struttura orientata ai motori di ricerca tramite una simulazione del “mod rewrite” (scriverò un lungo post su questo argomento domani o dopo): provate a cliccare su un articolo e date un’occhiata all’indirizzo che compare sul vostro browser! Ma non solo: a breve ci sarà il trackback, fin da ora c’à la nuova area “Similitudini” dove vengono caricati automaticamente gli articoli che trattano gli stessi argomenti e… va beh, non voglio rovinarvi altre sorprese 😀

Ho già fatto un giro di testing con Explorer 6 e con Firefox 1.5, per il primo tutto ok, mentre per la volpe ho dei problemi sull’allineamento delle thumbnail del fotoblog, ma vedrò di risolvere nei prossimi giorni. Se qualcuno ha modo di fare un test con Explorer 7 e/o con altri sistemi mi aiuterebbe molto…

Infine non posso dimenticarmi di dire che le immagini dei 2 cucciolotti non sono scattate da me: il boxer fa parte di una foto ritagliata e scontornata presente su Google Image, mentre il carlino proviene dal sito ugoclub.com a cui ho già scritto una mail. Allo stesso modo la cornice delle foto in home page era originariamente una gif di cui purtroppo non ricordo la provenienza 😛 Invece per la strutturazione dei contenuti, la griglia della homa page ed alcune funzionalità ho liberamente preso spunto estetico da 5 blog: Downloadblog, Stopdesign, Jayber, Themaninblue e Sitepoint.

E ora… passo la parola e attendo i vostri pareri.

Tag Cloud in ASP

0.00 avg. rating (0% score) - 0 votes

Partendo dal codice in Cold Fusion presente qui sul blog Edit e da quello in PHP qui su blog di Augusto ho scritto velocemente qualche riga per realizzare una Tag Cloud in ASP, come accennavo in un post di qualche giorno fa.

Il codice si basa sulla presenza di una tabella chiamata “Technorati” contenente tutti i Tag utilizzati. Lo script è sicuramente migliorabile (specie nel doppio ciclo), quindi se fate qualche modifica segnalatela nei commenti così da poter aggiornare il tutto ed ottimizzare la routine. Ecco il codice in VBScript:

Dim SQLTagCloud, RSTagCloud, ArrayTag, I, FrequenzaMin, FrequenzaMax, FrequenzaDiff, FrequenzaDistrib, CSSClass, FrequenzaFiltroFrequenzaFiltro = 2SQLTagCloud = ” SELECT COUNT(Tag) AS Frequenza, Tag FROM Technorati GROUP BY Tag “
Set RSTagCloud = Server.CreateObject(“ADODB.Recordset”)
RSTagCloud.Open SQLTagCloud, Conn, 1, 3

If NOT RSTagCloud.EOF Then
ArrayTag = RSTagCloud.GetRows
Else
ReDim ArrayTag(1, -1)
End If

RSTagCloud.Close
Set RSTagCloud = Nothing

If UBound(ArrayTag, 2) > -1 Then
FrequenzaMin = 1
FrequenzaMax = 1

For I = 0 To UBound(ArrayTag, 2)
If ArrayTag(0, I) < FrequenzaMin Then
FrequenzaMin = ArrayTag(0, I)
End If
If ArrayTag(0, I) > FrequenzaMax Then
FrequenzaMax = ArrayTag(0, I)
End If
Next

If FrequenzaMin < FrequenzaFiltro Then
FrequenzaMin = FrequenzaFiltro
End If

FrequenzaDiff = FrequenzaMax – FrequenzaMin
FrequenzaDistrib = FrequenzaDiff / 5

For I = 0 To UBound(ArrayTag, 2)
If ArrayTag(0, I) >= FrequenzaFiltro Then
If ArrayTag(0, I) = FrequenzaMin Then
CSSClass = “tcmpiccolo”
ElseIf ArrayTag(0, I) = FrequenzaMax Then
CSSClass = “tcmgrande”
ElseIf ArrayTag(0, I) > FrequenzaMin + (FrequenzaDistrib * 2) Then
CSSClass = “tcgrande”
ElseIf ArrayTag(0, I) > FrequenzaMin + FrequenzaDistrib Then
CSSClass = “tcmedio”
Else
CSSClass = “tcpiccolo”
End If

Response.Write “<a href=””cerca.asp?cosa=”& Server.URLEncode(ArrayTag(1, I)) &””” title=””Tag: “& Server.HTMLEncode(ArrayTag(1, I)) &” | Frequenza: “& ArrayTag(0, I) &””” class=”””& CSSClass &”””>” & ArrayTag(1, I) & “</a> “
End If
Next
End If

Invece nel foglio di stile andranno aggiunte le seguenti righe:

  a.tcmpiccolo { font-size: xx-small; }
a.tcpiccolo { font-size: small; }
a.tcmedio { font-size: medium; }
a.tcgrande { font-size: large; }
a.tcmgrande { font-size: xx-large; }
1 2  Torna su