Luca Bigon
a- a+

Validare più Email

Da qualche giorno a questa parte sto lavorando ad una applicazione lato-server che girerà nell'intranet di un'azienda abbastanza importante. L'applicazione permetterà agli impiegati di archiviare (per ora manualmente) le e-mail più importanti ricevute o inviate per poterle rileggerle in un secondo momento dall'ufficio o casa senza dover necessariamente portarsi a casa il computer.

In poche parole il sistema funziona da semplice archivio con le seguenti caratteristiche:

- Inserimento email del mittente
- Inserimento emails del destinatario/i
- Data di spedizione
- Titolo
- Messaggio
- Eventuali allegati

Come già detto i dipendenti procederanno manualmente alla compilazione di tutti i campi della pagina.

Ok. In questo mio primo articolo esaminerò gli errori più comuni che possono commettere gli utenti dell'intranet durante la compilazione del campo con le e-mail dei destinatari.
Nel 90% dei casi, infatti, gli utenti dell'intranet utilizzano il pessimo client di posta Outlook configurato in modo tale da lavorare con un Exchange Server locale.
Outlook, come molti altri programmi, tende a formattare il campo "From" con questa sintassi:


email1@prova.it; Nome utente[email2@prova.it]


Come potete vedere ci sono due indirizzi e-mail separati da un punto e virgola. Il primo è un vero e proprio indirizzo mentre il secondo è composto dal nome dell'utente (nome e cognome nella maggior parte dei casi) seguito dall'indirizzo e-mail.

In alcuni casi la sintassi potrebbe essere la seguente:

email1@prova.it, Nome utente


Questa volta gli indirizzi sono separati da una virgola, anzichè un punto e virgola, e il secondo indirizzo compare sotto forma di solo nome anzichè nome seguito da indirizzo e-mail o solo indirizzo e-mail.

A questo punto l'applicazione che sto scrivendo deve essere in grado di "purgare" , perdonatemi il termine, gli indirizzi e-mail mal formattati convertendoli in semplici indirizzi e-mail.
Il risultato finale, dunque, dovrà essere il seguente:

email1@prova.it; email2@prova.it


