/// <summary>
/// Generates a report using a report definition
/// </summary>
/// <param name="definition">The report definition</param>
/// <param name="filter">The filter (optional)</param>
/// <param name="options">The generation options (optional)</param>
/// <returns>The generated result</returns>
public ReportGenerationResult Generate
(
ReportDefinition definition,
ReportFilter filter = null,
ReportGenerationOptions options = null
)
{
var task = GenerateAsync(definition, filter, options);
return(task.WaitAndUnwrapException());
}
private void btnReportGeneratorPreview_ItemClick(object sender, DevExpress.XtraBars.ItemClickEventArgs e)
{
ReportGenerationOptions options = new ReportGenerationOptions()
{
PrintVerticalLines = DevExpress.Utils.DefaultBoolean.True,
PrintHorizontalLines = DevExpress.Utils.DefaultBoolean.True
};
XtraReport report = ReportGenerator.GenerateReport(gridView, options);
ReportPrintTool printTool = new ReportPrintTool(report);
printTool.ShowPreviewDialog(this.GetActiveLookAndFeel());
}
/// <summary>
/// Asynchronously generates a report using a report definition
/// </summary>
/// <param name="definition">The report definition</param>
/// <param name="filter">The filter (optional)</param>
/// <param name="options">The generation options (optional)</param>
/// <returns>The generation result</returns>
public async Task <ReportGenerationResult> GenerateAsync
(
ReportDefinition definition,
ReportFilter filter = null,
ReportGenerationOptions options = null
)
{
Validate.IsNotNull(definition);
var watch = Stopwatch.StartNew();
if (filter == null)
{
filter = _filterGenerator.Generate
(
definition
);
}
if (options == null)
{
options = new ReportGenerationOptions();
}
else if (options.Culture != null)
{
definition.Culture = options.Culture;
}
var pageHeaderTask = GenerateSectionAsync
(
definition,
filter,
ReportSectionType.PageHeader
);
var reportHeaderTask = GenerateSectionAsync
(
definition,
filter,
ReportSectionType.ReportHeader
);
var reportBodyTask = GenerateSectionAsync
(
definition,
filter,
ReportSectionType.ReportBody
);
var pageFooterTask = GenerateSectionAsync
(
definition,
filter,
ReportSectionType.PageFooter
);
var reportFooterTask = GenerateSectionAsync
(
definition,
filter,
ReportSectionType.ReportFooter
);
await Task.WhenAll
(
pageHeaderTask,
reportHeaderTask,
reportBodyTask,
reportFooterTask,
pageFooterTask
)
.ConfigureAwait
(
false
);
var pageHeaderResult = await pageHeaderTask.ConfigureAwait
(
false
);
var reportHeaderResult = await reportHeaderTask.ConfigureAwait
(
false
);
var reportBodyResult = await reportBodyTask.ConfigureAwait
(
false
);
var pageFooterResult = await pageFooterTask.ConfigureAwait
(
false
);
var reportFooterResult = await reportFooterTask.ConfigureAwait
(
false
);
var report = new Report(definition, filter);
if (pageHeaderResult != null)
{
report = report.WithPageHeader
(
pageHeaderResult.Section
);
}
if (reportHeaderResult != null)
{
report = report.WithReportHeader
(
reportHeaderResult.Section
);
}
if (reportBodyResult != null)
{
report = report.WithBody
(
reportBodyResult.Section
);
}
if (reportFooterResult != null)
{
report = report.WithReportFooter
(
reportFooterResult.Section
);
}
if (pageFooterResult != null)
{
report = report.WithPageFooter
(
pageFooterResult.Section
);
}
var sectionResults = new ReportSectionGenerationResult[]
{
pageHeaderResult,
reportHeaderResult,
reportBodyResult,
reportFooterResult,
pageFooterResult
};
var errorMessages = CompileErrorMessages
(
sectionResults
);
var handledExceptions = CompileHandledExceptions
(
sectionResults
);
if (options.PreferredLanguage != null)
{
report.Translate
(
_translator,
options.PreferredLanguage
);
}
watch.Stop();
var result = new ReportGenerationResult
(
report,
watch.ElapsedMilliseconds,
errorMessages
);
if (handledExceptions.Any())
{
result.AddExceptions(handledExceptions);
}
return(result);
}
/// <summary>
/// Asynchronously generates a report from a registered report and filter values
/// </summary>
/// <param name="reportName">The report name</param>
/// <param name="filterValues">The filter values</param>
/// <param name="userInfo">The user information</param>
/// <returns>The generation result</returns>
public async Task <ReportGenerationResult> GenerateAsync
(
string reportName,
SubmittedReportFilterValues filterValues,
ReportUserInfo userInfo
)
{
Validate.IsNotEmpty(reportName);
Validate.IsNotNull(filterValues);
Validate.IsNotNull(userInfo);
var watch = Stopwatch.StartNew();
var hasAccess = CanUserAccessReport
(
reportName,
userInfo
);
if (false == hasAccess)
{
watch.Stop();
return(new ReportGenerationResult
(
null,
watch.ElapsedMilliseconds,
"The user is not authorized to generate the report."
));
}
var registeredReport = _reportRepository.GetReport
(
reportName
);
if (registeredReport.Disabled)
{
watch.Stop();
return(new ReportGenerationResult
(
null,
watch.ElapsedMilliseconds,
"The report cannot be generated because it is disabled."
));
}
var reportDefinition = _definitionBuilder.Build
(
registeredReport,
_queryRepository
);
var reportFilter = BuildReportFilter
(
registeredReport,
reportDefinition,
filterValues,
userInfo
);
var options = new ReportGenerationOptions()
{
Culture = userInfo.Culture,
PreferredLanguage = userInfo.PreferredLanguage
};
var task = _reportGenerator.GenerateAsync
(
reportDefinition,
reportFilter,
options
);
var result = await task.ConfigureAwait
(
false
);
return(result);
}
