/// <summary>
/// Gets the selection.
/// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
/// <param name="controls">The collection of controls used to set the filter values.</param>
/// <returns>
/// A formatted string.
/// </returns>
public override string GetSelection(Type entityType, Control[] controls)
{
var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);
var settings = new FilterSettings();
settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(dvpDataView.SelectedValue);
return(settings.ToSelectionString());
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
// Parameter 1: Group Member Data View
GroupMemberDataViewGuid = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 0).AsGuidOrNull();
// Parameter 2: Group Member Count Comparison Type
MemberCountComparison = DataComponentSettingsHelper.GetParameterAsEnum(parameters, 1, ComparisonType.GreaterThan);
// Parameter 3: Group Member Count
MemberCount = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 2).AsIntegerOrNull();
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new FilterSettings(selection);
var context = (RockContext)serviceInstance.Context;
//
// Define Candidate Group Members.
//
// Get the Group Member Data View that defines the set of candidates from which matching Group Members can be selected.
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.GroupMemberDataViewGuid, context);
var memberService = new GroupMemberService(context);
var memberQuery = memberService.Queryable();
if (dataView != null)
{
memberQuery = DataComponentSettingsHelper.FilterByDataView(memberQuery, dataView, memberService);
}
//
// Construct the Query to return the list of People matching the filter conditions.
//
var personQuery = new PersonService(context).Queryable();
BinaryExpression result;
if (settings.MemberCountComparison.HasValue &&
settings.MemberCount.HasValue)
{
var comparisonType = settings.MemberCountComparison.Value;
int memberCountValue = settings.MemberCount.Value;
var memberKeys = memberQuery.Select(x => x.Id);
var memberCountEqualQuery = personQuery.Where(p => p.Members.Count(gm => memberKeys.Contains(gm.Id)) == memberCountValue);
var compareEqualExpression = FilterExpressionExtractor.Extract <Model.Person>(memberCountEqualQuery, parameterExpression, "p") as BinaryExpression;
result = FilterExpressionExtractor.AlterComparisonType(comparisonType, compareEqualExpression, 0);
}
else
{
personQuery = personQuery.Where(p => memberQuery.Any(m => m.PersonId == p.Id));
result = FilterExpressionExtractor.Extract <Model.Person>(personQuery, parameterExpression, "p") as BinaryExpression;
}
return(result);
}
/// <summary>
/// Gets the selection.
/// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
/// <param name="controls">The collection of controls used to set the filter values.</param>
/// <returns>
/// A formatted string.
/// </returns>
public override string GetSelection(Type entityType, Control[] controls)
{
var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);
var ddlLocationType = controls.GetByName <RockDropDownList>(_CtlLocationType);
var settings = new FilterSettings();
settings.LocationTypeGuid = ddlLocationType.SelectedValue.AsGuidOrNull();
settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(dvpDataView.SelectedValue);
return(settings.ToSelectionString());
}
/// <summary>
/// Sets the filter control values from a formatted string.
/// </summary>
/// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
/// <param name="controls">The collection of controls used to set the filter values.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
public override void SetSelection(Type entityType, Control[] controls, string selection)
{
var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);
var settings = new FilterSettings(selection);
if (!settings.IsValid)
{
return;
}
dvpDataView.SetValue(DataComponentSettingsHelper.GetDataViewId(settings.PersonDataViewGuid));
}
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
NoteTypeIds.Clear();
var selectedNoteTypeIds = DataComponentSettingsHelper.GetParameterAsList(parameters, 0, ",");
foreach (var noteTypeId in selectedNoteTypeIds)
{
NoteTypeIds.Add(noteTypeId.AsInteger());
}
DelimitedValues = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 1).Replace(";", "|");
}
/// <summary>
/// Sets the selection.
/// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="controls">The controls.</param>
/// <param name="selection">The selection.</param>
public override void SetSelection(Type entityType, Control[] controls, string selection)
{
var ddlDataView = controls.GetByName <DataViewPicker>(_CtlDataView);
var settings = new FilterSettings(selection);
if (!settings.IsValid)
{
return;
}
ddlDataView.SelectedValue = DataComponentSettingsHelper.GetDataViewId(settings.DataViewGuid).ToStringSafe();
}
/// <summary>
/// Gets the selection.
/// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
/// <param name="controls">The collection of controls used to set the filter values.</param>
/// <returns>
/// A formatted string.
/// </returns>
public override string GetSelection(Type entityType, Control[] controls)
{
var ddlDataView = controls.GetByName <DataViewPicker>(_CtlDataView);
var ddlCompare = controls.GetByName <RockDropDownList>(_CtlComparison);
var nbValue = controls.GetByName <NumberBox>(_CtlMemberCount);
var settings = new FilterSettings();
settings.GroupMemberDataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(ddlDataView.SelectedValue);
settings.MemberCountComparison = ddlCompare.SelectedValueAsEnum <ComparisonType>(ComparisonType.GreaterThan);
settings.MemberCount = nbValue.Text.AsInteger();
return(settings.ToSelectionString());
}
/// <summary>
/// Gets the selection.
/// Implement this version of GetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">The System Type of the entity to which the filter will be applied.</param>
/// <param name="controls">The collection of controls used to set the filter values.</param>
/// <returns>
/// A formatted string.
/// </returns>
public override string GetSelection(Type entityType, Control[] controls)
{
var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);
var ddlRoleType = controls.GetByName <RockDropDownList>(_CtlRoleType);
var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);
var settings = new SelectSettings();
settings.MemberStatus = ddlGroupMemberStatus.SelectedValue.ConvertToEnumOrNull <GroupMemberStatus>();
settings.RoleType = ddlRoleType.SelectedValue.ConvertToEnumOrNull <RoleTypeSpecifier>();
settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(dvpDataView.SelectedValue);
return(settings.ToSelectionString());
}
/// <summary>
/// Sets the selection.
/// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="controls">The controls.</param>
/// <param name="selection">The selection.</param>
public override void SetSelection(Type entityType, Control[] controls, string selection)
{
var dvpDataView = controls.GetByName <DataViewItemPicker>(_CtlDataView);
var ddlLocationType = controls.GetByName <RockDropDownList>(_CtlLocationType);
var settings = new FilterSettings(selection);
if (!settings.IsValid)
{
return;
}
dvpDataView.SetValue(DataComponentSettingsHelper.GetDataViewId(settings.DataViewGuid));
ddlLocationType.SelectedValue = settings.LocationTypeGuid.ToStringSafe();
}
/// <summary>
/// Gets the selection.
/// This is typically a string that contains the values selected with the Controls
/// </summary>
/// <param name="controls">The controls.</param>
/// <returns></returns>
public override string GetSelection(Control[] controls)
{
var ddlDataView = controls.GetByName <DataViewPicker>(_CtlDataView);
var ddlRoleType = controls.GetByName <RockDropDownList>(_CtlRoleType);
var ddlFormat = controls.GetByName <RockDropDownList>(_CtlFormat);
var ddlGroupMemberStatus = controls.GetByName <RockDropDownList>(_CtlGroupStatus);
var settings = new GroupParticipationSelectSettings();
settings.MemberStatus = ddlGroupMemberStatus.SelectedValue.ConvertToEnumOrNull <GroupMemberStatus>();
settings.RoleType = ddlRoleType.SelectedValue.ConvertToEnumOrNull <RoleTypeSpecifier>();
settings.DataViewGuid = DataComponentSettingsHelper.GetDataViewGuid(ddlDataView.SelectedValue);
settings.ListFormat = ddlFormat.SelectedValue.ConvertToEnum <ListFormatSpecifier>(ListFormatSpecifier.GroupAndRole);
return(settings.ToSelectionString());
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
StepProgramGuid = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 0).AsGuidOrNull();
StepTypeGuids = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 1).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.AsGuid()).ToList();
StepStatusGuids = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 2).Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.AsGuid()).ToList();
var periodStartSettings = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 3);
StartedInPeriod = new TimePeriod(periodStartSettings, ",");
var periodCompletedSettings = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 4);
CompletedInPeriod = new TimePeriod(periodCompletedSettings, ",");
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
/// <exception cref="System.Exception">Filter issue(s): + errorMessages.AsDelimited( ; )</exception>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new FilterSettings(selection);
var context = (RockContext)serviceInstance.Context;
// Get the Location Data View that defines the set of candidates from which proximate Locations can be selected.
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
// Evaluate the Data View that defines the candidate Locations.
var locationService = new LocationService(context);
var locationQuery = locationService.Queryable();
if (dataView != null)
{
locationQuery = DataComponentSettingsHelper.FilterByDataView(locationQuery, dataView, locationService);
}
// Get all the Family Groups that have a Location matching one of the candidate Locations.
int familyGroupTypeId = GroupTypeCache.Get(SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid()).Id;
var groupLocationsQuery = new GroupLocationService(context).Queryable()
.Where(gl => gl.Group.GroupTypeId == familyGroupTypeId && locationQuery.Any(l => l.Id == gl.LocationId));
// If a Location Type is specified, apply the filter condition.
if (settings.LocationTypeGuid.HasValue)
{
int groupLocationTypeId = DefinedValueCache.Get(settings.LocationTypeGuid.Value).Id;
groupLocationsQuery = groupLocationsQuery.Where(x => x.GroupLocationTypeValue.Id == groupLocationTypeId);
}
// Get all of the Group Members of the qualifying Families.
var groupMemberServiceQry = new GroupMemberService(context).Queryable()
.Where(gm => groupLocationsQuery.Any(gl => gl.GroupId == gm.GroupId));
// Get all of the People corresponding to the qualifying Group Members.
var qry = new PersonService(context).Queryable()
.Where(p => groupMemberServiceQry.Any(gm => gm.PersonId == p.Id));
// Retrieve the Filter Expression.
var extractedFilterExpression = FilterExpressionExtractor.Extract <Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
/// <summary>
/// Sets the selection.
/// Implement this version of SetSelection if your DataFilterComponent works the same in all FilterModes
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="controls">The controls.</param>
/// <param name="selection">The selection.</param>
public override void SetSelection(Type entityType, Control[] controls, string selection)
{
var ddlDataView = controls.GetByName <DataViewPicker>(_CtlDataView);
var ddlCompare = controls.GetByName <RockDropDownList>(_CtlComparison);
var nbValue = controls.GetByName <NumberBox>(_CtlMemberCount);
var settings = new FilterSettings(selection);
if (!settings.IsValid)
{
return;
}
ddlDataView.SelectedValue = DataComponentSettingsHelper.GetDataViewId(settings.GroupMemberDataViewGuid).ToStringSafe();
ddlCompare.SelectedValue = settings.MemberCountComparison.ConvertToInt().ToString();
nbValue.Text = settings.MemberCount.ToString();
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
// Parameter 1: Location Type
LocationTypeGuid = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 0).AsGuidOrNull();
// Parameter 2: Street1
Street1 = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 1).ToStringSafe();
// Parameter 3: City
City = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 2).ToStringSafe();
// Parameter 4: State
State = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 3).ToStringSafe();
// Parameter 5: Postal Code
PostalCode = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 4).ToStringSafe();
// Parameter 6: Country
Country = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 5).ToStringSafe();
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new FilterSettings(selection);
var context = (RockContext)serviceInstance.Context;
//
// Define Candidate People.
//
// Get the Person Data View that defines the set of candidates from which matching Group Members can be selected.
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.PersonDataViewGuid, context);
var personService = new PersonService(context);
var personQuery = personService.Queryable();
if (dataView != null)
{
personQuery = DataComponentSettingsHelper.FilterByDataView(personQuery, dataView, personService);
}
var personKeys = personQuery.Select(x => x.Id);
//
// Construct the Query to return the list of Groups matching the filter conditions.
//
var comparisonType = settings.PersonCountComparison;
int memberCountValue = settings.PersonCount;
var memberCountQuery = new GroupService(context).Queryable();
var memberCountEqualQuery = memberCountQuery.Where(g => g.Members.Count(gm => personKeys.Contains(gm.PersonId)) == memberCountValue);
var compareEqualExpression = FilterExpressionExtractor.Extract <Model.Group>(memberCountEqualQuery, parameterExpression, "g") as BinaryExpression;
var result = FilterExpressionExtractor.AlterComparisonType(comparisonType, compareEqualExpression, 0);
return(result);
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new FilterSettings(selection);
var context = (RockContext)serviceInstance.Context;
// Get the Data View that defines the set of related records from which entities can be selected.
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
// Evaluate the Data View that defines the related records.
var historyService = new HistoryService(context);
var historyQuery = historyService.Queryable();
if (dataView != null)
{
historyQuery = DataComponentSettingsHelper.FilterByDataView(historyQuery, dataView, historyService);
}
// Select only those History records that are either related to a Person, or affect a Person.
int personEntityTypeId = EntityTypeCache.GetId(typeof(Model.Person)).GetValueOrDefault();
historyQuery = historyQuery.Where(x => x.EntityTypeId == personEntityTypeId);
// Get all of the People corresponding to the qualifying History records.
var qry = new PersonService(context).Queryable()
.Where(
p =>
historyQuery.Any(
h =>
h.EntityTypeId == personEntityTypeId &&
h.EntityId == p.Id ||
(h.RelatedEntityTypeId == personEntityTypeId && h.RelatedEntityId == p.Id)));
// Retrieve the Filter Expression.
var extractedFilterExpression = FilterExpressionExtractor.Extract <Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new SelectSettings(selection);
var context = (RockContext)serviceInstance.Context;
//
// Evaluate the Data View that defines the candidate Groups.
//
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
var groupService = new GroupService(context);
var groupQuery = groupService.Queryable();
if (dataView != null)
{
groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
}
else
{
// Apply a default Group filter to only show Groups that would be visible in a Group List.
groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
}
var groupKeys = groupQuery.Select(x => x.Id);
//
// Construct the Query to return the list of Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService(context).Queryable();
// Filter By Group.
groupMemberQuery = groupMemberQuery.Where(gm => groupKeys.Contains(gm.GroupId));
var selectExpression = FilterExpressionExtractor.Extract <Model.GroupMember>(groupMemberQuery, parameterExpression, "gm");
return(selectExpression);
}
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
ListFormat = DataComponentSettingsHelper.GetParameterAsEnum(parameters, 0, ListFormatSpecifier.NameAndRelationship);
List <string> selectedRoleGuids;
FamilyRelationshipTypeGuids.Clear();
selectedRoleGuids = DataComponentSettingsHelper.GetParameterAsList(parameters, 1, ",");
foreach (var roleGuid in selectedRoleGuids)
{
FamilyRelationshipTypeGuids.Add(roleGuid.AsGuid());
}
KnownRelationshipTypeGuids.Clear();
selectedRoleGuids = DataComponentSettingsHelper.GetParameterAsList(parameters, 2, ",");
foreach (var roleGuid in selectedRoleGuids)
{
KnownRelationshipTypeGuids.Add(roleGuid.AsGuid());
}
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
{
var settings = new GroupParticipationSelectSettings(selection);
//
// Define Candidate Groups.
//
// Get the Group Data View that defines the set of candidates from which matching Groups can be selected.
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
// Evaluate the Data View that defines the candidate Groups.
var groupService = new GroupService(context);
var groupQuery = groupService.Queryable();
if (dataView != null)
{
groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
}
else
{
// Apply a default Group filter to only show Groups that would be visible in a Group List.
groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
}
var groupKeys = groupQuery.Select(x => x.Id);
//
// Construct the Query to return the list of Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService(context).Queryable();
// Filter By Group.
groupMemberQuery = groupMemberQuery.Where(x => groupKeys.Contains(x.GroupId));
// Filter By Group Role Type.
switch (settings.RoleType)
{
case RoleTypeSpecifier.Member:
groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
break;
case RoleTypeSpecifier.Leader:
groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
break;
}
// Filter by Group Member Status.
if (settings.MemberStatus.HasValue)
{
groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
}
//
// Create a Select Expression to return the requested values.
//
// Set the Output Format of the field.
Expression selectExpression;
if (settings.ListFormat == ListFormatSpecifier.YesNo)
{
// Define a Query to return True/False text indicating if the Person participates in any of the filtered Groups.
// Note that the text must be returned as an Enumerable to satisfy the expected output of this field.
var personGroupsQuery = new PersonService(context).Queryable()
.Select(p => new List <string> {
groupMemberQuery.Any(s => s.PersonId == p.Id) ? "Yes" : "No"
});
selectExpression = SelectExpressionExtractor.Extract(personGroupsQuery, entityIdProperty, "p");
}
else
{
// Define a Query to return the collection of filtered Groups for each Person.
Expression <Func <Rock.Model.GroupMember, string> > outputExpression;
if (settings.ListFormat == ListFormatSpecifier.GroupOnly)
{
outputExpression = ((m => m.Group.Name));
}
else
{
outputExpression = ((m => m.Group.Name + " [" + m.GroupRole.Name + "]"));
}
// Define a Query to return the collection of filtered Groups for each Person.
var personGroupsQuery = new PersonService(context).Queryable()
.Select(p => groupMemberQuery.Where(s => s.PersonId == p.Id)
.OrderBy(x => x.Group.Name)
.ThenBy(x => x.GroupRole.Name)
.Select(outputExpression).AsEnumerable());
selectExpression = SelectExpressionExtractor.Extract(personGroupsQuery, entityIdProperty, "p");
}
return(selectExpression);
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
DataViewGuid = DataComponentSettingsHelper.GetParameterOrDefault(parameters, 0, string.Empty).AsGuidOrNull();
}
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
// Parameter 1: Attribute Key
AttributeKey = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 0);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
{
var settings = new SelectSettings(selection);
// Get the Person Data View that defines the set of candidates from which matching Group Members can be selected.
IQueryable <int> personKeys = null;
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
var personService = new PersonService(context);
var personQuery = personService.Queryable();
if (dataView != null)
{
personQuery = DataComponentSettingsHelper.FilterByDataView(personQuery, dataView, personService);
personKeys = personQuery.Select(x => x.Id);
}
//
// Construct the Query to return the list of Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService(context).Queryable();
// Filter By People.
if (personKeys != null)
{
groupMemberQuery = groupMemberQuery.Where(x => personKeys.Contains(x.PersonId));
}
// Filter By Group Role Type.
switch (settings.RoleType)
{
case RoleTypeSpecifier.Member:
groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
break;
case RoleTypeSpecifier.Leader:
groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
break;
}
// Filter by Group Member Status.
if (settings.MemberStatus.HasValue)
{
groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
}
//
// Create a Select Expression to return the requested values.
//
// Set the Output Format of the field.
Expression <Func <Rock.Model.GroupMember, string> > outputExpression;
switch (settings.ListFormat)
{
case ListFormatSpecifier.FirstNameLastName:
outputExpression = ((m => m.Person.FirstName + " " + m.Person.LastName));
break;
default: // ListFormatSpecifier.GroupAndRole:
outputExpression = ((m => m.Person.FirstName + " " + m.Person.LastName + " [" + m.GroupRole.Name + "]"));
break;
}
// Define a Query to return the collection of filtered People for each Group.
var groupPeopleQuery = new GroupService(context).Queryable()
.Select(g => groupMemberQuery.Where(s => s.GroupId == g.Id)
.OrderBy(x => x.Person.LastName)
.ThenBy(x => x.Person.FirstName)
.ThenBy(x => x.GroupRole.Name)
.Select(outputExpression).AsEnumerable());
var selectExpression = SelectExpressionExtractor.Extract <Model.Person>(groupPeopleQuery, entityIdProperty, "g");
return(selectExpression);
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new SelectSettings(selection);
var context = ( RockContext )serviceInstance.Context;
//
// Evaluate the Data View that defines the candidate Groups.
//
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
var groupService = new GroupService(context);
var groupQuery = groupService.Queryable();
if (dataView != null)
{
groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
}
else
{
// Apply a default Group filter to only show Groups that would be visible in a Group List.
groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
}
var groupKeys = groupQuery.Select(x => x.Id);
//
// Construct the Query to return the list of Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService(context).Queryable();
// Filter By Group.
groupMemberQuery = groupMemberQuery.Where(x => groupKeys.Contains(x.GroupId));
// Filter By Group Role Type.
switch (settings.RoleType)
{
case RoleTypeSpecifier.Member:
groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
break;
case RoleTypeSpecifier.Leader:
groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
break;
}
// Filter by Group Member Status.
if (settings.MemberStatus.HasValue)
{
groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
}
//
// Create a Select Expression to return the Person records referenced by the Group Members.
//
var personGroupsQuery = new PersonService(context).Queryable()
.Where(p => groupMemberQuery.Select(gm => gm.PersonId).Contains(p.Id));
var selectExpression = FilterExpressionExtractor.Extract <Model.Person>(personGroupsQuery, parameterExpression, "p");
return(selectExpression);
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
// Parameter 1: Data View
DataViewGuid = DataComponentSettingsHelper.GetParameterOrEmpty(parameters, 0).AsGuidOrNull();
}
/// <summary>
/// Set the property values parsed from a settings string.
/// </summary>
/// <param name="version">The version number of the parameter set.</param>
/// <param name="parameters">An ordered collection of strings representing the parameter values.</param>
protected override void OnSetParameters(int version, IReadOnlyList <string> parameters)
{
DataViewGuid = DataComponentSettingsHelper.GetParameterOrDefault(parameters, 0, string.Empty).AsGuidOrNull();
MemberStatus = DataComponentSettingsHelper.GetParameterAsEnum <GroupMemberStatus>(parameters, 1);
RoleType = DataComponentSettingsHelper.GetParameterAsEnum <RoleTypeSpecifier>(parameters, 2);
}
