logo
small logo
  • Producto
  • Comprar
  • Ayuda
  • About
  • Consola de usarios Ayuda
    • en
    • de
    • JP
    • ZH
  • Página principal
  • /
  • Blogs
  • /
  • Cómo utilizar los informes FastReport en una aplicación PHP. Parte 1
  • How to create business cards from ASP .NET Core application

    31 de mayo de 2020

    ASP.NET Core Framework is a cross-platform solution for creating web applications. This means that you

    read more
  • How to create the invoice from ASP.Net Core application

    31 de agosto de 2020

    Few believed in the success of the new open-source ASP.Net Core framework from Microsoft. It’s

    read more
  • Cómo utilizar FastReport en una aplicación PHP. Parte 2

    13 de octubre de 2019

    En la primera parte del artículo creamos una aplicación SP.Net Core en la que implementamos

    read more
  • Informes y documentos PDF en Blazor

    5 de abril de 2021

    Microsoft ha lanzado recientemente una plataforma web llamada Blazor. Este marco permite crear una interfaz

    read more
  • Paquetes FastReport .NET y .NET 5.0

    17 de diciembre de 2020

    UPD: Se aplica a las versiones de FastReport. NET anteriores a 2022.2. Los paquetes de

    read more

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

13 de octubre de 2019

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
avatar
Dmitriy Fedyashov
Technical Writer
Fast Reports Team: Dmitriy Fedyashov - Technical Writer at Fast Reports
FastReport ASP.NET Core PHP

Add comment
logo
  • 800-985-8986 (English, US)
  • +4930568373928 (German)
  • +55 19 98147-8148 (Portuguese)
  • info@fast-report.com
  • 901 N Pitt Str #325 Alexandria VA 22314
  • Comprar
  • Descargar
  • Documentación
  • Opiniones de usuarios
  • Cómo desinstalar nuestros productos
  • FAQ
  • Toturial en vídeo
  • Foro
  • Documentación técnica
  • Nuestras noticias
  • Quiénes somos
  • Socios
  • Extended licensing
  • Contactos

© 1998-2023 by Fast Reports Inc.

  • Privacidad