Recuperar contraseña
  • Página principal
  • /
  • Blogs
  • /
  • Cómo enviar un informe por e-mail desde una base de datos en la aplicación .Net Core

Cómo enviar un informe por e-mail desde una base de datos en la aplicación .Net Core

Dmitriy Fedyashov

Cómo enviar un informe por e-mail desde una base de datos en la aplicación .Net Core

Ya hemos hablado de cómo se manda un informe a un grupo de direciones de e-mail desde la base de datos. En este artículo seguimos con el tema pero esta vez vamos a tratarlo en referencia a aplicaciones web en la plataforma .Net Core MVC. Bueno, nuestro objetivo es sacar una lista de direciones de e-mail y nombres de usarios de una base de datos y mandar e-mails con un informe adjunto a estas. Para ello, vamos a utilizar una base de datos en MS SQL Server.

 

Se crea una aplicación ASP .Net Core MVC. Se añaden bibliotecas necesarias en el proyecto con NuGet Packages Manager. En el almacén general nuget se encuntran y se instalan las siguientes paquetes:

  • Microsoft.EntityFrameworkCore;
  • Microsoft.EntityFrameworkCore.Relational;
  • Microsoft.jQuery.Unobtrusive.Ajax;
  • jQuery.

Desde el repositorio local, la carpeta Nuget en el directorio de instalación de FastReport.Net, se instalan los siguientes paquetes:

  • FastReport.Core;
  • FastReport.Web.

Se crea el contexto de trabajo con la base de datos y la clase-esencia de la tabla. Para ello, abra el panel de controles de paquetes Nuget. Se abre el menú Tools -> Nuget Package Manager -> Package Manager Console. En el panel de controles se tecla el siguiente comando:

scaffold-dbcontext "Server=localhost;Database=testdb;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

Claro que aquí tiene que especificar su cadena de conexión al servidor de base de datos y a una carpeta para el modelo de datos (Models por defecto).

PM> scaffold-dbcontext "Server=localhost;Database=testdb;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models

Al hacerlo, en teoría, en la carpeta Models se deben de añadir dos ficheros: el contexto y la esencia de la tabla. En mi caso, son testdbContext.cs y e-mails.cs.

Sin embargo, durante la generación de los ficheros puede ocurrir el siguiente error:

error MSB4064: The "SharedCompilationId" parameter is not supported by the "Csc" task. There is a settable public instance property.

Si es así, añada en el manager de paquetes NuGet un paquete más:

Microsoft.Net.Compillers

Conectemos FastReport a nuestro proyecto. En el fichero Startup.cs añada la línea:

1
2
3
4
5
6
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {

 app.UseFastReport();

}

Ahora volvamos al modelo de datos. Para sacar registros de la base de datos tenemos que crear el método Getemails. Se crea una clase fachada para trabajar con los datos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
namespace WebMailing.Models
{
 public static class Facade
 {
 public static List<Emails> GetEmails()
 {
 using (Models.testdbContext context = new Models.testdbContext())
 {
 var emails = (from adresses in context.Emails
 select adresses).ToList();
 return emails;
 }
 }
 }
}

 Ahora vamos al controlador HomeController. En el método Index se carga un informe para visualizarlo en la página principal del sitio web:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using WebMailing.Models;
using FastReport;
using FastReport.Export.Pdf;
using FastReport.Export.Email;
using FastReport.Web;

public IActionResult Index()
{
 WebReport webReport = new WebReport();
 webReport.Report.Load(Environment.CurrentDirectory + "/text.frx");
 ViewBag.WebReport = webReport;
 return View();
}

 Se añaden dos métodos de mandar mensajes por correo electrónico. El primero enviará mensajes personales con el nombre del usario indicado en la bienvenida; el segundo enviará un solo mensaje a un grupo de direcciones de e-mail.

