Nous voici arrivés à la 5ème (et dernière ??) leçon de cette série.
Comme prévu cette leçon est consacrée à l'envoi d'un mail contenant
les informations introduites dans un formulaire.
Nous allons utiliser le module NET::SMTP et / ou Sendmail pour envoyer le mail.
Le but est donc de reprendre les informations d'un formulaire semblable à celui avec lequel nous avons travaillé jusqu'à maintenant.
Il y a quand même quelques modifications ; j'ai ajouté :
un champ pour le sexe, en utilisant des boutons radios
un champ pour le commentaire en utilisant un textarea
des champs cachés.
N'OUBLIEZ PAS DE MODIFIER LES INFORMATIONS DE CES CHAMPS CACHES (je
n'ai pas envie de recevoir tous les mails de test :)
Le but en utilisant ces champs cachés est de permettre une plus grande
modularité du script ; c'est a dire qu'il ne faudra pas un script par
formulaire car certains paramètres peuvent être spécifiés dans le code HTML.
Ces paramètres sont au nombre de 3 :
L'adresse du destinataire (mailto)
La page à afficher si l'envoi c'est déroulé correctement. (redirectok)
La page à afficher si l'envoi n'a pas été fait. (redirectpasok)
On va rentrer directement dans le vif du sujet en analysant le code perl :
#################################
# Adresse du serveur smtp (celui de votre provider par exemple)
# si smtp = "" alors on utilise sendmail
$smtp = "";
# Changer la ligne suivant pour pointer vers le programme sendmail
$mailprog = '/usr/sbin/sendmail';
#################################
$stmp est l'adresse ip ou le nom du serveur smtp qui va me servir à
envoyer les mails. Il faut que vous soyez autorisés à utiliser ce
serveur smtp, sinon cela ne fonctionnera pas. Pour avoir cette
autorisation, il faut parfois être sur le même réseau que le serveur,
parfois il faut s'authentifier avant en relevant son courrier, ...
Si vous ne souhaitez pas utiliser un serveur smtp, mais sendmail, ne
mettez rien dans la variable $smtp.
Idem pour sendmail, il faut que vous y ayez accès, ce qui est
généralement le cas sur tous les serveurs unix (linux, solaris, bsd, ...)
require "cgi-lib.pl";
&ReadParse(*input);
Rien d'extraordinaire, ces lignes la ont peu changé depuis le début du cours ;)
if (&CreerMail == 0)
{ print "Location: $input{'redirectok'}\n\n";
}
else
{ print "Location: $input{'redirectpasok'}\n\n";
}
Je regarde si la valeur de retour envoyé par la fonction CreerMail est
égale à 0, si oui, le script m'envoie à la page dont l'adresse est
contenue dans la variable $in{'redirectok'}. Cela se fait en utilisant
un print "Location: adresse\n\n" ;
Si la valeur de retour n'est pas égale à 0, alors je suis envoyé sur
la page dont l'adresse est contenue dans la variable $input{'redirectpasok'}.
exit 0;
Je quitte le programme, avec 0 comme valeur de sortie
sub CreerMail
{
Début de la fonction CreerMail
$date = &Date;
Assigne à la variable date la valeur renvoyée par la fonction Date.
Cette fonction renvoie la date sous la forme : jour mois année.
Exemple : 15 octobre 2000
# préparer mail
my $to = $input{'mailto'};
my $mailfrom = $input{'email'};
my $mailsubject = "Cours5 : commentaire d'un visiteur";
my $msg = "Date : $date\n".
"Nom : $input{'nom'}\n".
"Prénom : $input{'prenom'}".
"Rue : $input{'rue'}, n° $input{'no'}\n".
"Code postal : $input{'cp'}\n".
"Localité : $input{'localite'}\n".
"Pays : $input{'pays'}\n".
"Adresse mail : $input{'email'}\n".
"Sexe : $input{'sexe'}\n".
"\n\nCommentaire :\n $input{'commentaire'}";
Comme le dit si bien la première ligne de ce morceau de code, toutes
ces instructions servent simplement a remplir les différentes
variables avec les valeurs dont on a besoin.
if ($smtp eq "")
{ # smtp est vide donc on utilise sendmail
return &miniSendmail($to,$mailfrom,$mailsubject,$msg);
}
else
{ return &MySendMail($to,$mailfrom,$msg,$smtp,$mailsubject);
}
Si $smtp est vide, c'est donc que je dois utiliser sendmail pour envoyer le mail.
Je vais donc exécuter le fonction miniSendmail avec différents
paramètres. Cette fonction miniSendmail me retourne une valeur qui me
permet de savoir si l'envoi a pu se faire ou pas. A mon tour je
retourne également cette valeur en utilisant le mot return.
Lors d'un return, on quitte la fonction actuelle et on retourne vers
l'endroit d'ou on vient. Dans ce cas-ci, on faisant le return
&miniSendmail, je vais retourner à la ligne
if (&CreerMail == 0)
Si le smtp est spécifié je vais donc utiliser la fonction MySendMail
en lui passant les paramètres (valeur des variables) to, mailfrom,
msg, smtp, mailsubject.
Cette fonction renvoie également un code retour qui permet de savoir
si tout c'est bien passé ou pas.
sub MySendMail
{ # utilisation MySendMail ($to, $from, $message, $smtpserver,$sujet)
Déclaration de la fonction, et rappel de la syntaxe à utiliser
my $to = $_[0];
my $from = $_[1];
my $message = $_[2];
my $smtpserver = $_[3];
my $sujet = $_[4];
Je récupère la valeur des différents paramètres et je la stocke dans
une variable.
Les paramètres passés à une fonction sont stockés dans le tableau @_.
C'est pour cela que pour récupérer la valeur du premier paramètre (le
destinataire) je dois utiliser $_[0] qui est le premier élément du
tableau @_
Idem pour tous les autres paramètres.
use Net::SMTP;
Déclare que l'on va utiliser NET::SMTP, qui est un module PERL.
$smtp = Net::SMTP->>new($smtpserver); # connecte un serveur SMTP
Comme indiqué dans le commentaire, cette ligne permet de se connecter
à un serveur smtp. Si la connexion est possible, $smtp est l'objet qui
nous permettra de dialoguer avec notre serveur SMTP. Si la connexion
est impossible, $smtp contient la valeur undef
if ($smtp != undef)
Teste la valeur de $smtp pour vérifier si l'on peut envoyer le mail ou
si c'est impossible.
{ $smtp->mail($from); # adresse de l'émetteur
$smtp->to($to); # adresse de destination
$smtp->data(); # début du mail
# Envoi de l'en tete
#
$smtp->datasend("To:".$to."\n");
$smtp->datasend("From:". $from."\n");
$smtp->datasend("Subject:".$sujet."\n");
$smtp->datasend("\n");
# Corps du message.
#
$smtp->datasend($message);
$smtp->dataend(); # Terminer l'envoi de mail
$smtp->quit; # Terminer ma connexion smtp
return 0;
}
Tout ce bloc de code est exécuté quand l'envoi de mail est possible.
A la fin de la fonction, la valeur 0 est renvoyée.
else
{ # erreur ne peut contacter le serveur smtp
Comme indiqué dans le commentaire, si on passe ici, c'est que l'on ne
peut pas envoyer de mail pour différentes raisons.
return 1;
}
On quitte la fonction en renvoyant la valeur 1.
C'est cette valeur qui est testée pour vérifier quelle page on doit
afficher : celle si l'envoi c'est déroulé correctement ou l'autre.
}
Fin du code de la fonction MySendMail
sub Date
{ local (@DATE)=("Janvier","Février", "Mars","Avril", "Mai", "Juin", "Juillet",
"Août","Septembre", "Octobre","Novembre","Décembre") ;
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
$year += 1900;
my $date = "$mday $DATE[$mon] $year" ;
return $date;
}
Sans rentrer trop dans les détails c'est cette fonction qui génère ma
date qui est affichée dans le mail.
Je remplis le tableau @DATE avec le nom des mois, puis j'utilise
localtime(time) pour récupérer dans différentes variables le numéro du
mois ($mon), le jour ($mday), l'année ($year) plus d'autres infos
(heures, minutes, secondes, n° du jour dans l'année, n° du jour dans
la semaine, …)
J'utilise les informations qui m'intéressent pour créer ma variable
$date puis je la retourne avec un return $date.
sub miniSendmail
{ my($to,$from,$sujet, $message);
$to = $_[0];
$from = $_[1];
$sujet = $_[2];
$message = $_[3];
Il s'agit du début de la déclaration de la fonction miniSendmail qui
me permet d'envoyer des emails en utilisant sendmail (principalement
sur serveurs Unix).
Comme pour l'envoi par smtp, je récupère la valeur de mes paramètres
et je les stocke dans différentes variables.
open (MAIL,"|$mailprog -t") || return 1;
Sendmail est considéré comme un fichier spécial dans lequel je vais
écrire mon mail, il faut donc l'ouvrir avant de pouvoir l'utiliser. Si
je n'arrive pas a l'ouvrir pour une raison quelconque, je quitte la
fonction avec un code de retour de 1.
print MAIL "To: $to\n";
print MAIL "From: $from\n";
print MAIL "Subject: $sujet\n\n";
print MAIL "$message\n";
print MAIL "\n";
Si nous arrivons ici, c'est que l'on a pu accéder a sendmail et que
l'on peut y écrire nos infos, comme dans un fichier normal.
Je crée donc l'entête de mon mail (from, to, subject) et j'ajoute le
message.
Il faut bien faire attention à mettre 2 retours de chariots (\n) après
le subject, sinon le mail risque d'être illisible.
close (MAIL);
Tout comme un fichier normal, je le ferme une fois que j'ai terminé de
m'en servir.
return 0;
Je quitte ma fonction en renvoyant 0 pour signaler que tout c'est
déroulé correctement.
Je réponds comme d'habitude à vos questions. Utilisez la liste elle a
été prévue à cet effet !!!!!!!
Néanmoins, si quelqu'un veut faire un bon exercice pratique, il peut
regrouper tout ce qui a été vu pour faire la chose suivante :
Un script qui récupère les données d'un formulaire, les enregistre
dans un fichier texte et les envoie en même temps au propriétaire du site.
Le script doit aussi permettre de rechercher une information dans
la base de données et ne pas tenir compte des différences
majuscules/minuscules.
Il ne faut pas oublier non plus de gérer les accès concurrents.
Voilà, c'est tout pour cette semaine.
Pour rappel, vous pouvez retrouver une version HTML de ce cours et
les exemples en fonctionnement sur http://cours.scripts-fr.com/cours/
(dès que j'aurai eut le temps de le mettre en html :-)
Accueil
