Enviar correo electrónico desde ASP.NET (II) – Configurando el Web.Config

¡Hay que ver lo que tiene esto de dedicarse al mundillo de la programación!, que a veces te cansas de hacer un copiar y pegar de cosas que tienes por ahí perdidas y ni te preocupas de mirar cómo solventarlo de otra manera. Me llegó la hora de entonar el mea culpa por no haber visto antes un punto tan sencillo.

En una de las empresas en las que trabajo tienen un server dedicado en 1and1 y la verdad es que es todo un lujazo programar en un sitio en el que no tienes que preocuparte de si el ISP te deja añadir un componente u otro. La verdad es que ya nos ha tocado sufrir lo suyo en este sentido.

Hace ya algún tiempo escribí un artículo – Enviar correo electrónico desde ASP.NET – en el que dejaba una clase que servía para enviar correos electrónicos desde ASP (bueno, la verdad es que la misma clase tiene utilidad si quieres usarla en una aplicación de escritorio). No obstante, enviar un correo electrónico desde ASP es una tarea mucho más fácil si almacenas la configuración del servidor SMTP en el Web.Config del modo siguiente:

<system.net>
  <mailSettings>
    <smtp from="usuario@dominio.com"> <!--Cuenta válida en el servidor de correo SMTP-->
      <network host="servidorSMTP" password="contraseña" userName="userSMTP" />
    </smtp>
  </mailSettings>
</system.net>

De esta manera, cada vez que queramos crear un nuevo mensaje de correo electrónico, bastará con introducir unas pocas sentencias de código que, lógicamente, pueden complicarse dependiendo de la necesidad:

/// <summary>
 /// Envío de un mensaje de correo electrónico
 /// </summary>
 /// <param name="address">Dirección de destino</param>
 /// <param name="subject">Asunto del mensaje</param>
 /// <param name="body">Mensaje</param>
 /// <remarks>
 /// En caso de cambio de la configuración de la cuenta del remitente, 
 /// deberá realizarse en el fichero Web.config
 /// </remarks>
 public void SendMessage(string address, string subject, string body)
 {
     System.Net.Mail.MailMessage message = new System.Net.Mail.MailMessage();
     // Dirección de destino
     message.To.Add(address);
     // Asunto 
     message.Subject = subject;
     // Mensaje 
     message.Body = body;

     System.Net.Mail.SmtpClient smpt = new System.Net.Mail.SmtpClient();
     smpt.Send(message);
 }

Personalizar el HTMLEditor de AjaxControlToolkit

Primeros pasos

Una de las novedades que nos ha traído el Ajax Control Toolkit (May 2009 Release) ha sido un editor HTML para nuestras páginas la mar de práctico. Hasta el momento, cada vez que he tenido que hacer uso de algún control similar con la finalidad de que el usuario pueda escribir negritas o subrayados, siempre he tenido que echar mano de algún componente externo. Debo reconocer que alguno de estos controles han sido realmente buenos y han cumplido a la perfección el objetivo. No obstante, al hacer uso de componentes de varios desarrolladores, llega un momento que el tamaño de la aplicación crece y, sobre todo, cualquier actualización se eterniza. Todo esto, sin contar con que cada control suele incluir sistemas propios de configuración (no será la primera vez que pierdo horas buscando dónde se indica un path para, por ejemplo, añadir una colección de botones propia).

Al ver por vez primera el HTMLEditor debo reconocer que me entusiasmé, puesto que veía la gran utilidad que tenía tener englobado el control con el resto de extensores que suelo usar a menudo. Propiedades y métodos más o menos conocidos, personalización de opciones…todo con una misma “filosofía”!!!!

Este entusiasmo inicial comenzó a decaer nada más empezar a utilizarlo (igual es que nos contagiamos de los clientes y cada día nos volvemos más exigentes). Y, por supuesto, nada más empezar a utilizarlo significa hacer uso de una estructura mínima para poder hacer uso del mismo