Bueno, el primer método es así:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[HttpPost]
 public ActionResult SendMail()
 {
 Report report1 = new Report(); //Create new report object
 report1.Load(Environment.CurrentDirectory + "/text.frx"); //Load report
 report1.Prepare(); //Prepare report
 
 PDFExport pdf = new PDFExport(); //Cteate PDF export
 EmailExport email = new EmailExport(); //Create Email export
 
 List<Emails> emails = Models.Facade.GetEmails();
 foreach (Emails item in emails)
 {
 SendMessage(report1, pdf, email, item.Email, item.Name);
 }
 return View();
 }

 En este método hemos creado un informe, Exportar en PDF, Exportar en E-mail. Luego, en el ciclo, obtenemos registros de la tabla y llamamos al método de mandar mensajes. Como parámetros, pasamos a ese el objeto del informe, Exportar PDF, Exportar E-mail, e-mail y el nombre del cliente. Aquí tiene el mismo método de mandar mensajes:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void SendMessage(Report report, PDFExport pdf, EmailExport email, string recipient, string custName)
 {
 string message = "This is test message.";
 email.Account.Address = "gromozekaster@yandex.ru";
 email.Account.Name = "Test User";
 email.Account.Host = "smtp.yandex.ru";
 email.Account.Port = 25;
 email.Account.UserName = "Gromozekaster";
 email.Account.Password = "*****"; //Your password
 email.Account.MessageTemplate = "Test";
 email.Account.EnableSSL = true;
 //email addressee settings
 email.Address = recipient;
 email.Subject = "TestMessage";
 email.MessageBody = custName is null ? message : string.Format("Dear, {0}! {1}", custName, message);
 email.Export = pdf; //Set export type
 email.SendEmail(report); //Send email
 }

En el método de mandar mensajes ajustamos cliente de correo electrónico para enviar mensajes. Y también añadimos un segundo método de enviar un sólo mensaje a un grupo de direciones de e-mail:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 [HttpPost]
 public ActionResult SendAll()
 {
 Report report1 = new Report(); //Create new report object
 report1.Load(Environment.CurrentDirectory + "/text.frx"); //Load report
 report1.Prepare(); //Prepare report
 PDFExport pdf = new PDFExport(); //Cteate PDF export
 EmailExport email = new EmailExport(); //Create Email export
 
 List<Emails> emails = Models.Facade.GetEmails();
 string addresses = "";
 foreach (Emails item in emails)
 {
 if (addresses == "")
 addresses = item.Email;
 else
 addresses = addresses + ", " + item.Email;
 }
 SendMessage(report1, pdf, email, addresses, null);
 return View();
 }

Como puede ver, parece mucho al método anterior, con la única diferencia: en el ciclo recibimos todas las direciones de e-mail y mandamos mensaje una sola vez. Como parámetro de e-mail, pasamos el variable de cadena con todas las direciones de e-mail sin pasar el nombre de usario.

Para los dos métodos SendMail() y SendAll() tenemos que crear vistas con el mismo nombre – view.

Sus contenidos son muy simples:

1
2
3
4
@{
 ViewBag.Message = "Report was sent";
}
@ViewBag.Message

Solo informamos del envío.

Pasemos a la vista Index.cshtml. Aquí tenemos que añadir dos botones para mandar mensajes a través de varios métodos, así como para visualizar el informe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@{
 ViewData["Title"] = "Home Page";
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.12.1/jquery.min.js"></script>
 <form action="SendMail" method="POST">
 <input type="button" id="SendPersonal" value="Send Personal Email">
 <input type="button" id="SendAll" value="Send Email to All">
 <div class="answer"/>
 </form>
 <script type="text/javascript">
 $('#SendPersonal').on("click", function () {
 $.ajax({
 type: 'POST', // dispatch method
 url: '@Url.Action("SendMail", "Home")', // path to handler
 dataType: 'text',
 success: function (data) {
 $(".answer").html(data); // upon successful receipt of the response from the server, we enter the data in the element with the class answer
 }
 });
 return false;
 })
 $('#SendAll').on("click", function () {
 $.ajax({
 type: 'POST', // dispatch method
 url: '@Url.Action("SendAll", "Home")', // path to handler
 dataType: 'text',
 success: function (data) {
 $(".answer").html(data); // upon successful receipt of the response from the server, we enter the data in the element with the class answer
 }
 });
 return false;
 })
 </script>
@await ViewBag.WebReport.Render() 

 Para utilizar el ajax jquery, añadimos un enlace al script jquery.min.js. Luego, añadimos forma con dos botones y dos scripts para cada uno. Los scripts son muy fáciles: la llamada al método desde el controlador y la vuelta de la vista resultante.

Finalmente, deducimos el informe del método Index. Ahora, ejecute la aplicación para ver cómo es:

We send letters by different methods:

 

And:

 

In the first case, in the text of the letter we refer to the client by name, in the second there is none.

That's all.

Similar articles:

Volver