Exportación de informes en FastReport.OpenSource

FastReport.OpenSource ha provocado mucho interés entre desarrolladores. Es un buen generador de informes con una historia larga. La versión con código de fuente abierto es FastReport.Core que aparece al principio de 2018, pero con algunas limitaciones. En particular, se trata de la exportación reducida. De esta manera, están desponibles solo los siguientes formatos:

HTML, BMP, PNG, JPEG, GIF, TIFF, EMF.

Claro, son muy pocos formatos. El objeto WebReport muestra el informe en el formato HTML, por lo cual está aparte.

Cabe destacar que en el objeto WebReport podemos guardar el informe solo en la extensión de vista previa .fpx.

Por lo tanto, tendrá que exportar el informe desde el código de la aplicación. Vamos a ver cómo es eso.

Voy a describir detalladamente el proceso entero de cómo se crea una aplicación demo para que lo pueda repetir.

Cree un proyecto ASP.Net Core 2.0. A continuación, añadimos paquetes desde el repositorio NuGet: FastReport.OpenSource y FastReport.OpenSource.Web.

Ahora tiene que añadir el uso de las bibliotecas de FastReport al archivo Startup.cs.

Vamos a utilizar la vista Index. Cámbiela como en el ejemplo:

1
2
3
4
5
6
7
8

@using (Html.BeginForm("Save", "Home", FormMethod.Get))
{
 <input id="save" type="submit" value="Save report in HTML" />
}
 
<div>
 <img src ='@Url.Action("GetImage")'>
</div>

Vamos a mostrar el informe en formato de dibujo, así como un hipervínculo a la descarga del informe en formato HTML.

Inicialmente, tendremos un botón de descarga cuya función es iniciar la formación del archivo de informe en formato HTML. Luego va la imágen. Pero el archivo para esta se generará sobre la marcha del método GetImage en el controlador.

Vamos al controlador HomeController.cs. Necesitarémos estas bibliotecas:

1
2
3
4
5
6
7
8
9

using System.IO;
using System.Diagnostics;
using Microsoft.AspNetCore.Mvc;
using OpenSourceReportExport.Models;
using FastReport;
using FastReport.Export.Image;
using FastReport.Export.Html;
using System.Data;
using Microsoft.AspNetCore.Hosting;

Para establecer ubicaciones determinadas para archivos en el servidor, vamos a utilizar la interfaz IHostingEnvironment. Con este fin pasamos el objeto del tipo IHostingEnvironment al constructor de controlador.

1
2
3
4
5
6

 public HomeController(IHostingEnvironment hostingEnvironment)
 {
 _hostingEnvironment = hostingEnvironment;
 }
 
 private IHostingEnvironment _hostingEnvironment;

El método Index no se debe modificar:

1
2
3
4

public IActionResult Index()
 {
 return View();
 }

Añada un nuevo método para obtener el informe en formato de imágen. Así exportarémos, por ejemplo, en formato .jpeg.

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

public IActionResult GetImage()
 {
 // Creatint the Report object
 using (Report report = new Report())
 {
 string path = _hostingEnvironment.WebRootPath;
 // Loading a report
 report.Load(path + "\\App_Data\\Master-Detail.frx");
 DataSet data = new DataSet();
 data.ReadXml(path + "\\App_Data\\nwind.xml"); //Open xml database
 report.RegisterData(data, "NorthWind"); //Register data source in the report
 report.Prepare();// Preparing a report
 
 // Creating the Image export
 using (ImageExport image = new ImageExport())
 { 
 image.ImageFormat = ImageExportFormat.Jpeg;
 image.JpegQuality = 100; // Set up the quality
 image.Resolution = 100; // Set up a resolution 
 image.SeparateFiles = false; // We need all pages in one big single file
 
using (MemoryStream st = new MemoryStream())// Using stream to save export
 {
 report.Export(image, st);
 return base.File(st.ToArray(), "image/jpeg");
 }
 }
 }
 }

El segundo método es para guardar la exportación del informe en formato HTML. De hecho, es lo mismo que en el anterior.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

 [HttpGet]
 public ActionResult Save()
 {
 using (Report report = new Report())
 {
 string path = _hostingEnvironment.WebRootPath;
 // Loading a report
 report.Load(path + "\\App_Data\\Master-Detail.frx");
 DataSet data = new DataSet();
 data.ReadXml(path + "\\App_Data\\nwind.xml"); //Open xml database
 report.RegisterData(data, "NorthWind"); //Register data source in the report
 report.Prepare();// Preparing a report
 
 // Creating the HTML export
 using (HTMLExport html = new HTMLExport())
 {
 using (FileStream st = new FileStream(path + "\\App_Data\\test.html", FileMode.Create))
 {
 report.Export(html, st);
 return File("App_Data/test.html", "application/octet-stream", "Test.html");
 }
 }
 }
 }

En este método hemos obtenido un archivo HTML. Esto quiere decir que no tenga imágenes. Para guardar el archivo HTML con imágenes, hay que guardar el archivo en bucle. Un ejemplo de esta operación se puede encontrar en la documentación FastReport Open Source: 

https://fastreports.github.io/FastReport.Documentation/Exporting.html.

Arranquemos nuestra aplicación:

La imágen contiene todas las páginas del informe porque hemos establecido la propiedad SeparateFiles = false. Si no, tendría que mostrar varios archivos.

Presione el botón Save report in HTML:

Y el archivo se guarda automáticamente por el navegador.

¡Ya está! Como puede ver, la implementación en el código en FastReport.OpenSource parece mucho a la de FastReport.Core..