Estructura básica para hacer uso del HTMLEditor

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Assembly="AjaxControlToolkit" Namespace="AjaxControlToolkit.HTMLEditor"
    TagPrefix="AjaxCT" %>
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>HTML Editor - Pruebas iniciales</title>
    <style type="text/css" media="all">
        * {
            font-family: Arial, Helvetica, sans-serif;
        }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="sm" runat="server" />
    <div>
        <h1>HTML Editor</h1>
        <AjaxCT:Editor ID="MiEditor" runat="server"  />
    </div>
    </form>
</body>
</html>

Con este código conseguimos añadir un control HTMLEditor en una de nuestras páginas. Apreciamos que no se ha cambiado un ápice de la “estructura original”, es decir, que el resultado que obtendremos también será el de una estructura básica:

Primeros pasos y… Primeros problemas

Una vez pasada la euforia inicial, cuando empezamos a aplicar el control en algún tipo de aplicación, comenzamos a apreciar que, en ocasiones, un control tan “extenso” puede llegar a ser demasiado para situaciones concretas. Por ejemplo, en ocasiones he contado con un espacio ínfimo para crear un control de este estilo y, en estos casos, hay que empezar a apurar botones (otra situación podría ser la de eliminar el tamaño de letra para evitar que los usuarios creen mensajes en los foros al estilo HOIGAN).

Así, de buenas a primeras, me marco dos objetivos iniciales:

1. Aprender a personalizar el número de botones que aparecerán en las barras de herramientas del control
2. Aprender a mostrar/ocultar estas barras de herramientas en tiempo de diseño/ejecución.

Primeras soluciones

Mirando un poco el explorador de objetos, veo que la clase AjaxControlToolkit.HTMLEditor.Editor contiene un par de métodos que me llaman la atención:

• FillTopToolbar
• FillBottonToolbar.

Así, en el ejemplo siguiente vamos a crear un editor que incluya, exclusivamente, los botones de formato estándar Negrita, Cursiva y Subrayado. Por tanto, empezaremos creando una nueva clase en la carpeta App_Code, la cual, heredará directamente del editor original.

using AjaxControlToolkit.HTMLEditor;

namespace jnSoftware.WebControls
{
    public class jnHTMLEditor : Editor
    {

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra superior del control
        /// </summary>
        protected override void FillTopToolbar()
        {
            // Botón de negrita
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Bold());
            // Botón de cursiva
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Italic());
            // Botón de subrayado
            this.TopToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.Underline());
        }


        /// <summary>
        /// Método en el que se colocarán los elementos de la barra inferior del control
        /// </summary>
        protected override void FillBottomToolbar()
        {
            // Vista Diseño
            this.BottomToolbar.Buttons.Add( 
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.DesignMode());
            // Vista Previa
            this.BottomToolbar.Buttons.Add(
                new AjaxControlToolkit.HTMLEditor.ToolbarButton.PreviewMode());

            // base.FillBottomToolbar();
        }
    }
}

A partir de aquí, ya vemos que podemos empezar a personalizar la barra de herramientas, tanto superior, como inferior. De hecho, gracias al IDE de VisualStudio es realmente sencillo y cómodo añadir el resto de botones deseados.

 

Agregando propiedades

En alguna que otra ocasión, he hecho uso de los editores de texto mostrando u ocultando las barras de herramientas, dependiendo del contexto. Así, como lo necesito para el editor, lo que hago es crear una propiedad que permita mostrar u ocultar las barras de herramientas:

using AjaxControlToolkit.HTMLEditor;

namespace jnSoftware.WebControls
{
    public class jnHTMLEditor : Editor
    {

        /// <summary>
        /// Muestra u oculta la barra de herramientas superior
        /// </summary>
        public bool ShowTopToolBar
        {
            get { return showTopToolBar; }
            set { showTopToolBar = value; }
        }
        private bool showTopToolBar = true ;


        /// <summary>
        /// Muestra u oculta la barra de botones inferior
        /// </summary>
        public bool ShowBottonToolbar
        {
            get { return showBottomToolbar; }
            set { showBottomToolbar = value; }
        }
        private bool showBottomToolbar = true;


