Potete scaricare qui la mia funzione dateAdd in JS.

Funzionamento

Utilizzare la funzione è semplicissimo: a seguito alcuni esempi.

/* Sommare 10 ore all'ora di oggi */
ora_nuova = addInterval(new Date(), 'h', 10);

/* Sommare 300 secondi all'ora di prima */
ora_nuova2 = addInterval(ora_nuova, 's', 300);

Semplice, non credete?

Dopo tanto tempo torno a pubblicare un articolo di programmazione, anche se banale, semplice e magari da tanti già utilizzato.

<%
' inserisci qui l'url della pagina da caricare
urlDaAprire = "http://url.protected.com/file-to-retrieve.txt" 

' creiamo un oggetto xml
Set miaConnessione = CreateObject("Microsoft.XMLHTTP")
' connessione alla nostra url
miaConnessione.Open "get", urlDaAprire, false, "username", "password"

miaConnessione.Send 

' ResponsePage è il contenuto dell'interrogazione all'indirizzo
ResponsePage = miaConnessione.responseText
Set miaConnessione = Nothing

' We will write
strPath = Server.Mappath("./nomeFileLocale.txt")
Set conFile = Server.CreateObject ("Scripting.FileSystemObject")
Set mioFile = conFile.OpenTextFile (strPath, 2)

mioFile.Write(ResponsePage)

mioFile.close
Set mioFile = Nothing
Set conFile = Nothing
%>

Username e Password non sono necessari. Nel caso che il file remoto che dovete utilizzare è libero e non richiede permessi, cancellate semplicemente gli ultimi 3 parametri alla riga 7, ottenendo

miaConnessione.Open "get", urlDaAprire

Come sempre, spero di esservi stato utile!

Symfony, ormai noto framework per lo sviluppo di applicazioni web, tra le tante funzioni messe a disposizione degli utenti, fornisce Generatori (a cui viene dedicato l’intero capitolo 14 di “The definitive guide to Symfony”, libro acquistabile su carta stampata o anche consultabile direttamente online) per due differenti metodi di “managing” dei dati.

I generatori messi a disposizione dal symfony-project sono:

• generatori per lo scaffolding
• generatori per l’amministrazione

Potremmo dire, in maniera molto semplice che gli scaffolding module vengono creati ad uso e consumo degli sviluppatori, mentre il modulo backend per l’amministrazione viene creato per l’utente finale. Lo scaffolding code è modificato manualmente, mentre i pannelli di amministrazione vengono modificati attraverso i documenti di configurazione e l’ereditarietà delle classi.

Generatori per lo scaffolding

Lo scaffolding è la generazione della struttura di base (actions e templates) richieste per gestire ed eseguire un’interfaccia CRUD. Il codice di scaffolding è minimale e va visto come codice di partenza per la creazione delle vostre applicazioni.

Non a caso, il termine scaffolding è stato utilizzato, come si dice su Wikipedia,

metaforicamente per indicare quelle strategie di sostegno ai processi di apprendimento che consentono di svolgere un compito sebbene non si abbiano ancora le competenze per farlo in autonomia, quindi di riuscire nel compito grazie all’aiuto di un esperto, di un adulto o di un pari più preparato che ci fornisce indicazioni e suggeriment

Ecco quindi che l’utilizzo del generatore di scaffolding andrebbe utilizzato per creare rapidamente tutte le funzioni di accesso web ai dati della base di dati, in particolar modo durante le prime fasi di creazione di un’applicazione.

Per generare questa impalcatura (scaffolding) in symfony si utilizza la chiamata alla funzione

> symfony propel-generate-crud nome_applicazione nome_modulo NomeClasse
> symfony propel-init-crud nome_applicazione nome_modulo NomeClasse

dove NomeClasse è la definizione dei dati inserita nel file schema.yml.

Generatori per l’amministrazione

La generazione dell’amministrazione (tipicamente chiamata backend administration) è la creazione di una sofisticata interfaccia per la gestione dei dati. La presentazione è enfatizzata per il codice di amministrazione (vis-a-vis scaffolding code). Vengono offerti metodi per l’ordinamento, la paginazione, filtri e altre features tipicamente utilizzate nelle interfacce di amministrazione.

Oltre a queste funzioni, tutte le funzioni di CRUD (creazione, visualizzazione, aggiornamento e cancellazione dei records) vengono implementate correttamente.

La generazione di questa intera area backend è in “mano” alla funzione

> symfony init-app nome_applicazione
> symfony propel-init-admin nome_applicazione nome_modulo NomeClasse

