ReportStorageWebExtension Class

A report storage for Web Reporting.

Namespace: DevExpress.XtraReports.Web.Extensions

Assembly: DevExpress.XtraReports.v22.1.Web.dll

NuGet Package: DevExpress.Web.Reporting.Common

Declaration

C#

public abstract class ReportStorageWebExtension :
    IReportStorageTool,
    IReportStorageWebTool,
    IReportStorageTool2

VB.NET

Public MustInherit Class ReportStorageWebExtension
    Implements IReportStorageTool,
               IReportStorageWebTool,
               IReportStorageTool2

Remarks

When you bind the Web Document Viewer or Report Designer to a report specified by name (a string identifier), the control uses custom services, registered in the application, to resolve a report name to a report object. The services are queried in the following order:

1. IWebDocumentViewerReportResolver (Web Document Viewer only)
2. IReportProvider
3. ReportStorageWebExtension

When you save a report in the Web Report Designer, the ReportStorageWebExtension service is called to save the report data.

Create the ReportStorageWebExtension class descendant and register it in your application to implement a custom report storage.

Refer to the following help topics for more information:

• Add a Report Storage (ASP.NET Web Forms)
• Add a Report Storage (ASP.NET MVC)
• Add a Report Storage (ASP.NET Core)
• Create a Blazor Reporting (JavaScript-Based) Application

Examples

For a code example, create a new Web project from the DevExpress Visual Studio template and review the code for the CustomReportStorageWebExtension class in the Services folder.