Il tutto verrà controllato con una semplice funzione scritta in JavaScript.
Ecco il codice:

    function pulisciMail(mails) {
  var re_outlook_mail = /[^[]+[([^]]+)]/;
  var re_valid_mail = /^([w-]+(?:.[w-]+)*)@((?:[w-]+.)*w (a capo)
    [w-]{0,66}).([a-z]{2,6}(?:.[a-z]{2})?)$/i;
  var mail_att = "";
  var out = "";
  var prompt_val = "";
  
  // Trasformo le , in ;
  mails = mails.split(',').join(';');
  // Esplodo da liusta delle e-mail
  var mail_array = mails.split(';');
  
  // Controllo tutte le voci nell'array
  for(var i = 0; i < mail_array.length; i++) {
    // Lavoro su mail_att
    mail_att = mail_array[i].trim();
    if(mail_att != "") { // Non è vuota
      // Tolgo le cagate di outlook
      mail_att = mail_att.replace(re_outlook_mail, "$1");
      if(re_valid_mail.test(mail_att)) { // E-mail valida
        prompt_val = mail_att;
      } else { // E-mail non vale
        do {
          // Leggo l'email
          prompt_val = prompt("L'indirizzo "" +mail_att+ "" non è valido.
          Per favore l'indirizzo e-mail corrispondente a questo contatto!" , "");
          // Se è false abbandono l'applicazione
          if(prompt_val == null)
            return false;
          // Tolgo le possibili cagate di outlook
          prompt_val = prompt_val.replace(re_outlook_mail, "$1");
        } while(!re_valid_mail.test(prompt_val));
      }
      // Aggiungo l'indirizzo e-mail
      out += prompt_val+ '; ';
    }
  }
  return out.substring(0, (out.length-2)).toLowerCase();
}



La funzione riceve in ingresso un solo parametro, cioè la lista degli indirizzi e-mail inseriti dall'utente nel web-form dell'applicazione.
Nella seconda e terza riga vengono richiarate due Regulare Expression che mi permetteranno nel primo caso di convertire l'indirizzo di Outlook in un semplice indirizzo e-mail (nome e cognome [email] <==> email) mentre la seconda RE mi permetterà di verificare se l'indirizzo e-mail inserito è valido oppure no.
Prendetele per buone; dalla quarta fino alla sesta riga vengono dichiarate delle variabili locali che mi permetteranno di memorizzare temporaneamente alcuni dati.

Nella nona riga di codice sostituisco nella variabile mails le virgole in punti e virgole; il risultato di questa sostituzione viene memorizzato ancora una volta in mails (dunque sovrascrivo il valore della variabile). A questo punto non ci sono più virgole all'interno della lista degli indirizzi e-mail.
La riga successiva esplode la variabile mails (che ho appena sovrascritto) in una lista di e-mail; ora infatti in mail_array ci sarà un vettore indicizzato numericamente (da 0 a n elementi-1) contenente in ogni "cella" un singolo indirizzo e-mail.

A questo punto sono in grado di lavorare su ogni indirizzo memorizzato nel vettore mail_array utilizzando un semplice ciclo for che parte da 0 e a arriva a n elementi-1 (in poche parole accedo al contenuto di ogni sincola "cella" del vettore).

Cosa devo fare? Prima di tutto verifico se nella cella in cui mi trovo c'è un indirizzo e-mail valido; se lo è allora senza preoccuparmi più di tanto passo alla cella successiva altrimenti inizio a porre alcune domande all'operatore che ha inserito l'indirizzo.
Mi spiego.. Se nella cella con indice 0 trovo l'indirizzo e-mail "email1@mia.it" allora passo all'elemento con indice 1, ammesso che esista, altrimenti se non trovo un'indirizzo valido (ricordatevi che ho già convertito tutti gli indirizzi formattati secondo Outlook in semplici indirizzi e-mail) chiedo all'utente che ha copiato la lista degli indirizzi (dunque all'operatore) di digitarne uno di valido.

Attenzione però. Una volta che l'operatore ha inserito il nuovo indirizzo e-mail devo verificare, ancora una volta, se l'indirizzo è valido o no! Se non lo fosse chiedo ancora una volta di inserirlo altrimenti termino l'esecuzione dello script.

Dunque nella sedicesima riga di codice tolgo gli spazi vuoti prima e dopo il contenuto della cella (la funzione trim() non esiste in JavaScript; in ogni caso potete trovare il codice qui sotto) poi verifico se l'indirizzo è vuoto. Se è vero allora passo alla "cella" successiva altrimenti, se non è vuoto, inizio a controllare la validità effettiva del testo.

Ed ecco la parte più complessa:
Per prima cosa salvo nella variabile mail_att il risultato della RE re_outlook_mail (converto le e-mail con il nome e cognome in un semplice indirizzo e-mail); successivamente controllo se il testo contenuto in mail_att è effettivamente un indirizzo e-mail. Se lo è salvo in prompt_val il suo valore altrimenti procedo al controllo incrociato del quale vi accennavo prima.

Devo chiedere l'indirizzo e-mail assocciato a quel falso indirizzo fino a quando l'operatore non ne inserisce uno di valido; per fare questo uso un ciclo do .. white() che esce appena l'indirizzo inserito soddisfa la RE memorizzata in re_valid_mail; all'interno del ciclo do .. white() chiedo all'operatore di inserire un nuovo indirizzo e-mail con la funzione prompt() di JavaScript.
Subito dopo controllo se l'utente ha premuto il bottone annulla (prompt_val == null); nel caso in cui sia vera questa condizione termino l'esecuzione della funzione con un "return false"; se invece l'utente ha inserito qualcosa allora applico la RE re_outlook_mail per convertire le e-mail complete di nome, cognome e e-mail in un semplice indirizzo e-mail, infine non mi resta che verificare se questo indirizzo, appena "purgato" , è valido oppure no.
Ovviamente se è valido passo alla cella successiva altrimenti interrogo nuovamente l'operatore.

Prima di uscire dal ciclo (anzi prima di uscire dall'else) accodo alla variabile out l'indirizzo e-mail appena verificato seguito da un punto e virgola più uno spazio.
Perchè questa riga? A cosa mi serve?
Alla fine del processo la funzione deve restituire una serie di indirizzi ben formattati separati da un punto e virgola e da uno spazio. Dunque la variabile out conterrà al suo interno il valore che poi verrà restituito dalla funzione pulisciMail.

La penultima riga di codice, la trentasettesima per la precisione, restituisce la variabile out.
Attenzione: dalla variabile vengono tolti gli ultimi due caratteri (che sono sicuramente "; ") e il testo della variabile viene convertito in soli caratteri piccoli utilizzando la funzione teLowerCase();

Ed ecco la funzione trim:

    String.prototype.trim = function() {
  var x=this;
  x=x.replace(/^s*(.*)/, "$1");
  x=x.replace(/(.*?)s*$/, "$1");
  return x;
}



Ti potrebbe interessare anche

commenta la notizia

C'è 1 commento
Francesco
Hai dubbi su questo articolo?