Il framework che ho scelto di usare (di cui vi ho già anticipato nell’ultimo articolo) è Symfony Project, un framework per lo sviluppo in PHP. E se in questi giorni avevo già visto come creare un progetto, un applicazione ed un modulo per la gestione dei dati, oggi mi sono “allargato”, andando a creare il mio “primo backend” con Symfony con l’integrazione del database MySQL.

Programmare con un framework diventa decisamente più veloce (che non vuol dire semplice), anche se si mettono in gioco decine e decine di files differenti. Un area di editing di tipo CRUD (Create, Read, Update e Delete) che, per un programmatore base prevede la creazione dai 4 documenti differenti in su (non conto tra questi i file di layout e/o simili), attraverso un framework MVC il numero dei files sale vertiginosamente…

Unico problema è riuscire a ricordarsi correttamente dove modificare cosa e come modificare le stesse pagine… Ma appreso il meccanismo, tutto diventa velocissimo!!!

Voi avete provato?

Uno dei suggerimenti dati da Adobe è quello di “evitare l’uso di parole riservate quali ‘date’, ‘name’, ‘select’, ‘where’ e ‘level’ quando si specificano i nomi delle colonne del database“, d’accordo, ma…probabilmente la parola chiave, riservata, che voi state cercando di usare come nome di un campo del vostro database e che vi solleva l’errore 80040e14 è password, come troppo spesso è capitato durante la programmazione e il salvataggio degli utenti!!!

Quindi, provate ad utilizzare una parola chiave tipo pwd, che sempre sta per password, ma che almeno non vi solleva errori nell’istruzione INSERT INTO!

Buona programmazione!!!

Visto che ci bazzicavo spesso ed era parecchio tempo che non programmavo in PHP, ecco due comode funzioni per sistemare le date: convertToMySQL() e convertToSimple().

function convertToMySQL($mydate) {
    list($dd,$mm,$yy)=explode(".",$mydate);
    if (is_numeric($yy) && is_numeric($mm) && is_numeric($dd)) {
      return "$yy-$mm-$dd";
    }
}

function convertToSimple($mydate) {
list($yy,$mm,$dd)=explode("-",$mydate);
    if (is_numeric($yy) && is_numeric($mm) && is_numeric($dd)) {
      return "$dd.$mm.$yy";
    }
}

Problema

Per pigrizia ho chiesto allo stesso Stefano di mandarmi il suo script pronto, così da provarlo e capire cosa non andasse. Le due pagine di test ricevute erano:

• pagina con editor di testo ad uso dell’amministratore del sito
• pagina di retrieve (recupero) dei dati inviati per visualizzazione anteprima

Area amministrativa con editor WYSIWYG

<html>
<head>
<title>Prova News</title>
<script language="javascript" type="text/javascript" src="<?php $basedir ?>/script/tiny_mce/tiny_mce.js"></script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
mode : "textareas",
theme : "advanced",
plugins : "safari,pagebreak,style,layer,table,save,advhr,advimage,advlink,emotions,iespell,inlinepopups,insertdatetime,preview,media,searchreplace,print,contextmenu,paste,directionality,fullscreen,noneditable,visualchars,nonbreaking,xhtmlxtras,template",

// Theme options
theme_advanced_buttons1 : "save,newdocument,|,bold,italic,underline,strikethrough,|,justifyleft,justifycenter,justifyright,justifyfull,|,styleselect,formatselect,fontselect,fontsizeselect",
theme_advanced_buttons2 : "cut,copy,paste,pastetext,pasteword,|,search,replace,|,bullist,numlist,|,outdent,indent,blockquote,|,undo,redo,|,link,unlink,anchor,image,cleanup,help,code,|,insertdate,inserttime,preview,|,forecolor,backcolor",
theme_advanced_buttons3 : "tablecontrols,|,hr,removeformat,visualaid,|,sub,sup,|,charmap,emotions,iespell,media,advhr,|,print,|,ltr,rtl,|,fullscreen",
theme_advanced_buttons4 : "insertlayer,moveforward,movebackward,absolute,|,styleprops,|,cite,abbr,acronym,del,ins,attribs,|,visualchars,nonbreaking,template,pagebreak",
theme_advanced_toolbar_location : "top",
theme_advanced_toolbar_align : "left",
theme_advanced_statusbar_location : "bottom",
theme_advanced_resizing : true,
apply_source_formatting : true
});
</script>
</head>
<body>
<form method="post" action="<?php $basedir ?>/vediNews.php">
<textarea name="content" cols="50" rows="15">Scrivi News.</textarea>
<input type="submit" value="Salva" />
</form>
</body>
</html>

