/// <summary>
/// Shows the preview.
/// </summary>
/// <param name="entityTypeId">The entity type id.</param>
/// <param name="filter">The filter.</param>
private void BindGrid( Report report )
{
if ( report != null )
{
var errors = new List<string>();
if ( !report.EntityTypeId.HasValue )
{
return;
}
string authorizationMessage;
if ( !this.IsAuthorizedForAllReportComponents( Authorization.VIEW, report, out authorizationMessage ) )
{
nbEditModeMessage.Text = authorizationMessage;
return;
}
Type entityType = EntityTypeCache.Read( report.EntityTypeId.Value ).GetEntityType();
bool isPersonDataSet = report.EntityTypeId == EntityTypeCache.Read( typeof( Rock.Model.Person ) ).Id;
if ( isPersonDataSet )
{
gReport.PersonIdField = "Id";
gReport.DataKeyNames = new string[] { "id" };
}
else
{
gReport.PersonIdField = null;
}
if ( report.EntityTypeId.HasValue )
{
gReport.RowItemText = EntityTypeCache.Read( report.EntityTypeId.Value ).FriendlyName;
}
List<EntityField> entityFields = Rock.Reporting.EntityHelper.GetEntityFields( entityType );
var selectedEntityFields = new Dictionary<int, EntityField>();
var selectedAttributes = new Dictionary<int, AttributeCache>();
var selectedComponents = new Dictionary<int, ReportField>();
gReport.Columns.Clear();
int columnIndex = 0;
if ( !string.IsNullOrWhiteSpace( gReport.PersonIdField ) )
{
gReport.Columns.Add( new SelectField() );
columnIndex++;
}
foreach ( var reportField in report.ReportFields.OrderBy( a => a.Order ) )
{
columnIndex++;
if ( reportField.ReportFieldType == ReportFieldType.Property )
{
var entityField = entityFields.FirstOrDefault( a => a.Name == reportField.Selection );
if ( entityField != null )
{
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField;
if ( entityField.DefinedTypeGuid.HasValue )
{
boundField = new DefinedValueField();
}
else
{
boundField = Grid.GetGridField( entityField.PropertyType );
}
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? entityField.Title : reportField.ColumnHeaderText;
boundField.SortExpression = entityField.Name;
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( boundField );
}
}
else if ( reportField.ReportFieldType == ReportFieldType.Attribute )
{
Guid? attributeGuid = reportField.Selection.AsGuidOrNull();
if ( attributeGuid.HasValue )
{
var attribute = AttributeCache.Read( attributeGuid.Value );
selectedAttributes.Add( columnIndex, attribute );
BoundField boundField;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.BOOLEAN.AsGuid() ) )
{
boundField = new BoolField();
}
else
{
boundField = new BoundField();
}
boundField.DataField = string.Format( "Attribute_{0}_{1}", attribute.Id, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? attribute.Name : reportField.ColumnHeaderText;
boundField.SortExpression = null;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.INTEGER.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) )
{
boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
boundField.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
}
boundField.Visible = reportField.ShowInGrid;
// NOTE: Additional formatting for attributes is done in the gReport_RowDataBound event
gReport.Columns.Add( boundField );
}
}
else if ( reportField.ReportFieldType == ReportFieldType.DataSelectComponent )
{
selectedComponents.Add( columnIndex, reportField );
DataSelectComponent selectComponent = DataSelectContainer.GetComponent( reportField.DataSelectComponentEntityType.Name );
if ( selectComponent != null )
{
DataControlField columnField = selectComponent.GetGridField( entityType, reportField.Selection );
if ( columnField is BoundField )
{
( columnField as BoundField ).DataField = string.Format( "Data_{0}_{1}", selectComponent.ColumnPropertyName, columnIndex );
}
columnField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? selectComponent.ColumnHeaderText : reportField.ColumnHeaderText;
columnField.SortExpression = null;
columnField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( columnField );
}
}
}
// if no fields are specified, show the default fields (Previewable/All) for the EntityType
var dataColumns = gReport.Columns.OfType<object>().Where(a => a.GetType() != typeof(SelectField));
if (dataColumns.Count() == 0)
{
// show either the Previewable Columns or all (if there are no previewable columns)
bool showAllColumns = !entityFields.Any( a => a.FieldKind == FieldKind.Property && a.IsPreviewable );
foreach ( var entityField in entityFields.Where(a => a.FieldKind == FieldKind.Property) )
{
columnIndex++;
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField;
if ( entityField.DefinedTypeGuid.HasValue )
{
boundField = new DefinedValueField();
}
else
{
boundField = Grid.GetGridField( entityField.PropertyType );
}
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = entityField.Name;
boundField.SortExpression = entityField.Name;
boundField.Visible = showAllColumns || entityField.IsPreviewable;
gReport.Columns.Add( boundField );
}
}
try
{
gReport.ExportFilename = report.Name;
gReport.DataSource = report.GetDataSource( new RockContext(), entityType, selectedEntityFields, selectedAttributes, selectedComponents, gReport.SortProperty, out errors );
gReport.DataBind();
}
catch ( Exception ex )
{
errors.Add( ex.Message );
}
if ( errors.Any() )
{
nbEditModeMessage.Text = "INFO: There was a problem with one or more of the report's data components...<br/><br/> " + errors.AsDelimited( "<br/>" );
}
}
}
/// <summary>
/// Shows the preview.
/// </summary>
/// <param name="entityTypeId">The entity type id.</param>
/// <param name="filter">The filter.</param>
private void BindGrid( Report report )
{
if ( report != null )
{
var errors = new List<string>();
if ( !report.EntityTypeId.HasValue )
{
gReport.Visible = false;
return;
}
var rockContext = new RockContext();
if ( !report.IsAuthorized( Authorization.VIEW, this.CurrentPerson ) )
{
gReport.Visible = false;
return;
}
Type entityType = EntityTypeCache.Read( report.EntityTypeId.Value, rockContext ).GetEntityType();
bool isPersonDataSet = report.EntityTypeId == EntityTypeCache.Read( typeof( Rock.Model.Person ), true, rockContext ).Id;
if ( isPersonDataSet )
{
gReport.PersonIdField = "Id";
gReport.DataKeyNames = new string[] { "Id" };
}
else
{
gReport.PersonIdField = null;
}
if ( report.EntityTypeId.HasValue )
{
gReport.RowItemText = EntityTypeCache.Read( report.EntityTypeId.Value, rockContext ).FriendlyName;
}
List<EntityField> entityFields = Rock.Reporting.EntityHelper.GetEntityFields( entityType );
var selectedEntityFields = new Dictionary<int, EntityField>();
var selectedAttributes = new Dictionary<int, AttributeCache>();
var selectedComponents = new Dictionary<int, ReportField>();
// if there is a selectField, keep it to preserve which items are checked
var selectField = gReport.Columns.OfType<SelectField>().FirstOrDefault();
gReport.Columns.Clear();
int columnIndex = 0;
if ( !string.IsNullOrWhiteSpace( gReport.PersonIdField ) )
{
// if we already had a selectField, use it (to preserve checkbox state)
gReport.Columns.Add( selectField ?? new SelectField() );
columnIndex++;
}
var reportFieldSortExpressions = new Dictionary<Guid, string>();
foreach ( var reportField in report.ReportFields.OrderBy( a => a.ColumnOrder ) )
{
columnIndex++;
if ( reportField.ReportFieldType == ReportFieldType.Property )
{
var entityField = entityFields.FirstOrDefault( a => a.Name == reportField.Selection );
if ( entityField != null )
{
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField;
if ( entityField.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DEFINED_VALUE.AsGuid() ) )
{
boundField = new DefinedValueField();
}
else
{
boundField = Grid.GetGridField( entityField.PropertyType );
}
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? entityField.Title : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace( reportField.Guid, boundField.SortExpression );
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( boundField );
}
}
else if ( reportField.ReportFieldType == ReportFieldType.Attribute )
{
Guid? attributeGuid = reportField.Selection.AsGuidOrNull();
if ( attributeGuid.HasValue )
{
var attribute = AttributeCache.Read( attributeGuid.Value, rockContext );
if ( attribute != null )
{
selectedAttributes.Add( columnIndex, attribute );
BoundField boundField;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.BOOLEAN.AsGuid() ) )
{
boundField = new BoolField();
}
else
{
boundField = new BoundField();
}
boundField.DataField = string.Format( "Attribute_{0}_{1}", attribute.Id, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? attribute.Name : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace( reportField.Guid, boundField.SortExpression );
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.INTEGER.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.FILTER_DATE.AsGuid() ) )
{
boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
boundField.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
}
boundField.Visible = reportField.ShowInGrid;
// NOTE: Additional formatting for attributes is done in the gReport_RowDataBound event
gReport.Columns.Add( boundField );
}
}
}
else if ( reportField.ReportFieldType == ReportFieldType.DataSelectComponent )
{
selectedComponents.Add( columnIndex, reportField );
DataSelectComponent selectComponent = DataSelectContainer.GetComponent( reportField.DataSelectComponentEntityType.Name );
if ( selectComponent != null )
{
DataControlField columnField = selectComponent.GetGridField( entityType, reportField.Selection );
if ( columnField is BoundField )
{
( columnField as BoundField ).DataField = string.Format( "Data_{0}_{1}", selectComponent.ColumnPropertyName, columnIndex );
columnField.SortExpression = ( columnField as BoundField ).DataField;
}
columnField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? selectComponent.ColumnHeaderText : reportField.ColumnHeaderText;
if ( columnField.SortExpression != null )
{
reportFieldSortExpressions.AddOrReplace( reportField.Guid, columnField.SortExpression );
}
columnField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( columnField );
}
}
}
// if no fields are specified, show the default fields (Previewable/All) for the EntityType
var dataColumns = gReport.Columns.OfType<object>().Where( a => a.GetType() != typeof( SelectField ) );
if ( dataColumns.Count() == 0 )
{
// show either the Previewable Columns or all (if there are no previewable columns)
bool showAllColumns = !entityFields.Any( a => a.FieldKind == FieldKind.Property && a.IsPreviewable );
foreach ( var entityField in entityFields.Where( a => a.FieldKind == FieldKind.Property ) )
{
columnIndex++;
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField;
if ( entityField.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DEFINED_VALUE.AsGuid() ) )
{
boundField = new DefinedValueField();
}
else
{
boundField = Grid.GetGridField( entityField.PropertyType );
}
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = entityField.Name;
boundField.SortExpression = boundField.DataField;
boundField.Visible = showAllColumns || entityField.IsPreviewable;
gReport.Columns.Add( boundField );
}
}
try
{
gReport.Visible = true;
gReport.ExportFilename = report.Name;
SortProperty sortProperty = gReport.SortProperty;
if ( sortProperty == null )
{
var reportSort = new SortProperty();
var sortColumns = new Dictionary<string, SortDirection>();
foreach ( var reportField in report.ReportFields.Where( a => a.SortOrder.HasValue ).OrderBy( a => a.SortOrder.Value ) )
{
if ( reportFieldSortExpressions.ContainsKey( reportField.Guid ) )
{
var sortField = reportFieldSortExpressions[reportField.Guid];
if ( !string.IsNullOrWhiteSpace( sortField ) )
{
sortColumns.Add( sortField, reportField.SortDirection );
}
}
}
if ( sortColumns.Any() )
{
reportSort.Property = sortColumns.Select( a => a.Key + ( a.Value == SortDirection.Descending ? " desc" : string.Empty ) ).ToList().AsDelimited( "," );
sortProperty = reportSort;
}
}
gReport.DataSource = report.GetDataSource( entityType, selectedEntityFields, selectedAttributes, selectedComponents, sortProperty, GetAttributeValue( "DatabaseTimeout" ).AsIntegerOrNull() ?? 180, out errors );
gReport.DataBind();
}
catch ( Exception ex )
{
Exception exception = ex;
this.LogException( ex );
while ( exception != null )
{
if ( exception is System.Data.SqlClient.SqlException )
{
// if there was a SQL Server Timeout, have the warning be a friendly message about that.
if ( ( exception as System.Data.SqlClient.SqlException ).Number == -2 )
{
nbEditModeMessage.NotificationBoxType = NotificationBoxType.Warning;
nbEditModeMessage.Text = "This report did not complete in a timely manner. You can try again or adjust the timeout setting of this block.";
return;
}
else
{
errors.Add( exception.Message );
exception = exception.InnerException;
}
}
else
{
errors.Add( exception.Message );
exception = exception.InnerException;
}
}
}
if ( errors.Any() )
{
nbEditModeMessage.NotificationBoxType = NotificationBoxType.Warning;
nbEditModeMessage.Text = "INFO: There was a problem with one or more of the report's data components...<br/><br/> " + errors.AsDelimited( "<br/>" );
}
}
}
/// <summary>
/// Shows the preview.
/// </summary>
/// <param name="entityTypeId">The entity type id.</param>
/// <param name="filter">The filter.</param>
private void BindGrid( Report report )
{
if ( report != null && report.DataView != null )
{
var errors = new List<string>();
if ( !report.EntityTypeId.HasValue )
{
return;
}
Type entityType = EntityTypeCache.Read( report.EntityTypeId.Value ).GetEntityType();
List<EntityField> entityFields = Rock.Reporting.EntityHelper.GetEntityFields( entityType );
var selectedEntityFields = new Dictionary<int,EntityField>();
var selectedAttributes = new Dictionary<int, AttributeCache>();
var selectedComponents = new Dictionary<int, ReportField>();
gReport.Columns.Clear();
int columnIndex = 0;
foreach ( var reportField in report.ReportFields.OrderBy( a => a.Order ) )
{
columnIndex++;
if ( reportField.ReportFieldType == ReportFieldType.Property )
{
var entityField = entityFields.FirstOrDefault( a => a.Name == reportField.Selection );
if ( entityField != null )
{
selectedEntityFields.Add( columnIndex, entityField );
if ( reportField.ShowInGrid )
{
BoundField boundField;
if ( entityField.DefinedTypeId.HasValue )
{
boundField = new DefinedValueField();
}
else
{
boundField = Grid.GetGridField( entityField.PropertyType );
}
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? entityField.Title : reportField.ColumnHeaderText;
boundField.SortExpression = entityField.Name;
gReport.Columns.Add( boundField );
}
}
}
else if ( reportField.ReportFieldType == ReportFieldType.Attribute )
{
int? attributeId = reportField.Selection.AsInteger( false );
if ( attributeId.HasValue )
{
var attribute = AttributeCache.Read( attributeId.Value );
selectedAttributes.Add( columnIndex, attribute );
if ( reportField.ShowInGrid )
{
BoundField boundField;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.BOOLEAN.AsGuid() ) )
{
boundField = new BoolField();
}
else
{
boundField = new BoundField();
}
boundField.DataField = string.Format( "Attribute_{0}_{1}", attribute.Id, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? attribute.Name : reportField.ColumnHeaderText;
boundField.SortExpression = null;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.INTEGER.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) )
{
boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
boundField.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
}
// NOTE: Additional formatting for attributes is done in the gReport_RowDataBound event
gReport.Columns.Add( boundField );
}
}
}
else if ( reportField.ReportFieldType == ReportFieldType.DataSelectComponent )
{
selectedComponents.Add( columnIndex, reportField );
if ( reportField.ShowInGrid )
{
DataSelectComponent selectComponent = DataSelectContainer.GetComponent( reportField.DataSelectComponentEntityType.Name );
if ( selectComponent != null )
{
var boundField = Grid.GetGridField( selectComponent.ColumnFieldType );
boundField.DataField = string.Format( "Data_{0}_{1}", selectComponent.ColumnPropertyName, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? selectComponent.ColumnHeaderText : reportField.ColumnHeaderText;
boundField.SortExpression = null;
gReport.Columns.Add( boundField );
}
}
}
}
gReport.DataSource = report.GetDataSource( new RockContext(), entityType, selectedEntityFields, selectedAttributes, selectedComponents, gReport.SortProperty, out errors );
if ( errors.Any() )
{
nbEditModeMessage.Text = "INFO: There was a problem with one or more of the report's data components...<br/><br/> " + errors.AsDelimited( "<br/>" );
}
gReport.DataBind();
}
}
/// <summary>
/// Shows the preview.
/// </summary>
/// <param name="report">The report.</param>
/// <param name="gReport">The g report.</param>
/// <param name="currentPerson">The current person.</param>
/// <param name="databaseTimeoutSeconds">The database timeout seconds.</param>
/// <param name="errorMessage">The error message.</param>
public static void BindGrid( Report report, Grid gReport, Person currentPerson, int? databaseTimeoutSeconds, out string errorMessage )
{
errorMessage = null;
if ( report != null )
{
var errors = new List<string>();
if ( !report.EntityTypeId.HasValue )
{
gReport.Visible = false;
return;
}
var rockContext = new RockContext();
if ( !report.IsAuthorized( Authorization.VIEW, currentPerson ) )
{
gReport.Visible = false;
return;
}
Type entityType = EntityTypeCache.Read( report.EntityTypeId.Value, rockContext ).GetEntityType();
if ( entityType == null )
{
errorMessage = string.Format( "Unable to determine entityType for {0}", report.EntityType );
return;
}
gReport.EntityTypeId = report.EntityTypeId;
bool isPersonDataSet = report.EntityTypeId == EntityTypeCache.Read( typeof( Rock.Model.Person ), true, rockContext ).Id;
if ( isPersonDataSet )
{
gReport.PersonIdField = "Id";
gReport.DataKeyNames = new string[] { "Id" };
}
else
{
gReport.PersonIdField = null;
}
if ( report.EntityTypeId.HasValue )
{
gReport.RowItemText = EntityTypeCache.Read( report.EntityTypeId.Value, rockContext ).FriendlyName;
}
List<EntityField> entityFields = Rock.Reporting.EntityHelper.GetEntityFields( entityType, true, false );
var selectedEntityFields = new Dictionary<int, EntityField>();
var selectedAttributes = new Dictionary<int, AttributeCache>();
var selectedComponents = new Dictionary<int, ReportField>();
// if there is a selectField, keep it to preserve which items are checked
var selectField = gReport.Columns.OfType<SelectField>().FirstOrDefault();
gReport.Columns.Clear();
int columnIndex = 0;
if ( !string.IsNullOrWhiteSpace( gReport.PersonIdField ) )
{
// if we already had a selectField, use it (to preserve checkbox state)
gReport.Columns.Add( selectField ?? new SelectField() );
columnIndex++;
}
var reportFieldSortExpressions = new Dictionary<Guid, string>();
foreach ( var reportField in report.ReportFields.OrderBy( a => a.ColumnOrder ) )
{
columnIndex++;
if ( reportField.ReportFieldType == ReportFieldType.Property )
{
var entityField = entityFields.FirstOrDefault( a => a.Name == reportField.Selection );
if ( entityField != null )
{
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField = entityField.GetBoundFieldType();
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? entityField.Title : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace( reportField.Guid, boundField.SortExpression );
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( boundField );
}
}
else if ( reportField.ReportFieldType == ReportFieldType.Attribute )
{
Guid? attributeGuid = reportField.Selection.AsGuidOrNull();
if ( attributeGuid.HasValue )
{
var attribute = AttributeCache.Read( attributeGuid.Value, rockContext );
if ( attribute != null )
{
selectedAttributes.Add( columnIndex, attribute );
BoundField boundField;
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.BOOLEAN.AsGuid() ) )
{
boundField = new BoolField();
}
else if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DEFINED_VALUE.AsGuid() ) )
{
boundField = new DefinedValueField();
}
else
{
boundField = new CallbackField();
boundField.HtmlEncode = false;
( boundField as CallbackField ).OnFormatDataValue += (sender, e) => {
string resultHtml = null;
if (e.DataValue != null)
{
bool condensed = true;
resultHtml = attribute.FieldType.Field.FormatValueAsHtml( gReport, e.DataValue.ToString(), attribute.QualifierValues, condensed );
}
e.FormattedValue = resultHtml ?? string.Empty;
};
}
boundField.DataField = string.Format( "Attribute_{0}_{1}", attribute.Id, columnIndex );
boundField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? attribute.Name : reportField.ColumnHeaderText;
boundField.SortExpression = boundField.DataField;
reportFieldSortExpressions.AddOrReplace( reportField.Guid, boundField.SortExpression );
if ( attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.INTEGER.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.DATE.AsGuid() ) ||
attribute.FieldType.Guid.Equals( Rock.SystemGuid.FieldType.FILTER_DATE.AsGuid() ) )
{
boundField.HeaderStyle.HorizontalAlign = HorizontalAlign.Right;
boundField.ItemStyle.HorizontalAlign = HorizontalAlign.Right;
}
boundField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( boundField );
}
}
}
else if ( reportField.ReportFieldType == ReportFieldType.DataSelectComponent )
{
selectedComponents.Add( columnIndex, reportField );
DataSelectComponent selectComponent = DataSelectContainer.GetComponent( reportField.DataSelectComponentEntityType.Name );
if ( selectComponent != null )
{
try
{
DataControlField columnField = selectComponent.GetGridField( entityType, reportField.Selection ?? string.Empty );
if ( columnField is BoundField )
{
( columnField as BoundField ).DataField = string.Format( "Data_{0}_{1}", selectComponent.ColumnPropertyName, columnIndex );
var customSortProperties = selectComponent.SortProperties( reportField.Selection ?? string.Empty );
bool sortReversed = selectComponent.SortReversed( reportField.Selection ?? string.Empty );
if ( customSortProperties != null )
{
if ( customSortProperties == string.Empty )
{
// disable sorting if customSortExpression set to string.empty
columnField.SortExpression = string.Empty;
}
else
{
columnField.SortExpression = customSortProperties.Split( ',' ).Select( a => string.Format( "Sort_{0}_{1}", a, columnIndex ) ).ToList().AsDelimited( "," );
}
}
else
{
// use default sorting if customSortExpression was null
columnField.SortExpression = ( columnField as BoundField ).DataField;
}
if ( sortReversed == true && !string.IsNullOrWhiteSpace( columnField.SortExpression ) )
{
columnField.SortExpression = columnField.SortExpression + " DESC";
}
}
columnField.HeaderText = string.IsNullOrWhiteSpace( reportField.ColumnHeaderText ) ? selectComponent.ColumnHeaderText : reportField.ColumnHeaderText;
if ( !string.IsNullOrEmpty( columnField.SortExpression ) )
{
reportFieldSortExpressions.AddOrReplace( reportField.Guid, columnField.SortExpression );
}
columnField.Visible = reportField.ShowInGrid;
gReport.Columns.Add( columnField );
}
catch ( Exception ex )
{
ExceptionLogService.LogException( ex, HttpContext.Current );
errors.Add( string.Format( "{0} - {1}", selectComponent, ex.Message ) );
}
}
}
}
// if no fields are specified, show the default fields (Previewable/All) for the EntityType
var dataColumns = gReport.Columns.OfType<object>().Where( a => a.GetType() != typeof( SelectField ) );
if ( dataColumns.Count() == 0 )
{
// show either the Previewable Columns or all (if there are no previewable columns)
bool showAllColumns = !entityFields.Any( a => a.FieldKind == FieldKind.Property && a.IsPreviewable );
foreach ( var entityField in entityFields.Where( a => a.FieldKind == FieldKind.Property ) )
{
columnIndex++;
selectedEntityFields.Add( columnIndex, entityField );
BoundField boundField = entityField.GetBoundFieldType();
boundField.DataField = string.Format( "Entity_{0}_{1}", entityField.Name, columnIndex );
boundField.HeaderText = entityField.Name;
boundField.SortExpression = boundField.DataField;
boundField.Visible = showAllColumns || entityField.IsPreviewable;
gReport.Columns.Add( boundField );
}
}
try
{
gReport.Visible = true;
gReport.ExportFilename = report.Name;
SortProperty sortProperty = gReport.SortProperty;
if ( sortProperty == null )
{
var reportSort = new SortProperty();
var sortColumns = new Dictionary<string, SortDirection>();
foreach ( var reportField in report.ReportFields.Where( a => a.SortOrder.HasValue ).OrderBy( a => a.SortOrder.Value ) )
{
if ( reportFieldSortExpressions.ContainsKey( reportField.Guid ) )
{
var sortField = reportFieldSortExpressions[reportField.Guid];
if ( !string.IsNullOrWhiteSpace( sortField ) )
{
sortColumns.Add( sortField, reportField.SortDirection );
}
}
}
if ( sortColumns.Any() )
{
reportSort.Property = sortColumns.Select( a => a.Key + ( a.Value == SortDirection.Descending ? " desc" : string.Empty ) ).ToList().AsDelimited( "," );
sortProperty = reportSort;
}
}
var qryErrors = new List<string>();
dynamic qry = report.GetQueryable( entityType, selectedEntityFields, selectedAttributes, selectedComponents, sortProperty, databaseTimeoutSeconds ?? 180, out qryErrors );
errors.AddRange( qryErrors );
gReport.SetLinqDataSource( qry );
gReport.DataBind();
}
catch ( Exception ex )
{
Exception exception = ex;
ExceptionLogService.LogException( ex, HttpContext.Current );
while ( exception != null )
{
if ( exception is System.Data.SqlClient.SqlException )
{
// if there was a SQL Server Timeout, have the warning be a friendly message about that.
if ( ( exception as System.Data.SqlClient.SqlException ).Number == -2 )
{
errorMessage = "This report did not complete in a timely manner. You can try again or adjust the timeout setting of this block.";
return;
}
else
{
errors.Add( exception.Message );
exception = exception.InnerException;
}
}
else
{
errors.Add( exception.Message );
exception = exception.InnerException;
}
}
}
if ( errors.Any() )
{
errorMessage = "WARNING: There was a problem with one or more of the report's data components...<br/><br/> " + errors.AsDelimited( "<br/>" );
}
}
}