Una delle necessità più comuni nella progettazione di un sito, che si tratti di un grande network o di un piccolo biglietto da visita per un'azienda, è la realizzazione di un sistema di invio di email.
Le implementazioni più frequenti partono dal semplice modulo di feedback fino ad arrivare a sistemi complessi di autenticazione.
ASP non mette a disposizione alcun modo nativo per poter inviare delle email ma si deve ricorrere all'uso di uno o più oggetti. I più comuni sono il componente CDONTS installato di default sui server fino a Windows 2000 ed il più recente CDOSYS, presente su Windows 2003 server.
Già da queste prime righe si può notare come non esista un modo univoco per inviare una email e questo è proprio uno dei problemi più comuni. Immaginiamo di aver realizzato un portale con una decina di script per inviare una email da windows 2000, se di colpo ci trovassimo a dover spostare il sito su un nuovo server potrebbero sorgere evidenti problemi di incompatibilità.
Questo inevitabilmente ci porterebbe a dover riscrivere numerose righe di codice per adattare il sito al nuovo server con indubbi sprechi di tempo e risorse.
Vediamo allora come potremmo procedere per ottimizzare al meglio l'invio di email dal nostro sito web.
Definiamo una funzione
Il primo passo da fare è realizzare un sistema che ci consenta di non dover riscrivere tutte le volte il codice per l'invio di una email che, come vedremo, non è neanche così corto.
L'idea è quella di definire una funzione alla quale passeremo ciascuna volta dei parametri che consistono nelle parti generalmente variabili dell'email.
Possiamo quindi individuare un elenco di argomenti della funzione in base alle nostre necessità. In questo esempio definiamo come parametri le informazioni sul mittente, il destinatario, il corpo e l'oggetto dell'email, una variabile che ci permetta di scegliere se inviare l'email in formato HTML o testo e per finire una variabile, che spiegheremo in seguito, che definisce il tipo di oggetto email usato. Ovviamente siamo noi a dover scegliere cosa passare poi in fase di utilizzo della funzione ed è quindi possibile modificare l'esempio seguente a piacimento aggiungendo ad esempio un parametro per il livello di importanza, per dei destinatari in CCN o eventualmente per allegare un file.
Cominciamo allora con la dichiarazione della nostra funzione che chiameremo sendEmail:
public function sendEmail(toName, toEmail, fromName, fromEmail, emailSubject, emailBody, isHTML, emailComponent, emailServer)
Nel dettaglio:
toNameetoEmail: rispettivamente nome ed indirizzo del destinatariofromNameefromEmail: rispettivamente nome ed indirizzo del mittenteemailSubject: oggetto dell'emailemailBody: contenuto dell'emailisHTML: se impostato a true invia una email in formato HTML, altrimenti in formato testoemailComponent: oggetto email utilizzatoemailServer: indirizzo SMTP del server d'invio. Necessario per qualsiasi oggetto tranne CDONTS
Prima di addentrarci nel vivo della funzione inseriamo ancora un paio di personalizzazioni che miglioreranno il risultato finale. Ovviamente anche queste sono assolutamente facoltative.
Come primo passo dichiariamo tutte le variabili che ci serviranno in futuro.
Dim objMail ' Oggetto email
Dim objMailConfig ' Configurazione oggetto email
Dim blnSent ' Conferma di invio email
Dim strBodySignature ' Firma da aggiungere alle email
Dopo di che definiamoci una semplice formattazione del carattere per l'invio delle email in HTML creando una stringa con l'adeguata formattazione.
Const strBodyFormat = "<font size=""2"" face=""Tahoma, Verdana, Arial, Helvetica, sans-serif"">$body$</font>"
$body$ corrisponde in questo caso ad una parola a noi convenzionale che andremo poi a sostituire in fase di invio con il contenuto dell'email.
Assicuriamoci che di default la funzione restituisca false se non vengono inviate email
blnSent = false
e per concludere creiamo una piccola istruzione che ci consenta di allegare una firma, in HTML o in formato testo, in qualsiasi email.
' Inserisci una firma
if isHTML then
strBodySignature = "<br /><hr />Inserire la firma in HTML"
else
strBodySignature = vbCrLf & vbCrLf & "--------------------"
strBodySignature = strBodySignature & vbCrLf & "Inserire la firma in solo testo"
end if
Ovviamente, come detto prima, questa parte è assolutamente opzionale e rappresenta solo un miglioramento del cuore della nostra funzione.
Organizziamo gli oggetti email
Il passo successivo è pensare di inserire in questa funzione tutte le sintassi dei più comuni oggetti per l'invio di email, permettendo poi di sceglierne uno in fase di richiamo della funzione. Questo richiederà qualche minuto, ma ci risparmierà notevole tempo nel caso ci trovassimo nella situazione di dover spostare il sito di server.
È possibile reperire la sintassi di ogni singolo oggetto nelle documentazioni ufficiali rilasciate dal produttore o dai numerosi esempi in rete. Per questo articolo prendiamo in considerazione i 4 più comuni oggetti e mediante il costrutto select case offriamo l'opportunità di impostare il singolo oggetto scrivendone il nome nella variabile emailComponent prima citata.
' Controlla il componente da usare
select case emailComponent
CDONTS
La documentazione su questo oggetto è reperibile qui.
Definiamo quindi un semplice codice di invio email passando come valore i parametri della funzione.
' ****** CDONTS *****
case "CDONTS"
' Crea l'oggetto CDONTS
Set objMail = Server.CreateObject("CDONTS.NewMail")
with objMail
' Mittente
.From = fromName & " <" & fromEmail & ">"
' Destinatario
.To = toName & " <" & toEmail & ">"
' Oggetto
.Subject = emailSubject
' Corpo dell'email
if isHTML then
.Body = Replace(strBodyFormat, "$body$", emailBody & strBodySignature)
else
.Body = emailBody & strBodySignature
end if
' Formato corpo : 0 = HTML, 1 = Text
if isHTML then
.BodyFormat = 0
else
.BodyFormat = 1
end If
' Formato email : 0 = MIME, 1 = Text
.MailFormat = 0
' Importanza : 0 = Low, 1 = Normal, 2 = High
.Importance = 1
' Invia l'email
.Send
blnSent = true
end with
Set objMail = Nothing
Vediamo nel dettaglio questo primo esempio. I successivi saranno estremamente simili a meno della sintassi proprietaria dell'oggetto.
Avendo definito un costrutto select case iniziale definiamo questo primo codice come casistica CDONTS. Questo significa che ogni qual volta richiameremo la funzione definendo a CDONTS il valore della variabile emailComponent, verrà processata unicamente questa parte di codice.
Creiamo poi un nuovo oggetto CDONTS ed assegnamogli le singole proprietà. Siccome è assolutamente ridondante stare a ripetere ogni volta objMail.Nomeproprieta usiamo il particolare costrutto with che ci permette di considerare implicitamente il nome dell'oggetto specificato all'inizio per tutta la durata fino alla chiusura con end with.
Definiamo quindi rispettivamente il mittente ed il destinatario secondo quanto richiesto dalla documentazione. Dato che questi valori variano presumibilmente ad ogni invio li opportunamente inseriti come parametri nella definizione della funzione.
Stessa cosa vale per l'oggetto ed il corpo dell'email, senza dimenticarci di eseguire un controllo sul formato di invio per gestire opportunamente il caso in cui sia richiesta una email in HTML.
Il resto del codice consiste nella definizione di ulteriori proprietà richieste dal componente.
Una volta conclusa la preparazione dell'email è finalmente possibile inviarla, in questo caso con il comando (Nomeoggetto).Send a cui facciamo seguire la conferma d'invio impostando a true la rispettiva variabile.
Chiudiamo il costrutto with, distruggiamo l'email ed abbiamo terminato la costruzione dell'invio dell'email con CDONTS.
Non ci resta che procedere in modo analogo per i successivi oggetti ricordando questa semplice scaletta:
- definizione dell'oggetto
- creazione dell'oggetto
- assegnazione delle proprietà d'invio
- formattazione dell'email
- invio e conferma
CDOSYS
Vediamo in breve un esempio di invio in CDOSYS adattato alla funzione sopra definita. I parametri sono gli stessi prima definiti, cambia unicamente la sintassi specifica dell'oggetto.
' ****** CDOSYS *****
case "CDOSYS"
' Crea l'oggetto CDOSYS
Set objMail = Server.CreateObject("CDO.Message")
Set objMailConfig = Server.CreateObject ("CDO.Configuration")
' Proprietà di invio
with objMailConfig
' SMTP mail server
.Fields("http://schemas.microsoft.com/cdo/configuration/smtpserver") = emailServer
' SMTP port
.Fields("http://schemas.microsoft.com/cdo/configuration/smtpserverport") = 25
' CDO port
.Fields("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
' Timeout
.Fields("http://schemas.microsoft.com/cdo/configuration/smtpconnectiontimeout") = 60
.Fields.Update
end with
' Configurazione CDOSYS
Set objMail.Configuration = objMailConfig
with objMail
' Mittente
.From = fromName & " <" & fromEmail & ">"
' Destinatario
.To = toName & " <" & toEmail & ">"
' Oggetto
.Subject = emailSubject
' Corpo dell'email
if isHTML then
.HTMLBody = Replace(strBodyFormat, "$body$", emailBody & strBodySignature)
else
.TextBody = emailBody & strBodySignature
end if
' Invia l'email
if Len(emailServer) > 0 then
.Send
blnSent = true
end if
end with
Set objMail = Nothing
Set objMailConfig = Nothing
A differenza di CDONTS che è tutto sommato molto permissivo da questo punto di vista, sia CDOSYS sia i prossimi componenti richiedono qualche configurazione in più.
Nello specifico ci è richiesto di specificare il server SMTP di invio per le email (in genere mail.nomedominio.estensione), la porta da utilizzare per l'invio ed alcune informazioni ulteriori.
Sebbene si tratti di valori spesso standard corrispondenti a quanto specificato nell'esempio, è bene prima di procedere verificare presso il proprio amministratore di rete o provider le corrette impostazioni .
ASPEmail
La documentazione su questo oggetto è reperibile all'indirizzo http://www.aspemail.com/manual.html
' ****** PERSIT ASPEMAIL *****
case "ASPEmail"
' Crea l'oggetto ASPEMAIL
Set objMail = Server.CreateObject("Persits.MailSender")
with objMail
' SMTP mail server
.Host = emailServer
' SMTP port
.Port = 25
' Mittente
.From = fromEmail
.FromName = fromName
' Destinatario
.AddAddress toEmail, toName
' Oggetto
.Subject = emailSubject
' Corpo dell'email
if isHTML then
.Body = Replace(strBodyFormat, "$body$", emailBody & strBodySignature)
else
.Body = emailBody & strBodySignature
end if
' Imposta il formato HTML
if isHTML then
.IsHTML = true
end if
if Len(emailServer) > 0 then
.Send
blnSent = true
end if
end with
Set objMail = Nothing
ASPMail
La documentazione su questo oggetto è reperibile all'indirizzo http://www.serverobjects.com/comp/AspQMail.htm
' ****** ASPMAIL *****
case "ASPMail"
' Crea l'oggetto ASPMAIL
Set objMail = Server.CreateObject("SMTPsvg.Mailer")
with objMail
' SMTP mail server
.RemoteHost = emailServer
' Mittente
.FromAddress = fromEmail
.FromName = fromName
' Destinatario
.AddRecipient toName, toEmail
' Oggetto
.Subject = emailSubject
' Corpo dell'email
if isHTML then
.BodyText = Replace(strBodyFormat, "$body$", emailBody & strBodySignature)
.ContentType = "text/HTML"
else
.BodyText = emailBody & strBodySignature
.ContentType = "text/plain"
end if
if Len(emailServer) > 0 then
.SendMail
blnSent = true
end if
end with
Set objMail = Nothing
Completiamo il codice
Il passo conclusivio è chiudere la select case dei valori, a cui naturalmente possiamo aggiungere a piacimento la sintassi per l'invio con altri oggetti.
end select
Infine restituiamo il valore della variabile blnSent prima definita che presumibilmente corrisponderà a true se l'email è stata inviata
sendEmail = blnSent
e chiudiamo la funzione
end function
D'ora in avanti sarà sufficiente includere questa funzione nelle nostre pagine ASP e richiamarla passando i parametri corretti per avere un invio semplice ed ottimizzato di email.
Esempio, inviare una mail con CDONTS
myEmail = sendEmail("Destinatario", "destinatario@dominio.com", "Webmaster", "webmaster@sito.com", "Oggetto di prova", "Corpo dell'email", true, "CDONTS", "mail.sito.com")
Se poi dovesse succedere di cambiare server o oggetto di invio niente paura. Un semplice aggiornamento al parametro emailComponent e tutto si risolverà in pochi secondi.
Una copia della funzione è allegata a questo articolo.
