/// <summary>
/// The report will be generated, but not shown to the user.
/// </summary>
/// <param name="ACalc"></param>
/// <param name="Format"></param>
public MemoryStream ExportToStream(TRptCalculator ACalc, ReportExportType Format)
{
MemoryStream HtmlStream = new MemoryStream();
object exporter;
Type ExporterType;
if (Format == ReportExportType.Pdf)
{
exporter = FastReportsDll.CreateInstance("FastReport.Export.Pdf.PDFExport");
ExporterType = exporter.GetType();
ExporterType.GetProperty("EmbeddingFonts").SetValue(exporter, false, null);
}
else // otherwise do HTML - text is not yet supported.
{
exporter = FastReportsDll.CreateInstance("FastReport.Export.Html.HTMLExport");
ExporterType = exporter.GetType();
}
FFastReportType.GetMethod("LoadFromString", new Type[] { FSelectedTemplate.XmlText.GetType() }).Invoke(FfastReportInstance,
new object[] { FSelectedTemplate.XmlText });
LoadReportParams(ACalc);
FFastReportType.GetMethod("Prepare", new Type[0]).Invoke(FfastReportInstance, null);
FFastReportType.GetMethod("Export", new Type[] { ExporterType, HtmlStream.GetType() }).Invoke(FfastReportInstance,
new Object[] { exporter, HtmlStream });
return(HtmlStream);
}
/// <summary>
/// Export a .repx report with a datasource to an exported file type
/// </summary>
/// <param name="reportRepxFilePath"></param>
/// <param name="dataSource"></param>
/// <param name="reportExportType"></param>
/// <param name="targetDirectory"></param>
/// <param name="fileName"></param>
public static void ExportReport(string reportRepxFilePath, object dataSource,
ReportExportType reportExportType, string targetDirectory, string fileName /*No Extension*/)
{
var report = CreateXtraReportFromRepxWithDataSource(reportRepxFilePath, dataSource);
var targetFilePath = string.Empty;
Directory.CreateDirectory(targetDirectory);
switch (reportExportType)
{
case ReportExportType.CSV:
targetFilePath = Path.Combine(targetDirectory, fileName + ".csv");
report.ExportToCsv(targetFilePath);
break;
case ReportExportType.DOCX:
targetFilePath = Path.Combine(targetDirectory, fileName + ".docx");
report.ExportToDocx(targetFilePath);
break;
case ReportExportType.HTML:
targetFilePath = Path.Combine(targetDirectory, fileName + ".html");
report.ExportToHtml(targetFilePath);
break;
case ReportExportType.JPEG:
targetFilePath = Path.Combine(targetDirectory, fileName + ".jpg");
report.ExportToImage(targetFilePath);
break;
case ReportExportType.PDF:
targetFilePath = Path.Combine(targetDirectory, fileName + ".pdf");
report.ExportToPdf(targetFilePath);
break;
case ReportExportType.PNG:
targetFilePath = Path.Combine(targetDirectory, fileName + ".png");
report.ExportToImage(targetFilePath);
break;
case ReportExportType.RTF:
targetFilePath = Path.Combine(targetDirectory, fileName + ".rtf");
report.ExportToRtf(targetFilePath);
break;
case ReportExportType.Text:
targetFilePath = Path.Combine(targetDirectory, fileName + ".txt");
report.ExportToText(targetFilePath);
break;
case ReportExportType.XLSX:
targetFilePath = Path.Combine(targetDirectory, fileName + ".xlsx");
report.ExportToXlsx(targetFilePath);
break;
}
if (!File.Exists(targetFilePath))
{
throw new FileNotFoundException("Failed to export report");
}
}
/// <summary>
/// The report will be generated, but not shown to the user.
/// </summary>
/// <param name="ACalc"></param>
/// <param name="Format"></param>
public MemoryStream ExportToStream(TRptCalculator ACalc, ReportExportType Format)
{
object HtmlExport = FastReportsDll.CreateInstance("FastReport.Export.Html.HTMLExport");
Type ExporterType = HtmlExport.GetType();
MemoryStream HtmlStream = new MemoryStream();
FFastReportType.GetMethod("LoadFromString", new Type[] { FSelectedTemplate.XmlText.GetType() }).Invoke(FfastReportInstance,
new object[] { FSelectedTemplate.XmlText });
LoadReportParams(ACalc);
FFastReportType.GetMethod("Prepare", new Type[0]).Invoke(FfastReportInstance, null);
FFastReportType.GetMethod("Export", new Type[] { ExporterType, HtmlStream.GetType() }).Invoke(FfastReportInstance,
new Object[] { HtmlExport, HtmlStream });
return(HtmlStream);
}
/// <summary>
/// The report will be generated, but not shown to the user.
/// </summary>
/// <param name="ACalc"></param>
/// <param name="Format"></param>
public MemoryStream ExportToStream(TRptCalculator ACalc, ReportExportType Format)
{
object HtmlExport = FastReportsDll.CreateInstance("FastReport.Export.Html.HTMLExport");
Type ExporterType = HtmlExport.GetType();
MemoryStream HtmlStream = new MemoryStream();
FFastReportType.GetMethod("LoadFromString", new Type[] { FSelectedTemplate.XmlText.GetType() }).Invoke(FfastReportInstance,
new object[] { FSelectedTemplate.XmlText });
LoadReportParams(ACalc);
FFastReportType.GetMethod("Prepare", new Type[0]).Invoke(FfastReportInstance, null);
FFastReportType.GetMethod("Export", new Type[] { ExporterType, HtmlStream.GetType() }).Invoke(FfastReportInstance,
new Object[] { HtmlExport, HtmlStream });
return HtmlStream;
}
public byte[] RenderReport(IReport report, string reportKey, string designId, ReportExportType exportType)
{
if (reportKey.IsEmptyOrNull())
{
throw new ArgumentNullException("reportKey");
}
if (designId.IsEmptyOrNull())
{
throw new ArgumentNullException("designId");
}
var dataSources = GetDataSources(report);
if (report is IDataOnlyReport)
{
if (exportType != ReportExportType.Xlsx)
{
throw new ArgumentOutOfRangeException("exportType");
}
return(RenderDataOnlyReport((IDataOnlyReport)report, dataSources));
}
string extension;
using (var stream = new ReportRepository().OpenReportDesign(reportKey, designId, out extension))
{
/*
* if ((extension ?? "").ToLowerInvariant() == ".trdx")
* {
* var trpReport = TelerikReportLoad(stream);
* TelerikReportReplaceDataSources(trpReport, dataSources);
*
* var trpSource = new Telerik.Reporting.InstanceReportSource { ReportDocument = trpReport };
* var trpProcessor = new Telerik.Reporting.Processing.ReportProcessor();
*
* var trpResult = trpProcessor.RenderReport(ExportFormats[exportType], trpSource, null);
*
* return trpResult.DocumentBytes;
* }
* else
*/
{
//LocalReport ssrs = new LocalReport();
//ssrs.LoadReportDefinition(stream);
//ssrs.DataSources.Clear();
//foreach (var pair in dataSources)
// ssrs.DataSources.Add(new ReportDataSource(pair.Key, pair.Value));
//return ssrs.Render(ExportFormats[exportType]);
throw new NotImplementedException();
}
}
}
public async Task <ActionResult <ReportResult> > GetReportDownload(
[FromQuery] string maxOfficialRating,
[FromQuery] bool?hasThemeSong,
[FromQuery] bool?hasThemeVideo,
[FromQuery] bool?hasSubtitles,
[FromQuery] bool?hasSpecialFeature,
[FromQuery] bool?hasTrailer,
[FromQuery] string?adjacentTo,
[FromQuery] int?minIndexNumber,
[FromQuery] int?parentIndexNumber,
[FromQuery] bool?hasParentalRating,
[FromQuery] bool?isHd,
[FromQuery] string?locationTypes,
[FromQuery] string?excludeLocationTypes,
[FromQuery] bool?isMissing,
[FromQuery] bool?isUnaried,
[FromQuery] double?minCommunityRating,
[FromQuery] double?minCriticRating,
[FromQuery] int?airedDuringSeason,
[FromQuery] string?minPremiereDate,
[FromQuery] string?minDateLastSaved,
[FromQuery] string?minDateLastSavedForUser,
[FromQuery] string?maxPremiereDate,
[FromQuery] bool?hasOverview,
[FromQuery] bool?hasImdbId,
[FromQuery] bool?hasTmdbId,
[FromQuery] bool?hasTvdbId,
[FromQuery] bool?isInBoxSet,
[FromQuery] string?excludeItemIds,
[FromQuery] bool?enableTotalRecordCount,
[FromQuery] int?startIndex,
[FromQuery] int?limit,
[FromQuery] bool?recursive,
[FromQuery] string?sortOrder,
[FromQuery] string?parentId,
[FromQuery] string?fields,
[FromQuery] string?excludeItemTypes,
[FromQuery] string?includeItemTypes,
[FromQuery] string?filters,
[FromQuery] bool?isFavorite,
[FromQuery] bool?isNotFavorite,
[FromQuery] string?mediaTypes,
[FromQuery] string?imageTypes,
[FromQuery] string?sortBy,
[FromQuery] bool?isPlayed,
[FromQuery] string?genres,
[FromQuery] string?genreIds,
[FromQuery] string?officialRatings,
[FromQuery] string?tags,
[FromQuery] string?years,
[FromQuery] bool?enableUserData,
[FromQuery] int?imageTypeLimit,
[FromQuery] string?enableImageTypes,
[FromQuery] string?person,
[FromQuery] string?personIds,
[FromQuery] string?personTypes,
[FromQuery] string?studios,
[FromQuery] string?studioIds,
[FromQuery] string?artists,
[FromQuery] string?excludeArtistIds,
[FromQuery] string?artistIds,
[FromQuery] string?albums,
[FromQuery] string?albumIds,
[FromQuery] string?ids,
[FromQuery] string?videoTypes,
[FromQuery] string?userId,
[FromQuery] string?minOfficialRating,
[FromQuery] bool?isLocked,
[FromQuery] bool?isPlaceHolder,
[FromQuery] bool?hasOfficialRating,
[FromQuery] bool?collapseBoxSetItems,
[FromQuery] bool?is3D,
[FromQuery] string?seriesStatus,
[FromQuery] string?nameStartsWithOrGreater,
[FromQuery] string?nameStartsWith,
[FromQuery] string?nameLessThan,
[FromQuery] string?reportView,
[FromQuery] string?displayType,
[FromQuery] bool?hasQueryLimit,
[FromQuery] string?groupBy,
[FromQuery] string?reportColumns,
[FromQuery] string?minDate,
[FromQuery] ReportExportType exportType = ReportExportType.CSV,
[FromQuery] bool enableImages = true)
{
var request = new GetReportDownload
{
Albums = albums,
AdjacentTo = adjacentTo,
AiredDuringSeason = airedDuringSeason,
AlbumIds = albumIds,
ArtistIds = artistIds,
Artists = artists,
CollapseBoxSetItems = collapseBoxSetItems,
DisplayType = displayType,
EnableImages = enableImages,
EnableImageTypes = enableImageTypes,
Fields = fields,
Filters = filters,
Genres = genres,
Ids = ids,
Limit = limit,
Person = person,
Recursive = recursive ?? true,
Studios = studios,
Tags = tags,
Years = years,
GenreIds = genreIds,
GroupBy = groupBy,
HasOverview = hasOverview,
HasSubtitles = hasSubtitles,
HasTrailer = hasTrailer,
ImageTypes = imageTypes,
Is3D = is3D,
IsFavorite = isFavorite ?? false,
IsLocked = isLocked,
IsMissing = isMissing,
IsPlayed = isPlayed,
IsUnaired = isUnaried,
LocationTypes = locationTypes,
MediaTypes = mediaTypes,
OfficialRatings = officialRatings,
ParentId = parentId,
PersonIds = personIds,
PersonTypes = personTypes,
ReportColumns = reportColumns,
ReportView = reportView,
SeriesStatus = seriesStatus,
SortBy = sortBy,
SortOrder = sortOrder,
StartIndex = startIndex,
StudioIds = studioIds,
UserId = userId,
VideoTypes = videoTypes,
EnableUserData = enableUserData,
ExcludeArtistIds = excludeArtistIds,
ExcludeItemIds = excludeItemIds,
ExcludeItemTypes = excludeItemTypes,
ExcludeLocationTypes = excludeLocationTypes,
HasImdbId = hasImdbId,
HasOfficialRating = hasOfficialRating,
HasParentalRating = hasParentalRating,
HasQueryLimit = hasQueryLimit ?? false,
HasSpecialFeature = hasSpecialFeature,
HasThemeSong = hasThemeSong,
HasThemeVideo = hasThemeVideo,
HasTmdbId = hasTmdbId,
HasTvdbId = hasTvdbId,
ImageTypeLimit = imageTypeLimit,
IncludeItemTypes = includeItemTypes,
IsHD = isHd,
IsNotFavorite = isNotFavorite ?? false,
IsPlaceHolder = isPlaceHolder,
MaxOfficialRating = maxOfficialRating,
MaxPremiereDate = maxPremiereDate,
MinCommunityRating = minCommunityRating,
MinCriticRating = minCriticRating,
MinIndexNumber = minIndexNumber,
MinOfficialRating = minOfficialRating,
MinPremiereDate = minPremiereDate,
NameLessThan = nameLessThan,
NameStartsWith = nameStartsWith,
ParentIndexNumber = parentIndexNumber,
EnableTotalRecordCount = enableTotalRecordCount ?? true,
IsInBoxSet = isInBoxSet,
MinDateLastSaved = minDateLastSaved,
NameStartsWithOrGreater = nameStartsWithOrGreater,
MinDateLastSavedForUser = minDateLastSavedForUser,
ExportType = exportType,
MinDate = minDate
};
var(content, contentType, headers) = await _reportsService.Get(request).ConfigureAwait(false);
foreach (var(key, value) in headers)
{
Response.Headers.Add(key, value);
}
return(Content(content, contentType));
}