Visualizzazione della news inviata

<html>
<head>
<title>Visualizzazione News</title>
</head>
<body>
<?=$_POST['content'] ?>
</body>
</html>

Il problema, dopo aver inviato il contenuto dell’editor di testo, riportando la frase del ragazzo che mi ha contattato, è che

[...] viene rispettata solo la formattazione quale grassetto, corsivo, sottolineato, mentre ignorati i cambi di colore, carattere ecc ecc… [...]

Soluzione

Analizzando il codice di output ho notato, stupido che non ci ho pensato prima, a come le variabili passate da un FORM e recuperate attraverso gli operatori $_GET e $_POST di PHP, aggiungono automaticamente slash ( \ ) prima degli apici singoli ( ‘ ) e doppi ( ” ) per evitare di interpretare le stesse all’interno del codice PHP, evitando così problemi ancora maggiori, come la “rottura” di query che crea problemi di sicurezza.

Per risolvere così il “problema”, basta allora utilizzare la funzione PHP stripslashes, che restituisce il risultato privo di slash ( \ ), mostrando così il contenuto del FORM pulito e correttamente interpretabile da tutti i browser.

<?=stripslashes($_POST['testo'])?>

TinyMCE: cos’è?

Giusto per dare una forma completa questo post, voglio enunciare, a chi non è nel settore, cos’è questo TinyMCE di cui in questo post cerco di farne una piccola guida all’installazione. Il primo paragrafo del sito del produttore Moxiecode, recita:

TinyMCE is a platform independent web based Javascript HTML WYSIWYG editor control released as Open Source under LGPL by Moxiecode Systems AB. It has the ability to convert HTML TEXTAREA fields or other HTML elements to editor instances. TinyMCE is very easy to integrate into other Content Management Systems.

TinyMCE è una piattaforma web per l’editing HTML con controlli WYSIWYG indipendente scritta in Javascript e rilasciata con licenza Open Source sotto LGPL da Moxiecode Systems AB. Ha l’abilità di convertire i campi HTML TEXTAREA o altri elementi HTML in istanze di editor. TinyMCE è veramente semplice da integrare nei Content Management Systems (Sistemi di Gestione del Contenuto).

In poche parole vi permette di ottenere quello che vedete qui in immagine:

Scarica TinyMCE (download)

TinyMCE si può scaricare come archivio compresso direttamente dalla sezione download del sito Moxiecode. Le versioni scaricabili sono quasi sempre due distinte, una RC (Release Candidate) ed una versione stabile (Stable – oggi la versione 2.1.3). La differenza è che la versione in Release Candidate è quasi definitiva, in attesa delle ultime correzioni da parte del gruppo di sviluppatori (una sorta di fine del beta-testing).

Le versioni TAR GZip e ZIP corrispondono a differenti sistemi di compressione: se non sapete quale dei due scaricare, scaricate la vesione ZIP.

Oltre al download del pacchetto dell’applicativo vi sono anche i pacchetti di compressione GZip per rendere più veloce lo scaricamento e la conseguente apertura dell’editor HTML. Questo pacchetto di compressione in molti casi, se presente, va disabilitato perchè genera un errore tipo “realTinyMCE is not defined“.

Aggiungere TinyMCE ad un sito (installazione)

L’integrazione di TinyMCE in un sito web è, come detto da Moxiecode, decisamente semplice. Dopo aver scaricato l’archivio contentente la piattaforma e la sua documentazione, estraete solamente la cartella “tiny_mce” contenuta in “tinymce/jscripts/” e salvatela nella root (cartella di base) del vostro sito.

A questo punto inserite questa stringa nell’instestazione delle pagine prima del tag </head>:

...
<script src="tiny_mce/tiny_mce.js" language="javascript" type="text/javascript">
</script>
<script language="javascript" type="text/javascript">
tinyMCE.init({
 mode : "textareas"
});
</script>

L’integrazione, con l’aggiunta di queste semplici righe di codice, è già finita: passiamo ora alle personalizzazioni del tool.

Configurazione di TinyMCE

Lo spaccato di codice inserito nella sezione di installazione va ad inizializzare l’editor WYSIWYG su tutti i campi <textarea> presenti nella pagina (mode : "textareas"): altre opzioni per il parametro mode sono specific_textareas che converte solo le textarea con un trigger impostato su true, exact che converte solo una determinata textarea o div e none che non converte nulla (utile se si imposta un pulsante per l’attivazione dello script).