        /// <summary>
        /// Método en el que se colocarán los elementos de la barra superior del control
        /// </summary>
        protected override void FillTopToolbar()
        {
            if (showTopToolBar)
            {
                // Botón de negrita
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Bold());
                // Botón de cursiva
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Italic());
                // Botón de subrayado
                this.TopToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.Underline());
            }
        }

        /// <summary>
        /// Método en el que se colocarán los elementos de la barra inferior del control
        /// </summary>
        protected override void FillBottomToolbar()
        {
            if (ShowBottonToolbar)
            {
                // Vista Diseño
                this.BottomToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.DesignMode());
                // Vista Previa
                this.BottomToolbar.Buttons.Add(
                    new AjaxControlToolkit.HTMLEditor.ToolbarButton.PreviewMode());
            }
        }
    }
}

Una vez creada la clase, bastará con hacer alguna pequeña modificación en el fichero .ASPX para que se muestre el control creado:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Namespace="jnSoftware.WebControls" TagPrefix="jnControles" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>HTML Editor - Pruebas iniciales</title>
    <style type="text/css" media="all">
        * {
            font-family: Arial, Helvetica, sans-serif;
        }
    </style>
</head>
<body>
    <form id="form1" runat="server">
    <asp:ScriptManager ID="sm" runat="server" />
    <div>
        <h1>HTML Editor</h1>
        <jnControles:jnHTMLEditor ID="MiEditor" runat="server"  />
    </div> 
    </form>
</body>
</html>

 

Enviar correo electrónico desde ASP.NET

Ya sé que es un tema repetido hasta la saciedad, pero en este caso, incluyo el código de un modo egoísta, así, cuando necesite crear de nuevo un elemento que permita enviar correo, sólo tengo que hacerme a mí mismo un Copy & Paste.

El ejemplo siguiente está pensado como una utilidad de notificación en una página Web, es decir, se conocen las direcciones de origen y destino con antelación y no es necesario el uso de adjuntos.

using System;
using System.Net;
using System.Net.Mail;


/// <summary>
/// Útiles de la aplicación
/// </summary>
public static class Utiles
{


    /// <summary>
    /// Envío de un correo electrónico
    /// </summary>
    /// <param name="subject">Asunto del mensaje</param>
    /// <param name="body"></param>
    public static void EnviaMensaje(string subject, string body)
    {
        try
        {
            string smtpServidor = "SERVIDOR_SMTP";
            string smtpUsuario = "CUENTA_USUARIO_STMP";
            string smtpPassword = "PASSWORD_SMTP";
            string cuentaDestino = "CUENTA_DESTINO";
            string cuentaOrigen = "CUENTA_ORIGEN";

            // Credenciales de autenticación
            NetworkCredential credenciales = new NetworkCredential(smtpUsuario, smtpPassword);
            // Permite a las aplicaciones enviar mensajes de correo electrónico mediante el protocolo SMTP 
            SmtpClient cliente = new SmtpClient(smtpServidor);

            // Se descartan las credenciales por defecto
            cliente.UseDefaultCredentials = false;
            // Credenciales de autenticación
            cliente.Credentials = credenciales;
            // Los mensajes de correo electrónico se envían a un servidor SMTP a través de la red
            cliente.DeliveryMethod = SmtpDeliveryMethod.Network;

            // Dirección de destino
            MailAddress direccionDestino = new MailAddress(cuentaDestino, "Formulario Web");

            // Dirección de origen
            MailAddress direccionOrigen = new MailAddress(cuentaOrigen);

            // Mensaje
            MailMessage mensaje = new MailMessage();
            mensaje.From = direccionOrigen;
            mensaje.To.Add(direccionDestino);
            mensaje.Subject = DateTime.Now.ToString() + " " + subject;
            mensaje.Body = body;
            mensaje.IsBodyHtml = false;

            // Envío del mensaje
            cliente.Send(mensaje);

            // Limpieza
            mensaje = null;
            direccionOrigen = null;
            direccionDestino = null;
            credenciales = null;
            cliente = null;
        }
        catch { }
    }


}