|
public GetAllDescendents ( int parentGroupId ) : IEnumerable |
||
| parentGroupId | int | An |
| return | IEnumerable |
|
/// <summary>
/// Loads the groups.
/// </summary>
private void LoadDropDowns()
{
var groupEntityType = EntityTypeCache.Read( typeof( Group ) );
var currentGroup = RockPage.GetCurrentContext( groupEntityType ) as Group;
var groupIdString = Request.QueryString["groupId"];
if ( groupIdString != null )
{
var groupId = groupIdString.AsInteger();
if ( currentGroup == null || currentGroup.Id != groupId )
{
currentGroup = SetGroupContext( groupId, false );
}
}
var parts = ( GetAttributeValue( "GroupFilter" ) ?? string.Empty ).Split( '|' );
Guid? groupTypeGuid = null;
Guid? rootGroupGuid = null;
if ( parts.Length >= 1 )
{
groupTypeGuid = parts[0].AsGuidOrNull();
if ( parts.Length >= 2 )
{
rootGroupGuid = parts[1].AsGuidOrNull();
}
}
var rockContext = new RockContext();
var groupService = new GroupService( rockContext );
var groupTypeService = new GroupTypeService( rockContext );
IQueryable<Group> qryGroups = null;
// if rootGroup is set, use that as the filter. Otherwise, use GroupType as the filter
if ( rootGroupGuid.HasValue )
{
var rootGroup = groupService.Get( rootGroupGuid.Value );
if ( rootGroup != null )
{
qryGroups = groupService.GetAllDescendents( rootGroup.Id ).AsQueryable();
}
}
else if ( groupTypeGuid.HasValue )
{
SetGroupTypeContext( groupTypeGuid );
if ( GetAttributeValue( "IncludeGroupTypeChildren" ).AsBoolean() )
{
var childGroupTypeGuids = groupTypeService.Queryable().Where( t => t.ParentGroupTypes.Select( p => p.Guid ).Contains( groupTypeGuid.Value ) )
.Select( t => t.Guid ).ToList();
qryGroups = groupService.Queryable().Where( a => childGroupTypeGuids.Contains( a.GroupType.Guid ) );
}
else
{
qryGroups = groupService.Queryable().Where( a => a.GroupType.Guid == groupTypeGuid.Value );
}
}
// no results
if ( qryGroups == null )
{
nbSelectGroupTypeWarning.Visible = true;
lCurrentSelection.Text = string.Empty;
rptGroups.Visible = false;
}
else
{
nbSelectGroupTypeWarning.Visible = false;
rptGroups.Visible = true;
lCurrentSelection.Text = currentGroup != null ? currentGroup.ToString() : GetAttributeValue( "NoGroupText" );
var groupList = qryGroups.OrderBy( a => a.Order )
.ThenBy( a => a.Name ).ToList()
.Select( a => new GroupItem() { Name = a.Name, Id = a.Id } )
.ToList();
// check if the group can be unselected
if ( !string.IsNullOrEmpty( GetAttributeValue( "ClearSelectionText" ) ) )
{
var blankGroup = new GroupItem
{
Name = GetAttributeValue( "ClearSelectionText" ),
Id = Rock.Constants.All.Id
};
groupList.Insert( 0, blankGroup );
}
rptGroups.DataSource = groupList;
rptGroups.DataBind();
}
}
/// <summary>
/// Gets the set of Groups that are included in a Group Branch, either as the parent or a descendant.
/// </summary>
/// <param name="groupService"></param>
/// <param name="parentGroup"></param>
/// <param name="includedBranchItems"></param>
/// <returns></returns>
private HashSet<int> GetGroupBranchKeys( GroupService groupService, Model.Group parentGroup, IncludedGroupsSpecifier includedBranchItems )
{
var groupKeys = new HashSet<int>();
if ( parentGroup == null )
{
return groupKeys;
}
// Include the Parent Group?
if ( includedBranchItems == IncludedGroupsSpecifier.EntireBranch )
{
groupKeys.Add( parentGroup.Id );
}
// Include descendants of the Parent Group.
foreach ( int childGroupId in groupService.GetAllDescendents( parentGroup.Id ).Select( x => x.Id ) )
{
groupKeys.Add( childGroupId );
}
return groupKeys;
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
{
string[] selectionValues = selection.Split( '|' );
if ( selectionValues.Length >= 2 )
{
GroupMemberService groupMemberService = new GroupMemberService( (RockContext)serviceInstance.Context );
List<Guid> groupGuids = selectionValues[0].Split( ',' ).AsGuidList();
var groupService = new GroupService( (RockContext)serviceInstance.Context );
var groupIds = groupService.GetByGuids( groupGuids ).Select( a => a.Id ).Distinct().ToList();
bool includeChildGroups = false;
bool includeChildGroupsIncludeSelected = false;
bool includeChildGroupsPlusDescendants = false;
bool includeInactiveGroups = false;
if ( selectionValues.Length >= 3 )
{
includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false;
}
if ( selectionValues.Length >= 6 )
{
includeChildGroupsIncludeSelected = selectionValues[4].AsBooleanOrNull() ?? false;
includeChildGroupsPlusDescendants = selectionValues[5].AsBooleanOrNull() ?? false;
}
else if ( includeChildGroups )
{
// in case the selection was saved before these options where added
includeChildGroupsIncludeSelected = true;
includeChildGroupsPlusDescendants = true;
}
if ( selectionValues.Length >= 7 )
{
includeInactiveGroups = selectionValues[6].AsBooleanOrNull() ?? true; ;
}
else
{
// if options where saved before this option was added, set to false, even though it would have included inactive before
includeInactiveGroups = false;
}
GroupMemberStatus? groupMemberStatus = null;
if ( selectionValues.Length >= 4 )
{
groupMemberStatus = selectionValues[3].ConvertToEnumOrNull<GroupMemberStatus>();
}
var groupMemberServiceQry = groupMemberService.Queryable();
if ( includeChildGroups )
{
List<int> childGroupIds = new List<int>();
foreach ( var groupId in groupIds )
{
if ( includeChildGroupsPlusDescendants )
{
// get all children and descendants of the selected group(s)
var descendants = groupService.GetAllDescendents( groupId );
if ( !includeInactiveGroups )
{
descendants = descendants.Where( a => a.IsActive == true );
}
childGroupIds.AddRange( descendants.Select( a => a.Id ).Distinct().ToList() );
}
else
{
// get only immediate children of the selected group(s)
var childGroups = groupService.Queryable().Where( a => a.ParentGroupId == groupId );
if ( !includeInactiveGroups )
{
childGroups = childGroups.Where( a => a.IsActive == true );
}
childGroupIds.AddRange( childGroups.Select( a => a.Id ) );
}
}
if ( includeChildGroupsIncludeSelected )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupIds.Contains( xx.GroupId ) || childGroupIds.Contains( xx.GroupId ) );
}
else
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => childGroupIds.Contains( xx.GroupId ) );
}
}
else
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupIds.Contains( xx.GroupId ) );
}
if ( groupMemberStatus.HasValue )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.GroupMemberStatus == groupMemberStatus.Value );
}
var groupRoleGuids = selectionValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( n => n.AsGuid() ).ToList();
if ( groupRoleGuids.Count() > 0 )
{
var groupRoleIds = new GroupTypeRoleService( (RockContext)serviceInstance.Context ).Queryable().Where( a => groupRoleGuids.Contains( a.Guid ) ).Select( a => a.Id ).ToList();
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupRoleIds.Contains( xx.GroupRoleId ) );
}
if ( selectionValues.Length >= 8 )
{
string slidingDelimitedValues = selectionValues[7].Replace( ',', '|' );
DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues( slidingDelimitedValues );
if ( dateRange.Start.HasValue )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.DateTimeAdded >= dateRange.Start.Value );
}
if ( dateRange.End.HasValue )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.DateTimeAdded < dateRange.End.Value );
}
}
var qry = new PersonService( (RockContext)serviceInstance.Context ).Queryable()
.Where( p => groupMemberServiceQry.Any( xx => xx.PersonId == p.Id ) );
Expression extractedFilterExpression = FilterExpressionExtractor.Extract<Rock.Model.Person>( qry, parameterExpression, "p" );
return extractedFilterExpression;
}
return null;
}
/// <summary>
/// Handles the SelectItem event of the gp control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void gp_SelectItem( object sender, EventArgs e )
{
var rockContext = new RockContext();
var groupIdList = gp.SelectedValues.AsIntegerList();
var groupService = new GroupService( rockContext );
var qryGroups = groupService.GetByIds( groupIdList );
if ( qryGroups.Any() )
{
var groupTypeRoleService = new GroupTypeRoleService( rockContext );
var qryGroupTypeRoles = groupTypeRoleService.Queryable();
List<int> selectedGroupTypeIds = qryGroups.Select( a => a.GroupTypeId ).Distinct().ToList();
if ( cbChildGroups.Checked )
{
List<int> childGroupTypeIds = new List<int>();
foreach ( var groupId in qryGroups.Select( a => a.Id ).ToList() )
{
if ( cbChildGroupsPlusDescendants.Checked )
{
// get all children and descendants of the selected group(s)
var descendants = groupService.GetAllDescendents( groupId );
if ( !cbIncludeInactiveGroups.Checked )
{
descendants = descendants.Where( a => a.IsActive == true );
}
childGroupTypeIds.AddRange( descendants.Select( a => a.GroupTypeId ).Distinct().ToList() );
}
else
{
// get only immediate children of the selected group(s)
var childGroups = groupService.Queryable().Where( a => a.ParentGroupId == groupId );
if ( !cbIncludeInactiveGroups.Checked )
{
childGroups = childGroups.Where( a => a.IsActive == true );
}
childGroupTypeIds.AddRange( childGroups.Select( a => a.GroupTypeId ).Distinct().ToList() );
}
}
childGroupTypeIds = childGroupTypeIds.Distinct().ToList();
if ( cbIncludeSelectedGroup.Checked )
{
qryGroupTypeRoles = qryGroupTypeRoles.Where( a => a.GroupTypeId.HasValue && ( selectedGroupTypeIds.Contains( a.GroupTypeId.Value ) || childGroupTypeIds.Contains( a.GroupTypeId.Value ) ) );
}
else
{
qryGroupTypeRoles = qryGroupTypeRoles.Where( a => a.GroupTypeId.HasValue && childGroupTypeIds.Contains( a.GroupTypeId.Value ) );
}
}
else
{
qryGroupTypeRoles = qryGroupTypeRoles.Where( a => a.GroupTypeId.HasValue && selectedGroupTypeIds.Contains( a.GroupTypeId.Value ) );
}
var list = qryGroupTypeRoles.OrderBy( a => a.GroupType.Order ).ThenBy( a => a.GroupType.Name ).ThenBy( a => a.Order ).ThenBy( a => a.Name ).ToList();
cblRole.Items.Clear();
foreach ( var item in list )
{
cblRole.Items.Add( new ListItem( string.Format( "{0} ({1})", item.Name, item.GroupType.Name ), item.Guid.ToString() ) );
}
cblRole.Visible = list.Count > 0;
}
else
{
cblRole.Visible = false;
}
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
{
string[] options = selection.Split( '|' );
if ( options.Length < 4 )
{
return null;
}
var groupGuidList = options[0].Split( ',' ).AsGuidList();
ComparisonType comparisonType = options[1].ConvertToEnum<ComparisonType>( ComparisonType.GreaterThanOrEqualTo );
int? attended = options[2].AsIntegerOrNull();
string slidingDelimitedValues = options[3].Replace( ',', '|' );
var dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues( slidingDelimitedValues );
bool includeChildGroups = options.Length >= 5 ? options[4].AsBooleanOrNull() ?? false : false;
var groupService = new GroupService( new RockContext() );
var groups = groupService.GetByGuids( groupGuidList );
List<int> groupIds = new List<int>();
foreach ( var group in groups )
{
groupIds.Add( group.Id );
if ( includeChildGroups )
{
var childGroups = groupService.GetAllDescendents( group.Id );
if ( childGroups.Any() )
{
groupIds.AddRange( childGroups.Select( a => a.Id ) );
// get rid of any duplicates
groupIds = groupIds.Distinct().ToList();
}
}
}
var rockContext = serviceInstance.Context as RockContext;
var attendanceQry = new AttendanceService( rockContext ).Queryable().Where( a => a.DidAttend.HasValue && a.DidAttend.Value );
if ( dateRange.Start.HasValue )
{
var startDate = dateRange.Start.Value;
attendanceQry = attendanceQry.Where( a => a.StartDateTime >= startDate );
}
if ( dateRange.End.HasValue )
{
var endDate = dateRange.End.Value;
attendanceQry = attendanceQry.Where( a => a.StartDateTime < endDate );
}
if ( groupIds.Count == 1 )
{
int groupId = groupIds[0];
attendanceQry = attendanceQry.Where( a => a.GroupId.HasValue && a.GroupId.Value == groupId );
}
else if ( groupIds.Count > 1 )
{
attendanceQry = attendanceQry.Where( a => a.GroupId.HasValue && groupIds.Contains( a.GroupId.Value ) );
}
else
{
// no groups selected, so return nothing
return Expression.Constant( false );
}
var qry = new PersonService( rockContext ).Queryable()
.Where( p => attendanceQry.Where( xx => xx.PersonAlias.PersonId == p.Id ).Count() == attended );
BinaryExpression compareEqualExpression = FilterExpressionExtractor.Extract<Rock.Model.Person>( qry, parameterExpression, "p" ) as BinaryExpression;
BinaryExpression result = FilterExpressionExtractor.AlterComparisonType( comparisonType, compareEqualExpression, null );
return result;
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
Group group;
bool wasSecurityRole = false;
bool triggersUpdated = false;
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService( rockContext );
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
GroupRequirementService groupRequirementService = new GroupRequirementService( rockContext );
GroupMemberWorkflowTriggerService groupMemberWorkflowTriggerService = new GroupMemberWorkflowTriggerService( rockContext );
ScheduleService scheduleService = new ScheduleService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
var roleGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() );
int roleGroupTypeId = roleGroupType != null ? roleGroupType.Id : int.MinValue;
if ( CurrentGroupTypeId == 0 )
{
ddlGroupType.ShowErrorMessage( Rock.Constants.WarningMessage.CannotBeBlank( GroupType.FriendlyTypeName ) );
return;
}
int groupId = hfGroupId.Value.AsInteger();
if ( groupId == 0 )
{
group = new Group();
group.IsSystem = false;
group.Name = string.Empty;
}
else
{
group = groupService.Queryable( "Schedule,GroupLocations.Schedules" ).Where( g => g.Id == groupId ).FirstOrDefault();
wasSecurityRole = group.IsActive && ( group.IsSecurityRole || group.GroupTypeId == roleGroupTypeId );
// remove any locations that removed in the UI
var selectedLocations = GroupLocationsState.Select( l => l.Guid );
foreach ( var groupLocation in group.GroupLocations.Where( l => !selectedLocations.Contains( l.Guid ) ).ToList() )
{
group.GroupLocations.Remove( groupLocation );
groupLocationService.Delete( groupLocation );
}
// remove any group requirements that removed in the UI
var selectedGroupRequirements = GroupRequirementsState.Select( a => a.Guid );
foreach ( var groupRequirement in group.GroupRequirements.Where( a => !selectedGroupRequirements.Contains( a.Guid ) ).ToList() )
{
group.GroupRequirements.Remove( groupRequirement );
groupRequirementService.Delete( groupRequirement );
}
// Remove any triggers that were removed in the UI
var selectedTriggerGuids = MemberWorkflowTriggersState.Select( r => r.Guid );
foreach ( var trigger in group.GroupMemberWorkflowTriggers.Where( r => !selectedTriggerGuids.Contains( r.Guid ) ).ToList() )
{
group.GroupMemberWorkflowTriggers.Remove( trigger );
groupMemberWorkflowTriggerService.Delete( trigger );
triggersUpdated = true;
}
}
// add/update any group requirements that were added or changed in the UI (we already removed the ones that were removed above)
foreach ( var groupRequirementState in GroupRequirementsState )
{
GroupRequirement groupRequirement = group.GroupRequirements.Where( a => a.Guid == groupRequirementState.Guid ).FirstOrDefault();
if ( groupRequirement == null )
{
groupRequirement = new GroupRequirement();
group.GroupRequirements.Add( groupRequirement );
}
groupRequirement.CopyPropertiesFrom( groupRequirementState );
}
// add/update any group locations that were added or changed in the UI (we already removed the ones that were removed above)
foreach ( var groupLocationState in GroupLocationsState )
{
GroupLocation groupLocation = group.GroupLocations.Where( l => l.Guid == groupLocationState.Guid ).FirstOrDefault();
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
group.GroupLocations.Add( groupLocation );
}
else
{
groupLocationState.Id = groupLocation.Id;
groupLocationState.Guid = groupLocation.Guid;
var selectedSchedules = groupLocationState.Schedules.Select( s => s.Guid ).ToList();
foreach ( var schedule in groupLocation.Schedules.Where( s => !selectedSchedules.Contains( s.Guid ) ).ToList() )
{
groupLocation.Schedules.Remove( schedule );
}
}
groupLocation.CopyPropertiesFrom( groupLocationState );
var existingSchedules = groupLocation.Schedules.Select( s => s.Guid ).ToList();
foreach ( var scheduleState in groupLocationState.Schedules.Where( s => !existingSchedules.Contains( s.Guid ) ).ToList() )
{
var schedule = scheduleService.Get( scheduleState.Guid );
if ( schedule != null )
{
groupLocation.Schedules.Add( schedule );
}
}
}
foreach ( var triggerState in MemberWorkflowTriggersState )
{
GroupMemberWorkflowTrigger trigger = group.GroupMemberWorkflowTriggers.Where( r => r.Guid == triggerState.Guid ).FirstOrDefault();
if ( trigger == null )
{
trigger = new GroupMemberWorkflowTrigger();
group.GroupMemberWorkflowTriggers.Add( trigger );
}
else
{
triggerState.Id = trigger.Id;
triggerState.Guid = trigger.Guid;
}
trigger.CopyPropertiesFrom( triggerState );
triggersUpdated = true;
}
group.Name = tbName.Text;
group.Description = tbDescription.Text;
group.CampusId = ddlCampus.SelectedValueAsInt();
group.GroupTypeId = CurrentGroupTypeId;
group.ParentGroupId = gpParentGroup.SelectedValueAsInt();
group.GroupCapacity = nbGroupCapacity.Text.AsIntegerOrNull();
group.RequiredSignatureDocumentTemplateId = ddlSignatureDocumentTemplate.SelectedValueAsInt();
group.IsSecurityRole = cbIsSecurityRole.Checked;
group.IsActive = cbIsActive.Checked;
group.IsPublic = cbIsPublic.Checked;
group.MustMeetRequirementsToAddMember = cbMembersMustMeetRequirementsOnAdd.Checked;
// save sync settings
group.SyncDataViewId = dvpSyncDataview.SelectedValue.AsIntegerOrNull();
group.WelcomeSystemEmailId = ddlWelcomeEmail.SelectedValue.AsIntegerOrNull();
group.ExitSystemEmailId = ddlExitEmail.SelectedValue.AsIntegerOrNull();
group.AddUserAccountsDuringSync = rbCreateLoginDuringSync.Checked;
string iCalendarContent = string.Empty;
// If unique schedule option was selected, but a schedule was not defined, set option to 'None'
var scheduleType = rblScheduleSelect.SelectedValueAsEnum<ScheduleType>( ScheduleType.None );
if ( scheduleType == ScheduleType.Custom )
{
iCalendarContent = sbSchedule.iCalendarContent;
var calEvent = ScheduleICalHelper.GetCalenderEvent( iCalendarContent );
if ( calEvent == null || calEvent.DTStart == null )
{
scheduleType = ScheduleType.None;
}
}
if ( scheduleType == ScheduleType.Weekly )
{
if ( !dowWeekly.SelectedDayOfWeek.HasValue )
{
scheduleType = ScheduleType.None;
}
}
int? oldScheduleId = hfUniqueScheduleId.Value.AsIntegerOrNull();
if ( scheduleType == ScheduleType.Custom || scheduleType == ScheduleType.Weekly )
{
if ( !oldScheduleId.HasValue || group.Schedule == null )
{
group.Schedule = new Schedule();
}
if ( scheduleType == ScheduleType.Custom )
{
group.Schedule.iCalendarContent = iCalendarContent;
group.Schedule.WeeklyDayOfWeek = null;
group.Schedule.WeeklyTimeOfDay = null;
}
else
{
group.Schedule.iCalendarContent = null;
group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek;
group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime;
}
}
else
{
// If group did have a unique schedule, delete that schedule
if ( oldScheduleId.HasValue )
{
var schedule = scheduleService.Get( oldScheduleId.Value );
if ( schedule != null && string.IsNullOrEmpty( schedule.Name ) )
{
// Make sure this is the only group trying to use this schedule.
if ( !groupService.Queryable().Where( g => g.ScheduleId == schedule.Id && g.Id != group.Id ).Any() )
{
scheduleService.Delete( schedule );
}
}
}
if ( scheduleType == ScheduleType.Named )
{
group.ScheduleId = spSchedule.SelectedValueAsId();
}
else
{
group.ScheduleId = null;
}
}
if ( group.ParentGroupId == group.Id )
{
gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." );
return;
}
group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group );
group.GroupType = new GroupTypeService( rockContext ).Get( group.GroupTypeId );
if ( group.ParentGroupId.HasValue )
{
group.ParentGroup = groupService.Get( group.ParentGroupId.Value );
}
// Check to see if group type is allowed as a child of new parent group.
if ( group.ParentGroup != null )
{
var allowedGroupTypeIds = GetAllowedGroupTypes( group.ParentGroup, rockContext ).Select( t => t.Id ).ToList();
if ( !allowedGroupTypeIds.Contains( group.GroupTypeId ) )
{
var groupType = CurrentGroupTypeCache;
nbInvalidParentGroup.Text = string.Format( "The '{0}' group does not allow child groups with a '{1}' group type.", group.ParentGroup.Name, groupType != null ? groupType.Name : string.Empty );
nbInvalidParentGroup.Visible = true;
return;
}
}
// Check to see if user is still allowed to edit with selected group type and parent group
if ( !group.IsAuthorized( Authorization.EDIT, CurrentPerson ) )
{
nbNotAllowedToEdit.Visible = true;
return;
}
if ( !Page.IsValid )
{
return;
}
// if the groupMember IsValid is false, and the UI controls didn't report any errors, it is probably because the custom rules of GroupMember didn't pass.
// So, make sure a message is displayed in the validation summary
cvGroup.IsValid = group.IsValid;
if ( !cvGroup.IsValid )
{
cvGroup.ErrorMessage = group.ValidationResults.Select( a => a.ErrorMessage ).ToList().AsDelimited( "<br />" );
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
var adding = group.Id.Equals( 0 );
if ( adding )
{
groupService.Add( group );
}
rockContext.SaveChanges();
if ( adding )
{
// add ADMINISTRATE to the person who added the group
Rock.Security.Authorization.AllowPerson( group, Authorization.ADMINISTRATE, this.CurrentPerson, rockContext );
}
group.SaveAttributeValues( rockContext );
/* Take care of Group Member Attributes */
var entityTypeId = EntityTypeCache.Read( typeof( GroupMember ) ).Id;
string qualifierColumn = "GroupId";
string qualifierValue = group.Id.ToString();
// Get the existing attributes for this entity type and qualifier value
var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue );
// Delete any of those attributes that were removed in the UI
var selectedAttributeGuids = GroupMemberAttributesState.Select( a => a.Guid );
foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) )
{
Rock.Web.Cache.AttributeCache.Flush( attr.Id );
attributeService.Delete( attr );
}
// Update the Attributes that were assigned in the UI
foreach ( var attributeState in GroupMemberAttributesState )
{
Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext );
}
rockContext.SaveChanges();
if ( group.IsActive == false && cbInactivateChildGroups.Checked )
{
var allActiveChildGroupsId = groupService.GetAllDescendents( group.Id ).Where( a => a.IsActive ).Select( a => a.Id ).ToList();
var allActiveChildGroups = groupService.GetByIds( allActiveChildGroupsId );
foreach ( var childGroup in allActiveChildGroups )
{
if ( childGroup.IsActive )
{
childGroup.IsActive = false;
}
}
rockContext.SaveChanges();
}
} );
bool isNowSecurityRole = group.IsActive && ( group.IsSecurityRole || group.GroupTypeId == roleGroupTypeId );
if ( group != null && wasSecurityRole )
{
if ( !isNowSecurityRole )
{
// if this group was a SecurityRole, but no longer is, flush
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
else
{
if ( isNowSecurityRole )
{
// new security role, flush
Rock.Security.Authorization.Flush();
}
}
AttributeCache.FlushEntityAttributes();
if ( triggersUpdated )
{
GroupMemberWorkflowTriggerService.FlushCachedTriggers();
}
var qryParams = new Dictionary<string, string>();
qryParams["GroupId"] = group.Id.ToString();
qryParams["ExpandedIds"] = PageParameter( "ExpandedIds" );
NavigateToPage( RockPage.Guid, qryParams );
}
/// <summary>
/// Handles the SelectItem event of the gp control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void gp_SelectItem( object sender, EventArgs e )
{
var rockContext = new RockContext();
int groupId = gp.SelectedValueAsId() ?? 0;
var groupService = new GroupService( rockContext );
var group = groupService.Get( groupId );
if ( group != null )
{
var groupTypeRoleService = new GroupTypeRoleService( rockContext );
var qryGroupTypeRoles = groupTypeRoleService.Queryable();
if ( cbChildGroups.Checked )
{
var childGroupTypeIds = groupService.GetAllDescendents( group.Id ).Select( a => a.GroupTypeId ).Distinct().ToList();
qryGroupTypeRoles = qryGroupTypeRoles.Where( a => a.GroupTypeId.HasValue && ( a.GroupTypeId == group.GroupTypeId || childGroupTypeIds.Contains( a.GroupTypeId.Value ) ) );
}
else
{
qryGroupTypeRoles = qryGroupTypeRoles.Where( a => a.GroupTypeId.HasValue && a.GroupTypeId == group.GroupTypeId );
}
var list = qryGroupTypeRoles.OrderBy( a => a.GroupType.Order ).ThenBy( a => a.GroupType.Name ).ThenBy( a => a.Order ).ThenBy( a => a.Name ).ToList();
cblRole.Items.Clear();
foreach ( var item in list )
{
cblRole.Items.Add( new ListItem( string.Format( "{0} ({1})", item.Name, item.GroupType.Name ), item.Guid.ToString() ) );
}
cblRole.Visible = list.Count > 0;
cbChildGroups.Visible = true;
}
else
{
cblRole.Visible = false;
cbChildGroups.Visible = false;
}
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
{
string[] selectionValues = selection.Split( '|' );
if ( selectionValues.Length >= 2 )
{
GroupMemberService groupMemberService = new GroupMemberService( (RockContext)serviceInstance.Context );
int groupId = 0;
Guid groupGuid = selectionValues[0].AsGuid();
var groupService = new GroupService( (RockContext)serviceInstance.Context );
var group = groupService.Get( groupGuid );
if ( group != null )
{
groupId = group.Id;
}
bool includeChildGroups = false;
if ( selectionValues.Length >= 3 )
{
includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false;
}
var groupMemberServiceQry = groupMemberService.Queryable();
if ( includeChildGroups )
{
var childGroupIds = groupService.GetAllDescendents( group.Id ).Select( a => a.Id ).Distinct().ToList();
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.GroupId == groupId || childGroupIds.Contains( xx.GroupId ) );
}
else
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.GroupId == groupId );
}
var groupRoleGuids = selectionValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( n => n.AsGuid() ).ToList();
if ( groupRoleGuids.Count() > 0 )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupRoleGuids.Contains( xx.GroupRole.Guid ) );
}
var qry = new PersonService( (RockContext)serviceInstance.Context ).Queryable()
.Where( p => groupMemberServiceQry.Any( xx => xx.PersonId == p.Id ) );
Expression extractedFilterExpression = FilterExpressionExtractor.Extract<Rock.Model.Person>( qry, parameterExpression, "p" );
return extractedFilterExpression;
}
return null;
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection )
{
string[] selectionValues = selection.Split( '|' );
if ( selectionValues.Length >= 2 )
{
GroupMemberService groupMemberService = new GroupMemberService( (RockContext)serviceInstance.Context );
List<Guid> groupGuids = selectionValues[0].Split( ',' ).AsGuidList();
var groupService = new GroupService( (RockContext)serviceInstance.Context );
var groupIds = groupService.GetByGuids( groupGuids ).Select( a => a.Id ).Distinct().ToList();
bool includeChildGroups = false;
bool includeChildGroupsIncludeSelected = false;
bool includeChildGroupsPlusDescendants = false;
if ( selectionValues.Length >= 3 )
{
includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false;
}
if ( selectionValues.Length >= 6 )
{
includeChildGroupsIncludeSelected = selectionValues[4].AsBooleanOrNull() ?? false;
includeChildGroupsPlusDescendants = selectionValues[5].AsBooleanOrNull() ?? false;
}
else if ( includeChildGroups )
{
// in case the selection was saved before these options where added
includeChildGroupsIncludeSelected = true;
includeChildGroupsPlusDescendants = true;
}
GroupMemberStatus? groupMemberStatus = null;
if ( selectionValues.Length >= 4 )
{
groupMemberStatus = selectionValues[3].ConvertToEnumOrNull<GroupMemberStatus>();
}
var groupMemberServiceQry = groupMemberService.Queryable();
if ( includeChildGroups )
{
List<int> childGroupIds = new List<int>();
foreach ( var groupId in groupIds )
{
if ( includeChildGroupsPlusDescendants )
{
// get all children and descendants of the selected group(s)
childGroupIds.AddRange( groupService.GetAllDescendents( groupId ).Select( a => a.Id ).Distinct().ToList() );
}
else
{
// get only immediate children of the selected group(s)
childGroupIds.AddRange( groupService.Queryable().Where( a => a.ParentGroupId == groupId ).Select( a => a.Id ) );
}
}
if ( includeChildGroupsIncludeSelected )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupIds.Contains( xx.GroupId ) || childGroupIds.Contains( xx.GroupId ) );
}
else
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => childGroupIds.Contains( xx.GroupId ) );
}
}
else
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupIds.Contains( xx.GroupId ) );
}
if ( groupMemberStatus.HasValue )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => xx.GroupMemberStatus == groupMemberStatus.Value );
}
var groupRoleGuids = selectionValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( n => n.AsGuid() ).ToList();
if ( groupRoleGuids.Count() > 0 )
{
groupMemberServiceQry = groupMemberServiceQry.Where( xx => groupRoleGuids.Contains( xx.GroupRole.Guid ) );
}
var qry = new PersonService( (RockContext)serviceInstance.Context ).Queryable()
.Where( p => groupMemberServiceQry.Any( xx => xx.PersonId == p.Id ) );
Expression extractedFilterExpression = FilterExpressionExtractor.Extract<Rock.Model.Person>( qry, parameterExpression, "p" );
return extractedFilterExpression;
}
return null;
}
/// <summary>
/// Loads the groups.
/// </summary>
private void LoadDropDowns()
{
var parts = ( GetAttributeValue( "GroupFilter" ) ?? string.Empty ).Split( '|' );
Guid? groupTypeGuid = null;
Guid? rootGroupGuid = null;
if ( parts.Length >= 1 )
{
groupTypeGuid = parts[0].AsGuidOrNull();
if ( parts.Length >= 2 )
{
rootGroupGuid = parts[1].AsGuidOrNull();
}
}
var groupEntityType = EntityTypeCache.Read( "Rock.Model.Group" );
var defaultGroup = RockPage.GetCurrentContext( groupEntityType ) as Group;
var groupService = new GroupService( new RockContext() );
IQueryable<Group> qryGroups = null;
// if rootGroup is set, use that as the filter. Otherwise, use GroupType as the filter
if ( rootGroupGuid.HasValue )
{
var rootGroup = groupService.Get( rootGroupGuid.Value );
if ( rootGroup != null )
{
qryGroups = groupService.GetAllDescendents( rootGroup.Id ).AsQueryable();
}
}
else if ( groupTypeGuid.HasValue )
{
qryGroups = groupService.Queryable().Where( a => a.GroupType.Guid == groupTypeGuid.Value );
}
if ( qryGroups == null )
{
nbSelectGroupTypeWarning.Visible = true;
lCurrentSelection.Text = string.Empty;
rptGroups.Visible = false;
}
else
{
nbSelectGroupTypeWarning.Visible = false;
rptGroups.Visible = true;
lCurrentSelection.Text = defaultGroup != null ? defaultGroup.ToString() : "Select Group";
var groups = qryGroups.OrderBy( a => a.Order ).ThenBy( a => a.Name ).ToList().Select( a => new { a.Name, a.Id } ).ToList();
rptGroups.DataSource = groups;
rptGroups.DataBind();
}
}
/// <summary>
/// Loads the groups.
/// </summary>
private void LoadDropDowns()
{
var parts = ( GetAttributeValue( "GroupFilter" ) ?? string.Empty ).Split( '|' );
Guid? groupTypeGuid = null;
Guid? rootGroupGuid = null;
if ( parts.Length >= 1 )
{
groupTypeGuid = parts[0].AsGuidOrNull();
if ( parts.Length >= 2 )
{
rootGroupGuid = parts[1].AsGuidOrNull();
}
}
var groupService = new GroupService( new RockContext() );
string defaultGroupPublicKey = string.Empty;
var contextCookie = Request.Cookies["Rock:context"];
if ( contextCookie != null )
{
var cookieValue = contextCookie.Values[typeof( Rock.Model.Group ).FullName];
string contextItem = Rock.Security.Encryption.DecryptString( cookieValue );
string[] contextItemParts = contextItem.Split( '|' );
if ( contextItemParts.Length == 2 )
{
defaultGroupPublicKey = contextItemParts[1];
}
}
var defaultGroup = groupService.GetByPublicKey( defaultGroupPublicKey );
IQueryable<Group> qryGroups = null;
// if rootGroup is set, use that as the filter. Otherwise, use GroupType as the filter
if ( rootGroupGuid.HasValue )
{
var rootGroup = groupService.Get( rootGroupGuid.Value );
if ( rootGroup != null )
{
qryGroups = groupService.GetAllDescendents( rootGroup.Id ).AsQueryable();
}
}
else if ( groupTypeGuid.HasValue )
{
qryGroups = groupService.Queryable().Where( a => a.GroupType.Guid == groupTypeGuid.Value );
}
if ( qryGroups == null )
{
nbSelectGroupTypeWarning.Visible = true;
ddlGroup.Visible = false;
}
else
{
nbSelectGroupTypeWarning.Visible = false;
ddlGroup.Visible = true;
ddlGroup.Items.Clear();
var groups = qryGroups.OrderBy( a => a.Order ).ThenBy( a => a.Name ).ToList();
foreach ( var group in groups )
{
var listItem = new ListItem( group.Name, HttpUtility.UrlDecode( group.ContextKey ) );
if ( defaultGroup != null )
{
listItem.Selected = group.Guid == defaultGroup.Guid;
}
ddlGroup.Items.Add( listItem );
}
}
}