Dopo la “modalità di integrazione”, molto importante è la gestione delle toolbar con i pulsanti, anch’esse molto semplici da gestire. E’ infatti questa la sezione necessaria per personalizzare tinyMCE.

Esistono due differenti profili (themes – temi) per la configurazione dei pulsanti: simple e advanced. La versione semplice non prevede modifiche ai pulsanti e integra di base i pulsanti più comuni e importanti quali grassetto (bold), corsivo (italic) e sottolineato (underline) insieme agli elenchi puntati/numerati e la gestione dei links.

La versione advanced, invece, permette una configurazione molto più ampia. Consiglio, per comodità, di utilizzarla e impostare manualmente solo i “pulsanti” interessati attraverso questo script di configurazione (non mettendo nulla non viene visualizzata l’intera riga di pulsanti, vedi theme_advanced_buttons3):

tinyMCE.init({
  ...
  theme : "advanced",theme_advanced_buttons1 : "inserttime,preview,zoom,separator,forecolor",
  theme_advanced_buttons2 : "bullist,numlist,separator,outdent,indent,separator",
  theme_advanced_buttons3 : ""
});

Vi è poi la possibilità di gestire anche i così detti plug-in in grado di rendere completamente personalizzato l’editor WYSIWYG (TinyMCE ne ha davvero molti) ma, la mia piccola guida diventerebbe un libro. Se avete dubbi o perplessità non esistate a chiedere informazioni, sono qui per questo!

Premetto che ho preso in considerazione la versione Lite (che tra l’altro è anche completamente gratuita!!) che permette solamente di configurare un unico sito per server, ma offre tutte le funzionalità di riscrittura degli URL. Dopo aver installato la componente, potrete vedere nella sua directory solamente 3 file (httpd.ini, ISAPI_Rewrite.dll e RxTest.exe): se avete utilizzato la versione autoinstallante, l’unica cosa che dovrete cominciare a fare è compilare il file httpd.ini esattamente come il file .httaccess in Server Apache: RewriteCond e RewriteRule sono molto simili, cambiano solo le lettere per dichiarare le opzioni di reindirizzamento di cui parlerò in seguito.

Preparativi per l’URL Rewrite

