/// <summary>
/// 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 generated result</returns>
public ReportGenerationResult Generate
(
string reportName,
SubmittedReportFilterValues filterValues,
ReportUserInfo userInfo
)
{
var task = GenerateAsync
(
reportName,
filterValues,
userInfo
);
return(task.WaitAndUnwrapException());
}
/// <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);
}
/// <summary>
/// Builds a report filter from the filter values specified
/// </summary>
/// <param name="registeredReport">The registered report</param>
/// <param name="reportDefinition">The report definition</param>
/// <param name="filterValues">The filter values</param>
/// <param name="userInfo">The user information</param>
/// <returns>The report filter</returns>
private ReportFilter BuildReportFilter
(
RegisteredReport registeredReport,
ReportDefinition reportDefinition,
SubmittedReportFilterValues filterValues,
ReportUserInfo userInfo
)
{
var submittedParameterValues = filterValues.ParameterValues;
var convertedParameterValues = new Dictionary <string, object>();
var filter = new ReportFilter
(
reportDefinition.Parameters.ToArray()
);
// Process the parameter values submitted and convert them to their expected types
if (submittedParameterValues != null && submittedParameterValues.Any())
{
var groupedValues = new Dictionary <string, List <object> >();
foreach (var submittedValue in submittedParameterValues)
{
var parameterName = submittedValue.ParameterName;
if (String.IsNullOrEmpty(parameterName))
{
throw new InvalidOperationException
(
"The submitted parameter name cannot be null."
);
}
var convertedValue = ConvertParameterValue
(
filter,
submittedValue
);
if (groupedValues.ContainsKey(parameterName))
{
groupedValues[parameterName].Add
(
convertedValue
);
}
else
{
groupedValues.Add
(
parameterName,
new List <object> {
convertedValue
}
);
}
}
// Flatten the grouped values into individual parameter values
foreach (var pair in groupedValues)
{
if (pair.Value.Count > 1)
{
convertedParameterValues.Add
(
pair.Key,
pair.Value.ToArray()
);
}
else
{
convertedParameterValues.Add
(
pair.Key,
pair.Value.First()
);
}
}
}
// Add any missing parameter values by using the definition defaults
foreach (var definition in filter.ParameterDefinitions)
{
var parameter = definition.Parameter;
var matchFound = convertedParameterValues.Any
(
pair => pair.Key.Equals
(
parameter.Name,
StringComparison.InvariantCultureIgnoreCase
)
);
if (false == matchFound)
{
convertedParameterValues.Add
(
parameter.Name,
parameter.DefaultValue
);
}
}
var constrainedParameters = CompileParameterConstraints
(
registeredReport,
userInfo
);
filter.SetParameterValues
(
convertedParameterValues,
constrainedParameters
);
if (filterValues.SortingRules != null)
{
foreach (var submittedRule in filterValues.SortingRules)
{
filter.SetSortingRule
(
submittedRule.SectionType,
submittedRule.ComponentName,
submittedRule.ColumnName,
submittedRule.Direction
);
}
}
return(filter);
}