• Report Storage based on a file system:

  Show code

  C#

  using DevExpress.XtraReports.UI;
  using System;
  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using System.ServiceModel;
  
  public class CustomReportStorageWebExtension : DevExpress.XtraReports.Web.Extensions.ReportStorageWebExtension
  {
      readonly string reportDirectory;
      const string FileExtension = ".repx";
      public CustomReportStorageWebExtension(string reportDirectory)
      {
          if (!Directory.Exists(reportDirectory))
          {
              Directory.CreateDirectory(reportDirectory);
          }
          this.reportDirectory = reportDirectory;
      }
  
      private bool IsWithinReportsFolder(string url, string folder)
      {
          var rootDirectory = new DirectoryInfo(folder);
          var fileInfo = new FileInfo(Path.Combine(folder, url));
          return fileInfo.Directory.FullName.ToLower().StartsWith(rootDirectory.FullName.ToLower());
      }
  
      public override bool CanSetData(string url)
      {
          // Determines whether a report with the specified URL can be saved.
          // Add custom logic that returns **false** for reports that should be read-only.
          // Return **true** if no valdation is required.
          // This method is called only for valid URLs (if the **IsValidUrl** method returns **true**).
  
          return true;
      }
  
      public override bool IsValidUrl(string url)
      {
          // Determines whether the URL passed to the current report storage is valid.
          // Implement your own logic to prohibit URLs that contain spaces or other specific characters.
          // Return **true** if no validation is required.
  
          return Path.GetFileName(url) == url;
      }
  
      public override byte[] GetData(string url)
      {
          // Uses a specified URL to return report layout data stored within a report storage medium.
          // This method is called if the **IsValidUrl** method returns **true**.
          // You can use the **GetData** method to process report parameters sent from the client
          // if the parameters are included in the report URL's query string.
          try
          {
              if (Directory.EnumerateFiles(reportDirectory).Select(Path.GetFileNameWithoutExtension).Contains(url))
              {
                  return File.ReadAllBytes(Path.Combine(reportDirectory, url + FileExtension));
              }
              if (ReportsFactory.Reports.ContainsKey(url))
              {
                  using (MemoryStream ms = new MemoryStream())
                  {
                      ReportsFactory.Reports[url]().SaveLayoutToXml(ms);
                      return ms.ToArray();
                  }
              }
          }
          catch (Exception)
          {
              throw new FaultException(new FaultReason("Could not get report data."),
                  new FaultCode("Server"), "GetData");
          }
          throw new FaultException(new FaultReason(string.Format("Could not find report '{0}'.", url)),
              new FaultCode("Server"), "GetData");
      }
  
      public override Dictionary<string, string> GetUrls()
      {
          // Returns a dictionary that contains the report names (URLs) and display names. 
          // The Report Designer uses this method to populate the Open Report and Save Report dialogs.
  
          return Directory.GetFiles(reportDirectory, "*" + FileExtension)
                                   .Select(Path.GetFileNameWithoutExtension)
                                   .Union(ReportsFactory.Reports.Select(x => x.Key))
                                   .ToDictionary<string, string>(x => x);
      }
  
      public override void SetData(XtraReport report, string url)
      {
          // Saves the specified report to the report storage with the specified name
          // (saves existing reports only).
  
          if (!IsWithinReportsFolder(url, reportDirectory))
              throw new FaultException(new FaultReason("Invalid report name."), new FaultCode("Server"), "GetData");
          report.SaveLayoutToXml(Path.Combine(reportDirectory, url + FileExtension));
      }
  
      public override string SetNewData(XtraReport report, string defaultUrl)
      {
          // Allows you to validate and correct the specified name (URL).
          // This method also allows you to return the resulting name (URL),
          // and to save your report to a storage. The method is called only for new reports.
  
          SetData(report, defaultUrl);
          return defaultUrl;
      }
  }
  
  public static class ReportsFactory
  {
      static ReportsFactory()
      {
          Reports.Add("TestReport", () => new TestReport());
      }
      public static Dictionary<string, Func<XtraReport>> Reports = new Dictionary<string, Func<XtraReport>>();
  }
  

  VB.NET

  Imports System.IO
  Imports System.ServiceModel
  Imports DevExpress.XtraReports.UI
  
  Public Class CustomReportStorageWebExtension
      Inherits DevExpress.XtraReports.Web.Extensions.ReportStorageWebExtension
  
      Private ReadOnly reportDirectory As String
      Private Const FileExtension As String = ".repx"
      Public Sub New(ByVal reportDirectory As String)
          If Not Directory.Exists(reportDirectory) Then
              Directory.CreateDirectory(reportDirectory)
          End If
          Me.reportDirectory = reportDirectory
      End Sub
  
      Private Function IsWithinReportsFolder(ByVal url As String, ByVal folder As String) As Boolean
          Dim rootDirectory = New DirectoryInfo(folder)
          Dim fileInfo = New FileInfo(Path.Combine(folder, url))
          Return fileInfo.Directory.FullName.ToLower().StartsWith(rootDirectory.FullName.ToLower())
      End Function
  
      Public Overrides Function CanSetData(ByVal url As String) As Boolean
          ' Determines whether a report with the specified URL can be saved.
          ' Add custom logic that returns **false** for reports that should be read-only.
          ' Return **true** if no valdation is required.
          ' This method is called only for valid URLs (if the **IsValidUrl** method returns **true**).
  
          Return True
      End Function
  
      Public Overrides Function IsValidUrl(ByVal url As String) As Boolean
          ' Determines whether the URL passed to the current report storage is valid.
          ' Implement your own logic to prohibit URLs that contain spaces or other specific characters.
          ' Return **true** if no validation is required.
  
          Return Path.GetFileName(url) = url
      End Function
  
      Public Overrides Function GetData(ByVal url As String) As Byte()
          ' Uses a specified URL to return report layout data stored within a report storage medium.
          ' This method is called if the **IsValidUrl** method returns **true**.
          ' You can use the **GetData** method to process report parameters sent from the client
          ' if the parameters are included in the report URL's query string.
  
          Try
              If Directory.EnumerateFiles(reportDirectory).
                  Select(AddressOf Path.GetFileNameWithoutExtension).Contains(url) Then
                  Return File.ReadAllBytes(Path.Combine(reportDirectory, url & FileExtension))
              End If
              If ReportsFactory.Reports.ContainsKey(url) Then
                  Using ms As New MemoryStream()
                      ReportsFactory.Reports(url)().SaveLayoutToXml(ms)
                      Return ms.ToArray()
                  End Using
              End If
          Catch e1 As Exception
              Throw New FaultException(New FaultReason("Could not get report data."),
                  New FaultCode("Server"), "GetData")
          End Try
          Throw New FaultException(New FaultReason(String.Format("Could not find report '{0}'.", url)),
              New FaultCode("Server"), "GetData")
      End Function
  
      Public Overrides Function GetUrls() As Dictionary(Of String, String)
          ' Returns a dictionary that contains the report names (URLs) and display names. 
          ' The Report Designer uses this method to populate the Open Report and Save Report dialogs.
  
          Return Directory.GetFiles(reportDirectory, "*" & FileExtension).
              Select(AddressOf Path.GetFileNameWithoutExtension).
              Concat(ReportsFactory.Reports.Select(Function(x) x.Key)).ToDictionary(Function(x) x)
      End Function
  
      Public Overrides Sub SetData(ByVal report As XtraReport, ByVal url As String)
          ' Saves the specified report to the report storage with the specified name
          ' (saves existing reports only).
  
          If Not IsWithinReportsFolder(url, reportDirectory) Then Throw New FaultException(New FaultReason("Invalid report name."),
              New FaultCode("Server"), "GetData")
          report.SaveLayoutToXml(Path.Combine(reportDirectory, url & FileExtension))
      End Sub
  
      Public Overrides Function SetNewData(ByVal report As XtraReport, ByVal defaultUrl As String) As String
          ' Allows you to validate and correct the specified name (URL).
          ' This method also allows you to return the resulting name (URL),
          ' and to save your report to a storage. The method is called only for new reports.
  
          SetData(report, defaultUrl)
          Return defaultUrl
      End Function
  End Class
  
  Public Module ReportsFactory
      Public Reports As New Dictionary(Of String, Func(Of XtraReport))() From {
          {"TestReport", Function() New TestReport()}
      }
  End Module
  

