Cómo utilizar los informes FastReport en una aplicación PHP. Parte 1

FastReport.Net está diseñado para las plataformas .Net lo que quiere decir que los informes web funcionan a base de las tecnologías ASP.Net y ASP.Net COre.

Pero la mayoría de los sitios web sigue en PHP. Y entre los usuarios hay muchos a los que les gustaría mostrar en sus aplicaciones PHP informes FastReport. Como entiende, es bastante posible gracias al protocolo http. Simplemente vamos a utilizar una aplicación PHP como parte de cliente, mientras ASP.Net Core, como parte de servidor.

Vamos a posibilitar la salida del informe, la salida del sideñador de informes y la descarga de informes en uno de los dos formatos, PHP o HTML (son bastantes dos formatos para la demostración).

De esta manera, en nuestra aplicación PHP habrá tres páginas: visualización del informe, visualización del diseñador de informes y descarga de informes.

Empecemos a implementar la parte de servidor. La tecnología más conviniente será ASP.Net Core porque es una solución multiplataforma, es decir, la aplicación podrá funcionar en un servidor linux. Como dice la estadística, el servidor linux es la solucón más popular para la colocación de sitios web.

En primer lugar, tenemos que descargar diseñador de informes desde el sitio web del desarrollador. Para descargarlo, hay que complilarlo antemano en un configurador especial. Fíjese en una opción de la que depende el funcionamiento del diseñador en su proyecto.

Tiene que seleccionar FastReport.Web  para Core.

Así, creamos una aplicación ASP.Net Core. Para utilizar informes web en ella, hay que instalar los paquetes en el administrador de paquetes NuGet. Estos paquetes están ubicados en el directorio de instalación FastReport.Net, en la carpeta Nuget. Por lo cual, tendrá que ajustar la fuente local de paquetes en el administrador de paquetes NuGet.

Como resultado, tendrá que instalar los siguientes paquetes: FastReport.Core y FastReport.Web.

Para utilizar las bibliotecas en su proyecto, hay que conectarlos en el archivo Startup.cs:

1
2
3
4
5
6

 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {
 …
 app.UseFastReport();
 …
 }

Vamos a empezar por la creación de las funcionalidades básicas del programa. Ya hemos creado nuestro propio controlador para implementar métodos WebAPI. Pero primero es lo primero.

 
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
35
36
37
38
39
40
41
42
43
44

using FastReport.Web;
using System.IO;
using FastReport;
using FastReport.Export.Html;
using FastReport.Export.Pdf;
using SimpleReportViewer.Models;
using System.Data;
using FastReport.Utils;
 
namespace SimpleReportViewer.Controllers
{
 [Route("api/[controller]")]
 public class ReportsController : Controller
 {
 private IHostingEnvironment _env;
 
// Web application directory path
 public string webRoot
 {
 get { return _env.WebRootPath; }
 set { }
 }
 
 public ReportsController(IHostingEnvironment env)
 {
 _env = env;
 }
 
 // Show report by name
 [HttpGet("[action]")]
 public IActionResult ShowReport(string name)
 {
 if (name == null) name = "Master-Detail.frx";
 WebReport WebReport = new WebReport();
 WebReport.Width = "1000";
 WebReport.Height = "1000";
 WebReport.Report.Load(String.Format("{0}/App_Data/{1}", webRoot, name)); // Download the report to the WebReport object
 System.Data.DataSet dataSet = new System.Data.DataSet(); // Download the report to the WebReport object
 dataSet.ReadXml(String.Format("{0}/App_Data/nwind.xml", webRoot)); // Open the xml database
 WebReport.Report.RegisterData(dataSet, "NorthWind"); // Register the data source in the report
 ViewBag.WebReport = WebReport; // Pass the report to View 
return View();
 }
}

Primero hemos recibido la ubicación de la carpeta de la aplicación wwwroot. A continuación realizamos el método de recibir informe. Este método debe tener el nombre del informe. Esto último si el nombre del informe no se ha pasado. Para este método web hay que crear una vista. Para eso hagamos clic con el botón derecho en la signatura del método y seleccionamos del menú desplegable "Añadir vista...." A continuación simplemente pulsamos OK.

En la aplicación creada remplazamos el código por:

@await ViewBag.WebReport.Render()

Tenemos hipervínculos para los informes pero no los hemos añadido al proyecto todavía. Creamos una carpeta App_Data y añadimos a esta los informes y una base de datos para ellos:

También colocamos la carpeta con el diseñador de informes en wwwroot: 

 

Ahora podemos añadir el método de mostrar diseñador de informes a nuestro controlador ReportsController:

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

// Static variable for storing the report name
 public static string ReportName;
// We show the designer with a report
 
 [HttpGet("[action]")]
 public IActionResult Design(string name)
 {
 if (name == null) name = "Master-Detail.frx";
 var webRoot = _env.WebRootPath;
 WebReport WebReport = new WebReport();
 WebReport.Width = "1000";
 WebReport.Height = "1000";
 WebReport.Report.Load(System.IO.Path.Combine(webRoot, (String.Format("App_Data/{0}", name)))); // Download the report to the WebReport object
 System.Data.DataSet dataSet = new System.Data.DataSet(); // Create a data source
 dataSet.ReadXml(System.IO.Path.Combine(webRoot, "App_Data/nwind.xml")); // Open the xml database
 WebReport.Report.RegisterData(dataSet, "NorthWind"); // Register the data source in the report
ReportName = name;
 WebReport.Mode = WebReportMode.Designer; // Set the mode of the object web report - display designer
 WebReport.DesignerLocale = "en";
 WebReport.DesignerPath = "/WebReportDesigner/index.html"; // Set the URL of the online designer
WebReport.DesignerSaveCallBack = "api/reports/SaveDesignedReport"; // Set the view URL for the report save method
 WebReport.Debug = true;
 ViewBag.WebReport = WebReport; // Pass the report to View
 return View();
 }

Este método también recibe como parámetro el nombre del informe. Para mostrar el diseñador de informes, se utiliza el objeto WebReport. Lo importante aquí es establecer la ubicación correcta para diseñador y manipulador de evento de guardar informe.

Creamos una vista para este método con un código simple:

1
2
3
4
5

@{
 ViewData["Title"] = "Design";
}
 
@await ViewBag.WebReport.Render()

Añadimos un método más al controlador. Este servirá para manipular el evento de guardar el informe editado en el diseñador:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 // call-back for save the designed report
 [HttpPost("[action]")]
 public IActionResult SaveDesignedReport(string reportID, string reportUUID)
 {
 var webRoot = _env.WebRootPath;
 ViewBag.Message = String.Format("Confirmed {0} {1}", reportID, reportUUID); // We set the message for presentation
 
 Stream reportForSave = Request.Body; // We write the result of the Post request to the stream
 string pathToSave = System.IO.Path.Combine(webRoot, @"App_Data/"+ ReportName); // We get the path to save the file
 using (FileStream file = new FileStream(pathToSave, FileMode.Create)) // Create a file stream
 {
 reportForSave.CopyTo(file); // Save the result of the request to a file
 }
 return View();
 }

Fíjese: hemos guardado el informe en la carpeta App_Data bajo el mismo nombre porque habíamos guardado el nomre del informe cuando lo habíamos abierto en el diseñador. De esta manera, el informe de origen se remplazará por el informe editado.

Con anticipación le digo que verá la palabra saved en el diseñador si este método se realiza sin errores.

Con esto terminamos el primer artículo. En la segunda parte vamos a considerar el método de recibir la exportación del informe según url

Part 2.

Part 3.

about product comprar
FastReport ASP.NET Core PHP
Add comment