logo
small logo
  • Produkte
  • Shop
  • Support
  • Über uns
  • Customer panel Support
    • en
    • de
    • JP
    • ZH
  • Home
  • /
  • Articles
  • /
  • Bericht im Online Designer öffnen, bearbeiten und speichern
  • Lokalisation von den Online Designer und Web Bericht

    15. August 2017

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 public ActionResult Index(string language) { WebReport webReport = new WebReport(); //ein Exemplar der Klasse WebReport

    read more
  • Wie man einen Bericht aus dem Code einer Webanwendung erstellt

    16. Februar 2022

    Manchmal kann die Erstellung eines Berichts echtes Kopfzerbrechen bereiten. Zum Beispiel, wenn Sie den

    read more
  • Wie verwendet man FastCube .NET in der Knockout SPA.js Anwendung

    21. Juli 2021

    Um den Cube von Daten zu ableiten, werden wir eine SPA Anwendung mit Knockout.js schaffen

    read more
  • How to use Online Designer in ASP .NET Core

    17. Januar 2018

    One of the novelties by FastReport .NET 2018 was the adaptation of OnlineDesigner to the

    read more
  • Wie wird das Objekt WebReport in ASP .Net Core App verwendet?

    17. Januar 2018

    Neulich veröffentlichte Fast Reports eine neue Bibliothek für die Arbeit mit dem Framework ASP .Net

    read more

Bericht im Online Designer öffnen, bearbeiten und speichern

29. Juli 2017

Eine der ersten Fragen, die sich die Anwender stellen, lautet wie: wie organisiert man das Download von den Berichten aus dem lokalen Rechner? Heute besprechen wir diese zwei Mechanismen mit der ASP.Net MVC Anwendung.

Wir erstellen ein ASP.Net MVC Projekt. Dazu brauchen wir folgende Bibliotheken:

Wir öffnen den Controller HomeController.cs. Weiter fügen abgängige Bibliotheken in die Sektion uses hinzu:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.UI;
using System.Runtime.Caching;
using System.Text;
using System.IO;
using FastReport;
using FastReport.Web;
using FastReport.Utils;
using System.Web.UI.WebControls;
using FastReport.Export.Html;
using FastReport.Data;
using System.Net.Http.Headers;
using FastReport.Export.Image;
using System.Net.Http;

In der Methode „Index“ stellen wir Online Designer dar. Aber zuerst erstellen wir ein Objekt von Web Report und einen Cache. Wir verwenden Cache, um das Speichern am Server zu vermeiden:

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
private WebReport webReport = new WebReport(); //Report object
 
 MemoryCache cache = MemoryCache.Default; //Cache
 
 public ActionResult Index(HttpPostedFileBase upload)
 {
 webReport.Width = Unit.Percentage(100);
 webReport.Height = Unit.Percentage(100); 
 string report_path = GetReportPath(); // The path to the folder with reports
 System.Data.DataSet dataSet = new System.Data.DataSet();
 dataSet.ReadXml(report_path + "nwind.xml"); //Read database
 webReport.Report.RegisterData(dataSet, "NorthWind"); // Register the data in the report
// If you do not use the cache, then load the report from the server
 if (System.IO.File.Exists(report_path + "report.frx"))
 {
 webReport.Report.Load(report_path + "report.frx");
 }
// If you are using a cache, then load a report from it
 if (cache.Contains("1"))
 {
 webReport.Report.Load(cache["1"] as Stream);
 }
 
 // Online-Designer settings
 webReport.DesignReport = true;
 webReport.DesignScriptCode = false;
 webReport.Debug = true;
 webReport.DesignerPath = "~/WebReportDesigner/index.html";
 webReport.DesignerSaveCallBack = "~/Home/SaveDesignedReport";
 webReport.ID = "DesignReport";
 ViewBag.WebReport = webReport; //Pass the report to View
 
 return View();
 }

Weiter bestimmen wir den Weg zu den Berichten:

1
2
3
4
 private string GetReportPath()
 {
 return this.Server.MapPath("~/App_Data/"); 
 }

Weiter fügen wir die Methode fürs Download der Datei:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[HttpPost] // Attribute indicates that the method is processing the Post request
 public ActionResult Upload(HttpPostedFileBase upload)
 {
 
 
 if (upload != null)
 {
 // Get file name
 string fileName = System.IO.Path.GetFileName(upload.FileName);
 // Save report in cache
 cache.Add("1", upload.InputStream, DateTimeOffset.Now.AddMinutes(1));
 // If you save to a file on the server
 upload.SaveAs(Server.MapPath("~/App_Data/report.frx"));
 }
 return RedirectToAction("Index");
 }

Merken Sie sich den Parameter DateTimeOffset.Now.AddMinutes(1) im Aufruf der Funktion cache.Add. Dieser Parameter bestimmt der Cache-Lebenszeit.

Jetzt brauchen wir eine Bestimmung der Speichern-Methode in den Online Designer:

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
[HttpPost]
 // call-back for save the designed report 
 public ActionResult SaveDesignedReport(string reportID, string reportUUID)
 {
 ViewBag.Message = String.Format("Confirmed {0} {1}", reportID, reportUUID);
 
 if (reportID == "DesignReport")
 {
//Save report in cache
 cache.Set("1", Request.InputStream, DateTimeOffset.Now.AddMinutes(10));
 
 // If the report is saved to the server /*************************************/
 
 Stream reportForSave = Request.InputStream;
 
 string pathToSave = Server.MapPath("~/App_Data/DesignedReports/test.frx");
 
 
 using (FileStream file = new FileStream(pathToSave, FileMode.Create))
 {
 reportForSave.CopyTo(file);
 } 
/*************************************/
 }
 return View();
 
 }

Für diese Methode erstellen wir neue Darstellung SaveDesignedReport.cshtml mit folgendem Code:

1
<h2>@ViewBag.Message</h2>

Wir realisieren jetzt die Methode fürs Herunterladen der Datei:

1
2
3
4
5
6
7
8
 public FileResult GetFile()
 {
 Stream str = cache["1"] as Stream;
// Prepare a file for download from the cache
return File(str, "application/octet-stream","test.frx");
// If you used saving report to the file on the server
return File(Server.MapPath("~/App_Data/DesignedReports/test.frx"), "application/octet-stream", "test.frx"); 
 }

Jetzt betrachten wir eine Darstellung für die Seite «Index» (Home->Index.cshtml):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@{
 ViewBag.Title = "Home Page";
}
<h3>Select file</h3>
@using (Html.BeginForm("Upload", "Home", FormMethod.Post, new { enctype = "multipart/form-data" }))
{
 <input type="file" name="upload" />
 <input type="submit" value="Upload" />
}
<div style="float:right"> 
 @using (Html.BeginForm("GetFile", "Home", FormMethod.Get))
 {
 <input id="dwn" type="submit" value="Download designed report" />
 }
</div>
@ViewBag.WebReport.GetHtml()

Zuerst stellen wir den Titel der Seite an. Weiter verwenden wir den Helper BeginForm, um die Form mit der Taste für die Wahl der Datei zu erstellen. In den Parameter steht der Name der Bearbeitungsmethode – «Upload», der Name des Kontrollers – «Home», Bearbeitungsmethode – FormMethod.Post, der Typ der Datencodierung -  enctype = "multipart/form-data".

Weiter setzen wir das Feld fürs Datei-Download und die Taste.

Im ersten Teil der Seite platzieren wir noch eine Taste fürs Download des bearbeiteten Berichts. Für diese Taste erstellen wir auch eine Form mit Hilfe vom Helper BeginForm.

In erster Zeile stellen wir den Bericht dar, der aus dem Kontroller erhalten wurde.

In der Datei _Layout.cshtml aktiviert man Scripts:    

1
2
3
4
<head>
@WebReportGlobals.Scripts()
@WebReportGlobals.Styles() 
</head>

Jetzt verändert man zwei Web Configs. Diese Dateien haben gleichen Namen, aber befinden sich in verschiedenen Ordnern. Erste ist im Ordner Views. Wir öffnen diesen Ordner und fügen folgende Zeilen dorthin hinzu:

1
2
3
4
5
<namespaces>
…
 <add namespace="FastReport" />
 <add namespace="FastReport.Web" />
 </namespaces>

Zweite Datei befindet sich im Kern-Ordner des Projekts. Wir fügen in diese Datei einen Bearbeiter hinzu:

1
2
3
4
5
6
<system.webServer> 
 <handlers>
 …
 <add name="FastReportHandler" path="FastReport.Export.axd" verb="*" type="FastReport.Web.Handlers.WebExport"/>
 </handlers>
 </system.webServer>

Und wir starten die Anwendung.

Upload Auf dem Bildschirm ist ein OnlineDesigner mit dem leeren Bericht. Laden wir den Bericht vom lokalen Rechner mit Hilfe von der Taste „Select File“ herunter. Vom Dialogfenster wählen wir die Datei und klicken auf die Taste:

Die Berichts Schablone ist heruntergeladen. Jetzt verändern wir die Farbe im Daten-Band. Im Tab „Report“ klicken wir die Taste „Save“:

Auch wird die Methode SaveDesignedReport gestartet und wir sehen ein grünes Zeichnen auf der rechten Seite:

Weiter klicken wir die Taste „Download designed report“:

Der Browser hat unseren Bericht heruntergeladen. Wir öffnen ihn mit Hilfe vom Report Designer:

Und wir bekommen unseren Bericht, der mit Hilfe vom Designer bearbeitet wurde.

about product buy
avatar
Dmitriy Fedyashov
Technical Writer
Fast Reports Team: Dmitriy Fedyashov - Technical Writer at Fast Reports
.NET FastReport MVC Online Designer WebReport

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
  • Shop
  • Download
  • Dokumentation
  • Referenzen
  • Informationen zur Deinstallation unserer Produkte
  • FAQ
  • Tutorial Video
  • Forum
  • Articles
  • Unsere Nachrichten
  • Presse über uns
  • Partner
  • Außergewöhnliche Lizenzierung
  • Kontakte

© 1998-2023 by Fast Reports Inc.

  • Datenschutz