Innanzitutto è opportuno configurare il proprio sito web secondo una certa logica per non ritrovarsi a lavorare milioni di volte. Evitiamo dunque di scrivere direttamente i link all’interno delle pagine web (che, per carità, se utilizziamo un distema dinamico potrebbero essere anche poche) e utilizziamo invece una funzione che creeremo ad hoc (per motivi sempre di praticità, consiglio di crearla su un file esterno da importare attraverso la direttiva <!–#import virtual=”nomefile.asp”–>).

La funzione, che prende in ingresso 3 parametri, potrebbe essere così definita:

url_rewrite = false
function getURL(par1, par2, par3)
if( url_rewrite ) then
...scrivo URL in bella forma
else
...scrivo URL normale, con QueryString
end if
getURL = URL
end function

Una funzione così strutturata mi permetterà di avere due diversi modi di riscrittura, quello normale (con parametri passati per GET nella QueryString insomma) e quella da riscrivere tramite l’ausilio della nostra componente. E tutto sarà semplicemente fattibile modificando la variabile url_rewrite: false per il sistema classico e true per il sistema riscritto e più “bello”!!!

Configurare l’URL Rewrite nel file httpd.ini

Dobbiamo innanzitutto capire come vogliamo che i nostri URL appaiano agli utenti (e di conseguenza anche ad i motori di ricerca). Il consiglio che viene sempre dato è quello di utilizzare, nell’URI anche il titolo della pagina che si andrà a personalizzare, così che, anche guardando direttamente l’URL si possa capire cosa contiene. Per andare a “scrivere” i link come qui sotto dovete utilizzare la funzione getURL() creata precedentemente, nel ramo dell’IF positivo (primo blocco).

Consiglio link che abbiano più o meno questa forma:

http://www.miosito.ext/par1/titolo-del-post.html

http://www.miosito.ext/par1/titolo-con-parametro-1/par2/titolo-dell-altro-post.html

http://www.miosito.ext/p/par3/titolo-di-un-altro-articolo.html

Supponendo che par1, par2 e par3 siano numeri interi indicanti gli ID dei contenuti del database, possibili regole per reindirizzare questi URL saranno:
RewriteRule /(\d+)/([^/\.]+).html$ /index.asp?par1=$1 [L]
RewriteRule /(\d+)/([^/\.]+)/(\d+)/([^/\.]+).html$ /index.asp?par1=$1&par2=$3 [L]
RewriteRule /p/(\d+)/([^/\.]+).html$ /pagina.asp?par3=$1 [L]

Già fatto?! SI!!!

Google e gli altri motori di ricerca cosa pensano della riscrittura degli URL?

NON sono un SEO, ma ragionate semplicemente a quello che state per leggere: è più facile, per voi, ricordare un link nella forma http://simone.cabrino.it/2007/05/14/migliorare-la-navigazione-dei-siti-a-frame/ oppure qualcosa nella forma http://simone.cabrino.it/article.php?id=##&browser=Mozilla&style=articolosingolo?!!? Ok, forse ho esagerato ed esasperato un po’ il concetto, ma penso di aver reso sufficientemente bene l’idea.

Molti SEO consigliano e spingono per l’URL Rewriting dandone le giuste argomentazioni:

• URL Rewriting: serve ancora! di Simone Carletti;
• URL Rewriting: non serve più? di Tagliaerbe;

Conclusioni

Come avete avuto modo di vedere da questa pagina, creare un buon URL Rewriting non è una cosa impossibile, anzi è abbbastanza semplice una volta capite le basi delle Regular Expression (RegEx). Semplici da creare, ottimo per i motori di ricerca e bello fa vedere e da ricordare.

Perchè allora non prendere in considerazione di farlo!?

Un amico mi ha trovato camminando in paese (boffalora sopra ticino – il mio grande paese) e mi ha fermato dicendomi:

“Per lavoro devo inviare una mail, tutti i mesi, sempre lo stesso giorno, possibilmente sempre intorno alla stessa ora, con lo stesso testo. Non c’è modo di inviare la email automaticamente? Tanto so che ce la puoi fare…”

Le sfide mi piacciono e, aperto il mio caro amato firefox, mi sono documentato.

Come inviare e-mail con VBS su Windows

Avevo già idea di utilizzare uno script, qualcosa tipo WSH (windows scripting host), o un semplice VBS (visual basic script) e di andarlo ad eseguire automaticamente grazie alla pianificazione operazioni di windows stesso. Bene, idee chiare, unico problema: se il PC su cui girava questo script fosse stato un server web o avesse almeno avuto installato IIS in una qualsiasi delle sue versioni, tutto sarebbe stato più semplice, mentre su un PC “normale”…

Dopo vari tentativi e codici trovati, ho trovato un VBS che fa al caso mio (per utilizzarlo dovete semplicemente copiare il codice seguente, aprire blocco note, incollare e salvare tutto come “invio_mail.VBS” e per eseguirlo, doppio click sul file creato).

Questo VBS utilizza l’oggetto CDOSYS, un componente integrato nei sistemi operativi Microsoft a partire dalla versione Windows 2000, spesso utilizzato per la creazione di newsletter.

Set objMessage = CreateObject("CDO.Message")
objMessage.Subject = "oggetto della email da inviare"
' gli indirizzi possono essere inseriti semplici oppure con "nome mittente"
' versione "normale": destinatario@dominio.xxx
' versione "avanzata": ""Nome Cognome"" < destinatatio@dominio.xxx>
' da notare la ripetizione dei doppi apici (")
objMessage.From = "mittente@dominio.xxx"
objMessage.To = "destinatario@dominio.xxx"
objMessage.Cc = "destinatario@dominio.xxx"
objMessage.Bcc = "destinatario@dominio.xxx"
objMessage.TextBody = "testo della mail da inviare, solo testo"
objMessage.Configuration.Fields.Item ("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
' server posta in uscita (SMTP)
objMessage.Configuration.Fields.Item ("http://schemas.microsoft.com/cdo/configuration/smtpserver") = "smtp.tuodominio.xxx"
objMessage.Configuration.Fields.Item ("http://schemas.microsoft.com/cdo/configuration/smtpserverport") = 25
objMessage.Configuration.Fields.Update
objMessage.Send
msgbox "il messaggio è stato inviato!"

A questo punto, tramite le operazioni pianificate di windows (start > pannello di controllo > (in visualizzazione classica) operazioni pianificate) ne aggiungete una che configurate come preferite (ora esecuzione e numero di esecuzioni) sul file che avete creato.

Avete finito, divertitevi!!!

(questo script è stato creato a scopo serio, quindi non voglio alcuna responsabilità nel caso di illeciti utilizzi – clicca qui per scaricare il file pronto)