• Report Storage based on a SQLite database:

  Show code

  Services/CustomReportStorageWebExtension.cs

  using System.Collections.Generic;
  using System.IO;
  using System.Linq;
  using DevExpress.XtraReports.UI;
  using AspNetCoreSample.PredefinedReports;
  using AspNetCoreSample.Data;
  
  namespace AspNetCoreSample.Services
  {
      public class CustomReportStorageWebExtension : 
          DevExpress.XtraReports.Web.Extensions.ReportStorageWebExtension
      {
          protected ReportDbContext DbContext { get; set; }
          public CustomReportStorageWebExtension(ReportDbContext dbContext) {
              this.DbContext = dbContext;
          }
  
          public override bool CanSetData(string url) {
              // Determines whether a report with the specified URL can be saved.
              // Add custom logic that returns **false** for reports that should be read-only.
              // Return **true** if no valdation is required.
              // This method is called only for valid URLs (if the **IsValidUrl** method returns **true**).
  
              return true;
          }
  
          public override bool IsValidUrl(string url) {
              // Determines whether the URL passed to the current report storage is valid.
              // Implement your own logic to prohibit URLs that contain spaces or other specific characters.
              // Return **true** if no validation is required.
  
              return true;
          }
  
          public override byte[] GetData(string url) {
              // Uses a specified URL to return report layout data stored within a report storage medium.
              // This method is called if the **IsValidUrl** method returns **true**.
              // You can use the **GetData** method to process report parameters sent from the client
              // if the parameters are included in the report URL's query string.
              var reportData = DbContext.Reports.FirstOrDefault(x => x.Name == url);
              if(reportData != null)
                  return reportData.LayoutData;
  
              if(ReportsFactory.Reports.ContainsKey(url)) {
                  using var ms = new MemoryStream();
                  using XtraReport report = ReportsFactory.Reports[url]();
                  report.SaveLayoutToXml(ms);
                  return ms.ToArray();
              }
              throw new DevExpress.XtraReports.Web.ClientControls.FaultException(
                  string.Format("Could not find report '{0}'.", url));
          }
  
          public override Dictionary<string, string> GetUrls() {
              // Returns a dictionary that contains the report names (URLs) and display names. 
              // The Report Designer uses this method to populate the Open Report and Save Report dialogs.
  
              return DbContext.Reports
                  .ToList()
                  .Select(x => x.Name)
                  .Union(ReportsFactory.Reports.Select(x => x.Key))
                  .ToDictionary<string, string>(x => x);
          }
  
          public override void SetData(XtraReport report, string url) {
              // Saves the specified report to the report storage with the specified name
              // (saves existing reports only). 
              using var stream = new MemoryStream(); report.SaveLayoutToXml(stream);
              var reportData = DbContext.Reports.FirstOrDefault(x => x.Name == url);
              if(reportData == null) {
                  DbContext.Reports.Add(new ReportItem { Name = url, LayoutData = stream.ToArray() });
              } else {
                  reportData.LayoutData = stream.ToArray();
              }
              DbContext.SaveChanges();
          }
  
          public override string SetNewData(XtraReport report, string defaultUrl) {
              // Allows you to validate and correct the specified name (URL).
              // This method also allows you to return the resulting name (URL),
              // and to save your report to a storage. The method is called only for new reports.
              SetData(report, defaultUrl);
              return defaultUrl;
          }
      }
  }
  

  Data/ReportDbContext.cs

  using System.Linq;
  using Microsoft.EntityFrameworkCore;
  
  namespace AspNetCoreSample.Data {
      public class SqlDataConnectionDescription : DataConnection { }
      public class JsonDataConnectionDescription : DataConnection { }
      public abstract class DataConnection {
          public int Id { get; set; }
          public string Name { get; set; }
          public string DisplayName { get; set; }
          public string ConnectionString { get; set; }
      }
  
      public class ReportItem {
          public int Id { get; set; }
          public string Name { get; set; }
          public string DisplayName { get; set; }
          public byte[] LayoutData { get; set; }
      }
  
      public class ReportDbContext : DbContext {
          public DbSet<JsonDataConnectionDescription> JsonDataConnections { get; set; }
          public DbSet<SqlDataConnectionDescription> SqlDataConnections { get; set; }
          public DbSet<ReportItem> Reports { get; set; }
          public ReportDbContext(DbContextOptions<ReportDbContext> options) : base(options) {
          }
          public void InitializeDatabase() {
              Database.EnsureCreated();
  
              var nwindJsonDataConnectionName = "NWindProductsJson";
              if(!JsonDataConnections.Any(x => x.Name == nwindJsonDataConnectionName)) {
                  var newData = new JsonDataConnectionDescription {
                      Name = nwindJsonDataConnectionName,
                      DisplayName = "Northwind Products (JSON)",
                      ConnectionString = "Uri=Data/nwind.json"
                  };
                  JsonDataConnections.Add(newData);
              }
  
  
              var nwindSqlDataConnectionName = "NWindConnectionString";
              if(!SqlDataConnections.Any(x => x.Name == nwindSqlDataConnectionName)) {
                  var newData = new SqlDataConnectionDescription {
                      Name = nwindSqlDataConnectionName,
                      DisplayName = "Northwind Data Connection",
                      ConnectionString = "XpoProvider=SQLite;Data Source=|DataDirectory|/Data/nwind.db"
                  };
                  SqlDataConnections.Add(newData);
              }
  
              var reportsDataConnectionName = "ReportsDataSqlite";
              if(!SqlDataConnections.Any(x => x.Name == reportsDataConnectionName)) {
                  var newData = new SqlDataConnectionDescription {
                      Name = reportsDataConnectionName,
                      DisplayName = "Reports Data (Demo)",
                      ConnectionString = "XpoProvider=SQLite;Data Source=|DataDirectory|/Data/reportsData.db"
                  };
                  SqlDataConnections.Add(newData);
              }
              SaveChanges();
          }
      }
  }
  

  PredefinedReports/ReportsFactory.cs

  using DevExpress.XtraReports.UI;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Threading.Tasks;
  
  namespace AspNetCoreSample.PredefinedReports
  {
      public static class ReportsFactory
      {
          public static Dictionary<string, Func<XtraReport>> Reports = new Dictionary<string, Func<XtraReport>>()
          {
              ["TestReport"] = () => new TestReport()
          };
      }
  }
  

Inheritance

Object

ReportStorageWebExtension