/// <summary>
/// Updates the group members active status from the group's active status.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="originalIsActive">if set to <c>true</c> [old active status].</param>
/// <param name="originalInactiveDateTime">The old inactive date time.</param>
/// <param name="newActiveStatus">if set to <c>true</c> [new active status].</param>
/// <param name="newInactiveDateTime">The new inactive date time.</param>
private void UpdateGroupMembersActiveStatusFromGroupStatus(RockContext rockContext, bool originalIsActive, DateTime?originalInactiveDateTime, bool newActiveStatus, DateTime?newInactiveDateTime)
{
if (originalIsActive == newActiveStatus || Entity.Id == 0)
{
// only change GroupMember status if the Group's status was changed
return;
}
var groupMemberQuery = new GroupMemberService(rockContext).Queryable().Where(a => a.GroupId == Entity.Id);
if (newActiveStatus == false)
{
// group was changed to from Active to Inactive, so change all Active/Pending GroupMembers to Inactive and stamp their inactivate DateTime to be the same as the group's inactive DateTime.
foreach (var groupMember in groupMemberQuery.Where(a => a.GroupMemberStatus != GroupMemberStatus.Inactive).ToList())
{
groupMember.GroupMemberStatus = GroupMemberStatus.Inactive;
groupMember.InactiveDateTime = newInactiveDateTime;
}
}
else if (originalInactiveDateTime.HasValue)
{
// group was changed to from Inactive to Active, so change all Inactive GroupMembers to Active if their InactiveDateTime is within 24 hours of the Group's InactiveDateTime
foreach (var groupMember in groupMemberQuery.Where(a => a.GroupMemberStatus == GroupMemberStatus.Inactive && a.InactiveDateTime.HasValue && Math.Abs(SqlFunctions.DateDiff("hour", a.InactiveDateTime.Value, originalInactiveDateTime.Value).Value) < 24).ToList())
{
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
groupMember.InactiveDateTime = newInactiveDateTime;
}
}
}
/// <summary>
/// Updates the group members IsArchived value from the group's IsArchived value.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="originalIsArchived">if set to <c>true</c> [original is archived].</param>
/// <param name="originalArchivedDateTime">The original archived date time.</param>
/// <param name="newIsArchived">if set to <c>true</c> [new is archived].</param>
/// <param name="newArchivedDateTime">The new archived date time.</param>
private void UpdateGroupMembersArchivedValueFromGroupArchivedValue(RockContext rockContext, bool originalIsArchived, DateTime?originalArchivedDateTime, bool newIsArchived, DateTime?newArchivedDateTime)
{
if (originalIsArchived == newIsArchived || Entity.Id == 0)
{
// only change GroupMember archived value if the Group's archived value was changed
return;
}
// IMPORTANT: When dealing with Archived Groups or GroupMembers, we always need to get
// a query without the "filter" (AsNoFilter) that comes from the GroupConfiguration and/or
// GroupMemberConfiguration because otherwise the query will not include archived items.
var groupMemberQuery = new GroupMemberService(rockContext).AsNoFilter().Where(a => a.GroupId == Entity.Id);
if (newIsArchived)
{
// group IsArchived was changed from false to true, so change all archived GroupMember's IsArchived to true and stamp their IsArchivedDateTime to be the same as the group's IsArchivedDateTime.
foreach (var groupMember in groupMemberQuery.Where(a => a.IsArchived == false).ToList())
{
groupMember.IsArchived = true;
groupMember.ArchivedDateTime = newArchivedDateTime;
}
}
else if (originalArchivedDateTime.HasValue)
{
// group IsArchived was changed from true to false, so change all archived GroupMember's IsArchived if their ArchivedDateTime is within 24 hours of the Group's ArchivedDateTime
foreach (var groupMember in groupMemberQuery.Where(a => a.IsArchived == true && a.ArchivedDateTime.HasValue && Math.Abs(SqlFunctions.DateDiff("hour", a.ArchivedDateTime.Value, originalArchivedDateTime.Value).Value) < 24).ToList())
{
groupMember.IsArchived = false;
groupMember.ArchivedDateTime = newArchivedDateTime;
}
}
}
/// <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;
}
private IQueryable<RelatedPersonInfo> GetRelatedPeopleQuery( RockContext context, IEnumerable<int> groupTypeIds, IEnumerable<Guid> principalRoleGuids, IEnumerable<Guid> targetRoleGuids,
string relationshipName = "*" )
{
var relationshipGroupMembersQuery = new GroupMemberService( context ).Queryable();
relationshipGroupMembersQuery = relationshipGroupMembersQuery.Where( x => groupTypeIds.Contains( x.Group.GroupTypeId ) );
var relatedPeopleQuery = new PersonService( context ).Queryable()
.SelectMany( p => relationshipGroupMembersQuery.Where( gm => gm.PersonId == p.Id && principalRoleGuids.Contains( gm.GroupRole.Guid ) )
.SelectMany( gm => gm.Group.Members )
.Where( gm => targetRoleGuids.Contains( gm.GroupRole.Guid ) && gm.PersonId != p.Id )
.OrderBy( gm => gm.GroupRole.Order )
.ThenBy( gm => gm.Person.BirthDate )
.ThenBy( gm => gm.Person.Gender )
.Select(
gm =>
new RelatedPersonInfo
{
RelatedToPersonId = p.Id,
PersonId = gm.Person.Id,
FirstName = gm.Person.FirstName,
LastName = gm.Person.LastName,
Suffix = gm.Person.SuffixValue.Value,
RelationshipName =
( relationshipName == "*"
? gm.GroupRole.Name
: relationshipName )
} ) );
return relatedPeopleQuery;
}
/// <summary>
/// Handles the Click event of the btnConfirm 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 btnConfirm_Click( object sender, EventArgs e )
{
if ( Page.IsValid )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var ids = Individuals.Select( i => i.PersonId ).ToList();
#region Individual Details Updates
int? newTitleId = ddlTitle.SelectedValueAsInt();
int? newSuffixId = ddlSuffix.SelectedValueAsInt();
int? newConnectionStatusId = ddlStatus.SelectedValueAsInt();
int? newRecordStatusId = ddlRecordStatus.SelectedValueAsInt();
int? newInactiveReasonId = ddlInactiveReason.SelectedValueAsInt();
string newInactiveReasonNote = tbInactiveReasonNote.Text;
Gender newGender = ddlGender.SelectedValue.ConvertToEnum<Gender>();
int? newMaritalStatusId = ddlMaritalStatus.SelectedValueAsInt();
int? newGraduationYear = null;
if ( ypGraduation.SelectedYear.HasValue )
{
newGraduationYear = ypGraduation.SelectedYear.Value;
}
int? newCampusId = cpCampus.SelectedCampusId;
bool? newEmailActive = null;
if ( !string.IsNullOrWhiteSpace( ddlIsEmailActive.SelectedValue ) )
{
newEmailActive = ddlIsEmailActive.SelectedValue == "Active";
}
EmailPreference? newEmailPreference = ddlEmailPreference.SelectedValue.ConvertToEnumOrNull<EmailPreference>();
string newEmailNote = tbEmailNote.Text;
int? newReviewReason = ddlReviewReason.SelectedValueAsInt();
string newSystemNote = tbSystemNote.Text;
string newReviewReasonNote = tbReviewReasonNote.Text;
int inactiveStatusId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ).Id;
var allChanges = new Dictionary<int, List<string>>();
var people = personService.Queryable().Where( p => ids.Contains( p.Id ) ).ToList();
foreach ( var person in people )
{
var changes = new List<string>();
allChanges.Add( person.Id, changes );
if ( SelectedFields.Contains( ddlTitle.ClientID ) )
{
History.EvaluateChange( changes, "Title", DefinedValueCache.GetName( person.TitleValueId ), DefinedValueCache.GetName( newTitleId ) );
person.TitleValueId = newTitleId;
}
if ( SelectedFields.Contains( ddlSuffix.ClientID ) )
{
History.EvaluateChange( changes, "Suffix", DefinedValueCache.GetName( person.SuffixValueId ), DefinedValueCache.GetName( newSuffixId ) );
person.SuffixValueId = newSuffixId;
}
if ( SelectedFields.Contains( ddlStatus.ClientID ) )
{
History.EvaluateChange( changes, "Connection Status", DefinedValueCache.GetName( person.ConnectionStatusValueId ), DefinedValueCache.GetName( newConnectionStatusId ) );
person.ConnectionStatusValueId = newConnectionStatusId;
}
if ( SelectedFields.Contains( ddlRecordStatus.ClientID ) )
{
History.EvaluateChange( changes, "Record Status", DefinedValueCache.GetName( person.RecordStatusValueId ), DefinedValueCache.GetName( newRecordStatusId ) );
person.RecordStatusValueId = newRecordStatusId;
if ( newRecordStatusId.HasValue && newRecordStatusId.Value == inactiveStatusId )
{
History.EvaluateChange( changes, "Inactive Reason", DefinedValueCache.GetName( person.RecordStatusReasonValueId ), DefinedValueCache.GetName( newInactiveReasonId ) );
person.RecordStatusReasonValueId = newInactiveReasonId;
if ( !string.IsNullOrWhiteSpace( newInactiveReasonNote ) )
{
History.EvaluateChange( changes, "Inactive Reason Note", person.InactiveReasonNote, newInactiveReasonNote );
person.InactiveReasonNote = newInactiveReasonNote;
}
}
}
if ( SelectedFields.Contains( ddlGender.ClientID ) )
{
History.EvaluateChange( changes, "Gender", person.Gender, newGender );
person.Gender = newGender;
}
if ( SelectedFields.Contains( ddlMaritalStatus.ClientID ) )
{
History.EvaluateChange( changes, "Marital Status", DefinedValueCache.GetName( person.MaritalStatusValueId ), DefinedValueCache.GetName( newMaritalStatusId ) );
person.MaritalStatusValueId = newMaritalStatusId;
}
if ( SelectedFields.Contains( ddlGradePicker.ClientID ) )
{
History.EvaluateChange( changes, "Graduation Year", person.GraduationYear, newGraduationYear );
person.GraduationYear = newGraduationYear;
}
if ( SelectedFields.Contains( ddlIsEmailActive.ClientID ) )
{
History.EvaluateChange( changes, "Email Is Active", person.IsEmailActive ?? true, newEmailActive.Value );
person.IsEmailActive = newEmailActive;
}
if ( SelectedFields.Contains( ddlEmailPreference.ClientID ) )
{
History.EvaluateChange( changes, "Email Preference", person.EmailPreference, newEmailPreference );
person.EmailPreference = newEmailPreference.Value;
}
if ( SelectedFields.Contains( tbEmailNote.ClientID ) )
{
History.EvaluateChange( changes, "Email Note", person.EmailNote, newEmailNote );
person.EmailNote = newEmailNote;
}
if ( SelectedFields.Contains( tbSystemNote.ClientID ) )
{
History.EvaluateChange( changes, "System Note", person.SystemNote, newSystemNote );
person.SystemNote = newSystemNote;
}
if ( SelectedFields.Contains( ddlReviewReason.ClientID ) )
{
History.EvaluateChange( changes, "Review Reason", DefinedValueCache.GetName( person.ReviewReasonValueId ), DefinedValueCache.GetName( newReviewReason ) );
person.ReviewReasonValueId = newReviewReason;
}
if ( SelectedFields.Contains( tbReviewReasonNote.ClientID ) )
{
History.EvaluateChange( changes, "Review Reason Note", person.ReviewReasonNote, newReviewReasonNote );
person.ReviewReasonNote = newReviewReasonNote;
}
}
if ( SelectedFields.Contains( cpCampus.ClientID ) && cpCampus.SelectedCampusId.HasValue )
{
int campusId = cpCampus.SelectedCampusId.Value;
Guid familyGuid = new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
var familyMembers = new GroupMemberService( rockContext ).Queryable()
.Where( m => ids.Contains( m.PersonId ) && m.Group.GroupType.Guid == familyGuid )
.Select( m => new { m.PersonId, m.GroupId } )
.Distinct()
.ToList();
var families = new GroupMemberService( rockContext ).Queryable()
.Where( m => ids.Contains( m.PersonId ) && m.Group.GroupType.Guid == familyGuid )
.Select( m => m.Group )
.Distinct()
.ToList();
foreach ( int personId in ids )
{
var familyIds = familyMembers.Where( m => m.PersonId == personId ).Select( m => m.GroupId ).ToList();
if ( familyIds.Count == 1 )
{
int familyId = familyIds.FirstOrDefault();
var family = families.Where( g => g.Id == familyId ).FirstOrDefault();
{
if ( family != null )
{
family.CampusId = campusId;
}
familyMembers.RemoveAll( m => m.GroupId == familyId );
}
}
}
rockContext.SaveChanges();
}
// Update following
if ( SelectedFields.Contains( ddlFollow.ClientID ) )
{
var personAliasEntityType = EntityTypeCache.Read( "Rock.Model.PersonAlias" );
if ( personAliasEntityType != null )
{
int personAliasEntityTypeId = personAliasEntityType.Id;
bool follow = true;
if ( !string.IsNullOrWhiteSpace( ddlFollow.SelectedValue ) )
{
follow = ddlFollow.SelectedValue == "Add";
}
var personAliasService = new PersonAliasService( rockContext );
var followingService = new FollowingService( rockContext );
if ( follow )
{
var paQry = personAliasService.Queryable();
var alreadyFollowingIds = followingService.Queryable()
.Where( f =>
f.EntityTypeId == personAliasEntityTypeId &&
f.PersonAlias.Id == CurrentPersonAlias.Id )
.Join( paQry, f => f.EntityId, p => p.Id, ( f, p ) => new { PersonAlias = p } )
.Select( p => p.PersonAlias.PersonId )
.Distinct()
.ToList();
foreach ( int id in ids.Where( id => !alreadyFollowingIds.Contains( id ) ) )
{
var following = new Following
{
EntityTypeId = personAliasEntityTypeId,
EntityId = ( people.FirstOrDefault( p => p.Id == id ).PrimaryAliasId ) ?? 0,
PersonAliasId = CurrentPersonAlias.Id
};
followingService.Add( following );
}
}
else
{
var paQry = personAliasService.Queryable()
.Where( p => ids.Contains( p.PersonId ) )
.Select( p => p.Id );
foreach ( var following in followingService.Queryable()
.Where( f =>
f.EntityTypeId == personAliasEntityTypeId &&
paQry.Contains( f.EntityId ) &&
f.PersonAlias.Id == CurrentPersonAlias.Id ) )
{
followingService.Delete( following );
}
}
}
}
rockContext.SaveChanges();
#endregion
#region Attributes
var selectedCategories = new List<CategoryCache>();
foreach ( string categoryGuid in GetAttributeValue( "AttributeCategories" ).SplitDelimitedValues() )
{
var category = CategoryCache.Read( categoryGuid.AsGuid(), rockContext );
if ( category != null )
{
selectedCategories.Add( category );
}
}
var attributes = new List<AttributeCache>();
var attributeValues = new Dictionary<int, string>();
int categoryIndex = 0;
foreach ( var category in selectedCategories.OrderBy( c => c.Name ) )
{
PanelWidget pw = null;
string controlId = "pwAttributes_" + category.Id.ToString();
if ( categoryIndex % 2 == 0 )
{
pw = phAttributesCol1.FindControl( controlId ) as PanelWidget;
}
else
{
pw = phAttributesCol2.FindControl( controlId ) as PanelWidget;
}
categoryIndex++;
if ( pw != null )
{
var orderedAttributeList = new AttributeService( rockContext ).GetByCategoryId( category.Id )
.OrderBy( a => a.Order ).ThenBy( a => a.Name );
foreach ( var attribute in orderedAttributeList )
{
if ( attribute.IsAuthorized( Authorization.EDIT, CurrentPerson ) )
{
var attributeCache = AttributeCache.Read( attribute.Id );
Control attributeControl = pw.FindControl( string.Format( "attribute_field_{0}", attribute.Id ) );
if ( attributeControl != null && SelectedFields.Contains( attributeControl.ClientID ) )
{
string newValue = attributeCache.FieldType.Field.GetEditValue( attributeControl, attributeCache.QualifierValues );
attributes.Add( attributeCache );
attributeValues.Add( attributeCache.Id, newValue );
}
}
}
}
}
if ( attributes.Any() )
{
foreach ( var person in people )
{
person.LoadAttributes();
foreach ( var attribute in attributes )
{
string originalValue = person.GetAttributeValue( attribute.Key );
string newValue = attributeValues[attribute.Id];
if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() )
{
Rock.Attribute.Helper.SaveAttributeValue( person, attribute, newValue, rockContext );
string formattedOriginalValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( originalValue ) )
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false );
}
string formattedNewValue = string.Empty;
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false );
}
History.EvaluateChange( allChanges[person.Id], attribute.Name, formattedOriginalValue, formattedNewValue );
}
}
}
}
// Create the history records
foreach ( var changes in allChanges )
{
if ( changes.Value.Any() )
{
HistoryService.AddChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
changes.Key, changes.Value );
}
}
rockContext.SaveChanges();
#endregion
#region Add Note
if ( !string.IsNullOrWhiteSpace( tbNote.Text ) && CurrentPerson != null )
{
string text = tbNote.Text;
bool isAlert = cbIsAlert.Checked;
bool isPrivate = cbIsPrivate.Checked;
var noteTypeService = new NoteTypeService( rockContext );
var noteType = noteTypeService.Get( Rock.SystemGuid.NoteType.PERSON_TIMELINE.AsGuid() );
if ( noteType != null )
{
var notes = new List<Note>();
var noteService = new NoteService( rockContext );
foreach ( int id in ids )
{
var note = new Note();
note.IsSystem = false;
note.EntityId = id;
note.Caption = isPrivate ? "You - Personal Note" : string.Empty;
note.Text = tbNote.Text;
note.IsAlert = cbIsAlert.Checked;
note.NoteType = noteType;
notes.Add( note );
noteService.Add( note );
}
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
foreach ( var note in notes )
{
note.AllowPerson( Authorization.EDIT, CurrentPerson, rockContext );
if ( isPrivate )
{
note.MakePrivate( Authorization.VIEW, CurrentPerson, rockContext );
}
}
} );
}
}
#endregion
#region Group
int? groupId = gpGroup.SelectedValue.AsIntegerOrNull();
if ( groupId.HasValue )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
if ( group != null )
{
var groupMemberService = new GroupMemberService( rockContext );
var existingMembers = groupMemberService.Queryable( "Group" )
.Where( m =>
m.GroupId == group.Id &&
ids.Contains( m.PersonId ) )
.ToList();
string action = ddlGroupAction.SelectedValue;
if ( action == "Remove" )
{
groupMemberService.DeleteRange( existingMembers );
rockContext.SaveChanges();
}
else
{
var roleId = ddlGroupRole.SelectedValueAsInt();
var status = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>();
// Get the attribute values updated
var gm = new GroupMember();
gm.Group = group;
gm.GroupId = group.Id;
gm.LoadAttributes( rockContext );
var selectedGroupAttributes = new List<AttributeCache>();
var selectedGroupAttributeValues = new Dictionary<string, string>();
foreach ( var attributeCache in gm.Attributes.Select( a => a.Value ) )
{
Control attributeControl = phAttributes.FindControl( string.Format( "attribute_field_{0}", attributeCache.Id ) );
if ( attributeControl != null && ( action == "Add" || SelectedFields.Contains( attributeControl.ClientID ) ) )
{
string newValue = attributeCache.FieldType.Field.GetEditValue( attributeControl, attributeCache.QualifierValues );
selectedGroupAttributes.Add( attributeCache );
selectedGroupAttributeValues.Add( attributeCache.Key, newValue );
}
}
if ( action == "Add" )
{
if ( roleId.HasValue )
{
var newGroupMembers = new List<GroupMember>();
var existingIds = existingMembers.Select( m => m.PersonId ).Distinct().ToList();
foreach ( int id in ids.Where( id => !existingIds.Contains( id ) ) )
{
var groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.GroupRoleId = roleId.Value;
groupMember.GroupMemberStatus = status;
groupMember.PersonId = id;
groupMemberService.Add( groupMember );
newGroupMembers.Add( groupMember );
}
rockContext.SaveChanges();
if ( selectedGroupAttributes.Any() )
{
foreach ( var groupMember in newGroupMembers )
{
foreach ( var attribute in selectedGroupAttributes )
{
Rock.Attribute.Helper.SaveAttributeValue( groupMember, attribute, selectedGroupAttributeValues[attribute.Key], rockContext );
}
}
}
}
}
else // Update
{
if ( SelectedFields.Contains( ddlGroupRole.ClientID ) && roleId.HasValue )
{
foreach ( var member in existingMembers.Where( m => m.GroupRoleId != roleId.Value ) )
{
if ( !existingMembers.Where( m => m.PersonId == member.PersonId && m.GroupRoleId == roleId.Value ).Any() )
{
member.GroupRoleId = roleId.Value;
}
}
}
if ( SelectedFields.Contains( ddlGroupMemberStatus.ClientID ) )
{
foreach ( var member in existingMembers )
{
member.GroupMemberStatus = status;
}
}
rockContext.SaveChanges();
if ( selectedGroupAttributes.Any() )
{
foreach ( var groupMember in existingMembers )
{
foreach ( var attribute in selectedGroupAttributes )
{
Rock.Attribute.Helper.SaveAttributeValue( groupMember, attribute, selectedGroupAttributeValues[attribute.Key], rockContext );
}
}
}
}
}
}
}
#endregion
pnlEntry.Visible = false;
pnlConfirm.Visible = false;
nbResult.Text = string.Format( "{0} {1} succesfully updated.",
ids.Count().ToString( "N0" ), ( ids.Count() > 1 ? "people were" : "person was" ) ); ;
pnlResult.Visible = true;
}
}
/// <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 )
{
string[] selectionValues = selection.Split( '|' );
Location selectedLocation = null;
Guid? locationTypeValidGuid = null;
if ( selectionValues.Count() >= 2 )
{
// the selected Location
selectedLocation = new LocationService( context ).Get( selectionValues[0].AsGuid() );
// which address type (home, work, previous) to use as the person's location
locationTypeValidGuid = selectionValues[1].AsGuidOrNull();
}
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
int familyGroupTypeId = new GroupTypeService( context ).Get( familyGuid ).Id;
var groupMemberQuery = new GroupMemberService( context ).Queryable();
const double milesPerMeter = 1 / 1609.344;
IQueryable<double?> personLocationDistanceQuery;
if ( selectedLocation != null )
{
personLocationDistanceQuery = new PersonService( context ).Queryable()
.Select( p =>
groupMemberQuery
.Where( m => m.Group.GroupTypeId == familyGroupTypeId && m.PersonId == p.Id )
.SelectMany( m => m.Group.GroupLocations )
.Where( gl => gl.GroupLocationTypeValue.Guid == locationTypeValidGuid )
.Where( gl => gl.Location.GeoPoint != null )
.Select( s => DbFunctions.Truncate(s.Location.GeoPoint.Distance( selectedLocation.GeoPoint ) * milesPerMeter, 2) )
.FirstOrDefault() );
}
else
{
personLocationDistanceQuery = new PersonService( context ).Queryable()
.Select( p => (double?)null );
}
var selectExpression = SelectExpressionExtractor.Extract<Rock.Model.Person>( personLocationDistanceQuery, entityIdProperty, "p" );
return selectExpression;
}
protected void bindGrid()
{
if ( String.IsNullOrWhiteSpace( CheckinCode ) )
{
ShowPanel( 0 );
}
else
{
rlCheckinCode.Text = CheckinCode + " <a href='?'><i class='fa fa-times'></i></a>";
if ( !SelectedAttendanceGuid.IsEmpty() )
{
ShowPanel( 2 );
var SelectedAttendance = new AttendanceService( rockContext ).Get( SelectedAttendanceGuid );
SelectedAttendance.LoadAttributes();
var attSearch = SelectedAttendance.GetAttributeValue( "SearchValue" );
var hasSearch = !String.IsNullOrWhiteSpace( attSearch );
if ( hasSearch )
attSearch = attSearch.AsNumeric();
var SelectedPerson = SelectedAttendance.PersonAlias.Person;
rlSelectedPerson.Text = SelectedPerson.FullName + " <a href='?CheckinCode=" + CheckinCode + "'><i class='fa fa-times'></i></a>";
var groupRoleServ = new GroupTypeRoleService( rockContext );
var knownRelationship_GroupMemberships = new GroupMemberService( rockContext ).Queryable()
.Where( gm => gm.Group.GroupTypeId == 11 && gm.PersonId == SelectedPerson.Id );
var shownRelationships = GetAttributeValue( "IncludedRelationships" ).Split( ',' ).Select( g => g.AsGuid() );
gReleventPeople.DataSource = SelectedPerson.GetFamilyMembers( false, rockContext )
.Select( m => new
{
Person = m.Person,
Role = m.GroupRole,
Priority = 100
} )
.ToList()
.Union(
knownRelationship_GroupMemberships
.Where( gm => gm.GroupRole.Guid == GUID_OwnerRole )
.SelectMany( gm => gm.Group.Members.Where( gm2 => gm2.PersonId != SelectedPerson.Id ) )
.ToList()
.Select( gm => new
{
Person = gm.Person,
Role = GetInverseRole( gm.GroupRole, groupRoleServ ),
Priority = 50
} )
)
.Union(
knownRelationship_GroupMemberships
.Where( gm => gm.GroupRole.Guid != GUID_OwnerRole )
.Select( gm => new
{
Person = gm.Group.Members.Where( gm2 => gm2.GroupRole.Guid == GUID_OwnerRole ).FirstOrDefault().Person,
Role = gm.GroupRole,
Priority = 40
} ).ToList()
)
.Where( r => shownRelationships.Contains( r.Role.Guid ) )
.GroupBy( x => x.Person )
.Select( x => new PersonRelationship
{
PersonAliasGuid = x.Key.PrimaryAlias.Guid,
FullName = x.Key.FullName,
Roles = String.Join( " ,", x.Select( y => y.Role.Name ) ),
Priority = x.Select( y => y.Priority ).Max(),
HomePhone = GetFormatedNumber( x.Key, GUID_HomePhone ),
MobilePhone = GetFormatedNumber( x.Key, GUID_MobilePhone ),
Highlight = hasSearch && x.Key.PhoneNumbers.Any( y => y.Number.Contains( attSearch ) )
} )
.OrderByDescending( r => r.Priority + ( r.Highlight ? 100 : 0) );
gReleventPeople.DataKeyNames = new string[] { "PersonAliasGuid" };
gReleventPeople.DataBind();
}
else
{
ShowPanel( 1 );
int daysBacktoSearch = GetAttributeValue( "DaysBacktoSearch" ).AsInteger();
var searchDate = DateTime.Now.Date.AddDays( -daysBacktoSearch );
gSearchResults.SetLinqDataSource( new AttendanceCodeService( rockContext )
.Queryable()
.Where( c => c.Code == CheckinCode && c.IssueDateTime > searchDate )
.SelectMany( c => c.Attendances )
.OrderByDescending( "StartDateTime" ) );
gSearchResults.DataKeyNames = new string[] { "Guid" };
gSearchResults.DataBind();
}
}
}
/// <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 adultGuid = SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
var childGuid = SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
var familyGuid = SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
//Contains an array of the int representation of EmailPreferences selected
int[] selectedPreferences = null;
if (!string.IsNullOrEmpty(selection))
{
selectedPreferences = Array.ConvertAll(selection.Split(','), s => int.Parse(s));
}
var familyGroupMembers = new GroupMemberService(context).Queryable()
.Where(m => m.Group.GroupType.Guid == familyGuid);
IQueryable<IEnumerable<string>> personParentsEmailQuery;
//Done as an if statement because:
// 1) If you try and check selectedPreferences for null in LINQ it throws an exception
// 2) If all preferences are selected it's quicker to disregard the preference entirely
if (selectedPreferences == null || selectedPreferences.Length == 3)
{
// this returns Enumerable of Email addresses for Parents per row. The Grid then uses ListDelimiterField to convert the list into Parent's Phone Numbers
personParentsEmailQuery = new PersonService(context).Queryable()
.Select(p => familyGroupMembers.Where(s => s.PersonId == p.Id && s.GroupRole.Guid == childGuid)
.SelectMany(gm => gm.Group.Members)
.Where(m => m.GroupRole.Guid == adultGuid)
.Where(m => !string.IsNullOrEmpty(m.Person.Email) && m.Person.IsEmailActive)
.Select(q => q.Person.Email).AsEnumerable());
}
else
{
// this returns Enumerable of Email addresses for Parents per row. The Grid then uses ListDelimiterField to convert the list into Parent's Phone Numbers
personParentsEmailQuery = new PersonService(context).Queryable()
.Select(p => familyGroupMembers.Where(s => s.PersonId == p.Id && s.GroupRole.Guid == childGuid)
.SelectMany(gm => gm.Group.Members)
.Where(m => m.GroupRole.Guid == adultGuid )
.Where(m => selectedPreferences.Contains((int)m.Person.EmailPreference))
.Where(m => !string.IsNullOrEmpty(m.Person.Email) && m.Person.IsEmailActive)
.Select(q => q.Person.Email).AsEnumerable());
}
var selectEmail = SelectExpressionExtractor.Extract( personParentsEmailQuery, entityIdProperty, "p" );
return selectEmail;
}
/// <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;
}
/// <summary>
/// Gets the groups of selected type that person is a member of
/// </summary>
/// <param name="context">The context.</param>
/// <param name="input">The input.</param>
/// <param name="groupTypeId">The group type identifier.</param>
/// <param name="status">The status.</param>
/// <returns></returns>
public static List<Rock.Model.GroupMember> Groups( DotLiquid.Context context, object input, string groupTypeId, string status = "Active" )
{
var person = GetPerson( input );
int? numericalGroupTypeId = groupTypeId.AsIntegerOrNull();
if ( person != null && numericalGroupTypeId.HasValue )
{
var groupQuery = new GroupMemberService( GetRockContext( context ) )
.Queryable("Group, GroupRole").AsNoTracking()
.Where( m =>
m.PersonId == person.Id &&
m.Group.GroupTypeId == numericalGroupTypeId.Value &&
m.Group.IsActive );
if ( status != "All" )
{
GroupMemberStatus queryStatus = GroupMemberStatus.Active;
queryStatus = (GroupMemberStatus)Enum.Parse( typeof( GroupMemberStatus ), status, true );
groupQuery = groupQuery.Where( m => m.GroupMemberStatus == queryStatus );
}
return groupQuery.ToList();
}
return new List<Model.GroupMember>();
}
/// <summary>
/// Handles the ItemDataBound event of the rptrGroups control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Web.UI.WebControls.RepeaterItemEventArgs"/> instance containing the event data.</param>
protected void rptrGroups_ItemDataBound( object sender, System.Web.UI.WebControls.RepeaterItemEventArgs e )
{
if ( e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem )
{
var group = e.Item.DataItem as Group;
if ( group != null )
{
HyperLink hlEditGroup = e.Item.FindControl( "hlEditGroup" ) as HyperLink;
if ( hlEditGroup != null )
{
hlEditGroup.Visible = _allowEdit;
var pageParams = new Dictionary<string, string>();
pageParams.Add( "PersonId", Person.Id.ToString() );
pageParams.Add( "GroupId", group.Id.ToString() );
hlEditGroup.NavigateUrl = LinkedPageUrl( "GroupEditPage", pageParams );
}
Repeater rptrMembers = e.Item.FindControl( "rptrMembers" ) as Repeater;
if ( rptrMembers != null )
{
// use the _bindGroupsRockContext that is created/disposed in BindFamilies()
var members = new GroupMemberService( _bindGroupsRockContext ).Queryable( "GroupRole,Person", true )
.Where( m =>
m.GroupId == group.Id &&
m.PersonId != Person.Id )
.OrderBy( m => m.GroupRole.Order )
.ToList();
var orderedMembers = new List<GroupMember>();
if ( _IsFamilyGroupType )
{
// Add adult males
orderedMembers.AddRange( members
.Where( m => m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) &&
m.Person.Gender == Gender.Male )
.OrderByDescending( m => m.Person.Age ) );
// Add adult females
orderedMembers.AddRange( members
.Where( m => m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) &&
m.Person.Gender != Gender.Male )
.OrderByDescending( m => m.Person.Age ) );
// Add non-adults
orderedMembers.AddRange( members
.Where( m => !m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) )
.OrderByDescending( m => m.Person.Age ) );
}
else
{
orderedMembers = members
.OrderBy( m => m.GroupRole.Order )
.ThenBy( m => m.Person.LastName )
.ThenBy( m => m.Person.NickName )
.ToList();
}
rptrMembers.ItemDataBound += rptrMembers_ItemDataBound;
rptrMembers.DataSource = orderedMembers;
rptrMembers.DataBind();
}
Repeater rptrAddresses = e.Item.FindControl( "rptrAddresses" ) as Repeater;
if ( rptrAddresses != null )
{
rptrAddresses.ItemDataBound += rptrAddresses_ItemDataBound;
rptrAddresses.ItemCommand += rptrAddresses_ItemCommand;
rptrAddresses.DataSource = new GroupLocationService( _bindGroupsRockContext ).Queryable( "Location,GroupLocationTypeValue" )
.Where( l => l.GroupId == group.Id )
.OrderBy( l => l.GroupLocationTypeValue.Order )
.ToList();
rptrAddresses.DataBind();
}
Panel pnlGroupAttributes = e.Item.FindControl( "pnlGroupAttributes" ) as Panel;
HyperLink hlShowMoreAttributes = e.Item.FindControl( "hlShowMoreAttributes" ) as HyperLink;
PlaceHolder phGroupAttributes = e.Item.FindControl( "phGroupAttributes" ) as PlaceHolder;
PlaceHolder phMoreGroupAttributes = e.Item.FindControl( "phMoreGroupAttributes" ) as PlaceHolder;
if ( pnlGroupAttributes != null && hlShowMoreAttributes != null && phGroupAttributes != null && phMoreGroupAttributes != null )
{
hlShowMoreAttributes.Visible = false;
phGroupAttributes.Controls.Clear();
phMoreGroupAttributes.Controls.Clear();
group.LoadAttributes();
var attributes = group.Attributes
.Select( a => a.Value )
.OrderBy( a => a.Order )
.ToList();
foreach( var attribute in attributes )
{
if ( attribute.IsAuthorized( Authorization.VIEW, CurrentPerson ) )
{
string value = attribute.DefaultValue;
if ( group.AttributeValues.ContainsKey( attribute.Key ) && group.AttributeValues[attribute.Key] != null )
{
value = group.AttributeValues[attribute.Key].ValueFormatted;
}
if ( !string.IsNullOrWhiteSpace( value ) )
{
var literalControl = new RockLiteral();
literalControl.ID = string.Format( "familyAttribute_{0}", attribute.Id );
literalControl.Label = attribute.Name;
literalControl.Text = value;
var div = new HtmlGenericControl( "div" );
div.AddCssClass( "col-md-3 col-sm-6" );
div.Controls.Add( literalControl );
if ( attribute.IsGridColumn )
{
phGroupAttributes.Controls.Add( div );
}
else
{
hlShowMoreAttributes.Visible = true;
phMoreGroupAttributes.Controls.Add( div );
}
}
}
}
pnlGroupAttributes.Visible = phGroupAttributes.Controls.Count > 0 || phMoreGroupAttributes.Controls.Count > 0;
}
}
}
}
/// <summary>
/// Handles the ItemDataBound event of the rptrGroups control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Web.UI.WebControls.RepeaterItemEventArgs"/> instance containing the event data.</param>
protected void rptrGroups_ItemDataBound( object sender, System.Web.UI.WebControls.RepeaterItemEventArgs e )
{
if ( e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem )
{
var group = e.Item.DataItem as Group;
if ( group != null )
{
HyperLink hlEditGroup = e.Item.FindControl( "hlEditGroup" ) as HyperLink;
if ( hlEditGroup != null )
{
hlEditGroup.Visible = _allowEdit;
var pageParams = new Dictionary<string, string>();
pageParams.Add( "PersonId", Person.Id.ToString() );
pageParams.Add( "GroupId", group.Id.ToString() );
hlEditGroup.NavigateUrl = LinkedPageUrl( "GroupEditPage", pageParams );
}
Literal lEditGroup = e.Item.FindControl( "lEditGroup" ) as Literal;
if ( lEditGroup != null )
{
lEditGroup.Text = "Edit " + _groupType.Name;
}
Repeater rptrMembers = e.Item.FindControl( "rptrMembers" ) as Repeater;
if ( rptrMembers != null )
{
// use the _bindGroupsRockContext that is created/disposed in BindFamilies()
var members = new GroupMemberService( _bindGroupsRockContext ).Queryable( "GroupRole,Person", true )
.Where( m =>
m.GroupId == group.Id &&
m.PersonId != Person.Id )
.OrderBy( m => m.GroupRole.Order )
.ToList();
var orderedMembers = new List<GroupMember>();
if ( _IsFamilyGroupType )
{
// Add adult males
orderedMembers.AddRange( members
.Where( m => m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) &&
m.Person.Gender == Gender.Male )
.OrderByDescending( m => m.Person.Age ) );
// Add adult females
orderedMembers.AddRange( members
.Where( m => m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) &&
m.Person.Gender != Gender.Male )
.OrderByDescending( m => m.Person.Age ) );
// Add non-adults
orderedMembers.AddRange( members
.Where( m => !m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) )
.OrderByDescending( m => m.Person.Age ) );
}
else
{
orderedMembers = members
.OrderBy( m => m.GroupRole.Order )
.ThenBy( m => m.Person.LastName )
.ThenBy( m => m.Person.NickName )
.ToList();
}
rptrMembers.ItemDataBound += rptrMembers_ItemDataBound;
rptrMembers.DataSource = orderedMembers;
rptrMembers.DataBind();
}
Repeater rptrAddresses = e.Item.FindControl( "rptrAddresses" ) as Repeater;
{
rptrAddresses.ItemDataBound += rptrAddresses_ItemDataBound;
rptrAddresses.ItemCommand += rptrAddresses_ItemCommand;
rptrAddresses.DataSource = new GroupLocationService( _bindGroupsRockContext ).Queryable( "Location,GroupLocationTypeValue" )
.Where( l => l.GroupId == group.Id )
.OrderBy( l => l.GroupLocationTypeValue.Order )
.ToList();
rptrAddresses.DataBind();
}
}
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
// Find all the Group Types
var groupTypeIds = GetAvailableGroupTypes();
if ( GetAttributeValue( "DisplayFilter" ).AsBooleanOrNull() ?? false )
{
int? groupTypeFilter = gfSettings.GetUserPreference( "Group Type" ).AsIntegerOrNull();
if ( groupTypeFilter.HasValue )
{
groupTypeIds = groupTypeIds.Where( g => g == groupTypeFilter.Value ).ToList();
}
}
var rockContext = new RockContext();
SortProperty sortProperty = gGroups.SortProperty;
if ( sortProperty == null )
{
sortProperty = new SortProperty( new GridViewSortEventArgs( "IsActiveOrder, GroupTypeOrder, GroupTypeName, GroupOrder, Name", SortDirection.Ascending ) );
}
bool onlySecurityGroups = GetAttributeValue( "LimittoSecurityRoleGroups" ).AsBoolean();
var qryGroups = new GroupService( rockContext ).Queryable().Where( g => groupTypeIds.Contains( g.GroupTypeId ) && ( !onlySecurityGroups || g.IsSecurityRole ) );
string limitToActiveStatus = GetAttributeValue( "LimittoActiveStatus" );
bool showActive = true;
bool showInactive = true;
if ( limitToActiveStatus == "all" && gfSettings.Visible )
{
// Filter by active/inactive unless the block settings restrict it
if ( ddlActiveFilter.SelectedIndex > -1 )
{
switch ( ddlActiveFilter.SelectedValue )
{
case "active":
showInactive = false;
break;
case "inactive":
showActive = false;
break;
}
}
}
else if ( limitToActiveStatus != "all" )
{
// filter by the block setting for Active Status
if ( limitToActiveStatus == "active" )
{
showInactive = false;
}
}
// Person context will exist if used on a person detail page
int personEntityTypeId = EntityTypeCache.Read( "Rock.Model.Person" ).Id;
if ( ContextTypesRequired.Any( e => e.Id == personEntityTypeId ) )
{
var personContext = ContextEntity<Person>();
if ( personContext != null )
{
// limit to Groups that the person is a member of
var qry = new GroupMemberService( rockContext ).Queryable( true )
.Where( m => m.PersonId == personContext.Id )
.Join( qryGroups, gm => gm.GroupId, g => g.Id, ( gm, g ) => new { Group = g, GroupMember = gm } );
// Filter by Active Status of Group and Group Membership.
if ( showActive && !showInactive )
{
// Show only active Groups and active Memberships.
qry = qry.Where( gmg => gmg.Group.IsActive && gmg.GroupMember.GroupMemberStatus == GroupMemberStatus.Active );
}
else if ( !showActive )
{
// Show only inactive Groups or inactive Memberships.
qry = qry.Where( gmg => !gmg.Group.IsActive || gmg.GroupMember.GroupMemberStatus == GroupMemberStatus.Inactive );
}
gGroups.DataSource = qry
.Select( m => new GroupListRowInfo {
Id = m.Group.Id,
Name = m.Group.Name,
GroupTypeName = m.Group.GroupType.Name,
GroupOrder = m.Group.Order,
GroupTypeOrder = m.Group.GroupType.Order,
Description = m.Group.Description,
IsSystem = m.Group.IsSystem,
GroupRole = m.GroupMember.GroupRole.Name,
DateAdded = m.GroupMember.CreatedDateTime,
IsActive = m.Group.IsActive && ( m.GroupMember.GroupMemberStatus == GroupMemberStatus.Active ),
IsActiveOrder = ( m.Group.IsActive && ( m.GroupMember.GroupMemberStatus == GroupMemberStatus.Active ) ? 1 : 2 ),
MemberCount = 0
} )
.Sort( sortProperty )
.ToList();
}
}
else
{
var roleGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() );
int roleGroupTypeId = roleGroupType != null ? roleGroupType.Id : 0;
bool useRolePrefix = onlySecurityGroups || groupTypeIds.Contains( roleGroupTypeId );
if ( !showInactive )
{
qryGroups = qryGroups.Where( x => x.IsActive );
}
else if ( !showActive )
{
qryGroups = qryGroups.Where( x => !x.IsActive );
}
gGroups.DataSource = qryGroups
.Select( g => new GroupListRowInfo {
Id = g.Id,
Name = ( ( useRolePrefix && g.GroupType.Id != roleGroupTypeId ) ? "GROUP - " : "" ) + g.Name,
GroupTypeName = g.GroupType.Name,
GroupOrder = g.Order,
GroupTypeOrder = g.GroupType.Order,
Description = g.Description,
IsSystem = g.IsSystem,
IsActive = g.IsActive,
IsActiveOrder = g.IsActive ? 1 : 2,
GroupRole = string.Empty,
DateAdded = DateTime.MinValue,
MemberCount = g.Members.Count()
} )
.Sort( sortProperty )
.ToList();
}
gGroups.EntityTypeId = EntityTypeCache.Read<Group>().Id;
gGroups.DataBind();
// hide the group type column if there's only one type; must come after DataBind()
if ( _groupTypesCount == 1 )
{
this.gGroups.Columns[1].Visible = false;
}
}
/// <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>
/// Maps the family address.
/// </summary>
/// <param name="tableData">The table data.</param>
/// <returns></returns>
private void MapFamilyAddress( IQueryable<Row> tableData )
{
var lookupContext = new RockContext();
var locationService = new LocationService( lookupContext );
List<GroupMember> familyGroupMemberList = new GroupMemberService( lookupContext ).Queryable().AsNoTracking()
.Where( gm => gm.Group.GroupType.Guid == new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY ) ).ToList();
var groupLocationDefinedType = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.GROUP_LOCATION_TYPE ), lookupContext );
int homeGroupLocationTypeId = groupLocationDefinedType.DefinedValues
.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME ) ).Id;
int workGroupLocationTypeId = groupLocationDefinedType.DefinedValues
.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_WORK ) ).Id;
int previousGroupLocationTypeId = groupLocationDefinedType.DefinedValues
.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS ) ).Id;
string otherGroupLocationName = "Other (Imported)";
int? otherGroupLocationTypeId = groupLocationDefinedType.DefinedValues
.Where( dv => dv.TypeName == otherGroupLocationName )
.Select( dv => (int?)dv.Id ).FirstOrDefault();
if ( otherGroupLocationTypeId == null )
{
var otherGroupLocationType = new DefinedValue();
otherGroupLocationType.Value = otherGroupLocationName;
otherGroupLocationType.DefinedTypeId = groupLocationDefinedType.Id;
otherGroupLocationType.IsSystem = false;
otherGroupLocationType.Order = 0;
lookupContext.DefinedValues.Add( otherGroupLocationType );
lookupContext.SaveChanges( DisableAuditing );
otherGroupLocationTypeId = otherGroupLocationType.Id;
}
var newGroupLocations = new List<GroupLocation>();
int completed = 0;
int totalRows = tableData.Count();
int percentage = ( totalRows - 1 ) / 100 + 1;
ReportProgress( 0, string.Format( "Verifying address import ({0:N0} found).", totalRows ) );
foreach ( var row in tableData.Where( r => r != null ) )
{
int? individualId = row["Individual_ID"] as int?;
int? householdId = row["Household_ID"] as int?;
var personKeys = GetPersonKeys( individualId, householdId, includeVisitors: false );
if ( personKeys != null )
{
var familyGroup = familyGroupMemberList.Where( gm => gm.PersonId == personKeys.PersonId )
.Select( gm => gm.Group ).FirstOrDefault();
if ( familyGroup != null )
{
var groupLocation = new GroupLocation();
string street1 = row["Address_1"] as string;
string street2 = row["Address_2"] as string;
string city = row["City"] as string;
string state = row["State"] as string;
string country = row["country"] as string; // NOT A TYPO: F1 has property in lower-case
string zip = row["Postal_Code"] as string ?? string.Empty;
// restrict zip to 5 places to prevent duplicates
Location familyAddress = locationService.Get( street1, street2, city, state, zip.Left( 5 ), country, verifyLocation: false );
if ( familyAddress != null )
{
familyAddress.CreatedByPersonAliasId = ImportPersonAliasId;
familyAddress.Name = familyGroup.Name;
familyAddress.IsActive = true;
groupLocation.GroupId = familyGroup.Id;
groupLocation.LocationId = familyAddress.Id;
groupLocation.IsMailingLocation = true;
groupLocation.IsMappedLocation = true;
string addressType = row["Address_Type"].ToString().ToLower();
if ( addressType.Equals( "primary" ) )
{
groupLocation.GroupLocationTypeValueId = homeGroupLocationTypeId;
}
else if ( addressType.Equals( "business" ) || addressType.ToLower().Equals( "org" ) )
{
groupLocation.GroupLocationTypeValueId = workGroupLocationTypeId;
}
else if ( addressType.Equals( "previous" ) )
{
groupLocation.GroupLocationTypeValueId = previousGroupLocationTypeId;
}
else if ( !string.IsNullOrEmpty( addressType ) )
{
// look for existing group location types, otherwise mark as imported
var customTypeId = groupLocationDefinedType.DefinedValues.Where( dv => dv.Value.ToLower().Equals( addressType ) )
.Select( dv => (int?)dv.Id ).FirstOrDefault();
groupLocation.GroupLocationTypeValueId = customTypeId ?? otherGroupLocationTypeId;
}
newGroupLocations.Add( groupLocation );
completed++;
if ( completed % percentage < 1 )
{
int percentComplete = completed / percentage;
ReportProgress( percentComplete, string.Format( "{0:N0} addresses imported ({1}% complete).", completed, percentComplete ) );
}
else if ( completed % ReportingNumber < 1 )
{
SaveFamilyAddress( newGroupLocations );
// Reset context
newGroupLocations.Clear();
lookupContext = new RockContext();
locationService = new LocationService( lookupContext );
ReportPartialProgress();
}
}
}
}
}
if ( newGroupLocations.Any() )
{
SaveFamilyAddress( newGroupLocations );
}
ReportProgress( 100, string.Format( "Finished address import: {0:N0} addresses imported.", completed ) );
}
void rptrFamilies_ItemDataBound(object sender, System.Web.UI.WebControls.RepeaterItemEventArgs e)
{
if ( e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem )
{
var group = e.Item.DataItem as Group;
if (group != null)
{
HyperLink hlEditFamily = e.Item.FindControl( "hlEditFamily" ) as HyperLink;
if ( hlEditFamily != null )
{
hlEditFamily.Visible = _allowEdit;
hlEditFamily.NavigateUrl = string.Format( "~/EditFamily/{0}/{1}", Person.Id, group.Id );
}
Repeater rptrMembers = e.Item.FindControl( "rptrMembers" ) as Repeater;
if (rptrMembers != null)
{
var members = new GroupMemberService( _rockContext ).Queryable( "GroupRole,Person", true )
.Where( m =>
m.GroupId == group.Id &&
m.PersonId != Person.Id )
.OrderBy( m => m.GroupRole.Order )
.ToList();
var orderedMembers = new List<GroupMember>();
// Add adult males
orderedMembers.AddRange(members
.Where( m => m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)) &&
m.Person.Gender == Gender.Male)
.OrderByDescending( m => m.Person.Age));
// Add adult females
orderedMembers.AddRange(members
.Where( m => m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)) &&
m.Person.Gender != Gender.Male)
.OrderByDescending( m => m.Person.Age));
// Add non-adults
orderedMembers.AddRange(members
.Where( m => !m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)))
.OrderByDescending( m => m.Person.Age));
rptrMembers.ItemDataBound += rptrMembers_ItemDataBound;
rptrMembers.DataSource = orderedMembers;
rptrMembers.DataBind();
}
Repeater rptrAddresses = e.Item.FindControl("rptrAddresses") as Repeater;
{
rptrAddresses.ItemDataBound += rptrAddresses_ItemDataBound;
rptrAddresses.ItemCommand += rptrAddresses_ItemCommand;
rptrAddresses.DataSource = new GroupLocationService( _rockContext ).Queryable( "Location,GroupLocationTypeValue" )
.Where( l => l.GroupId == group.Id)
.OrderBy( l => l.GroupLocationTypeValue.Order)
.ToList();
rptrAddresses.DataBind();
}
}
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute( RockContext rockContext, WorkflowAction action, Object entity, out List<string> errorMessages )
{
errorMessages = new List<string>();
Guid? groupGuid = null;
Person person = null;
string attributeValue = string.Empty;
Guid groupRoleGuid = Guid.Empty;
string attributeKey = string.Empty;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if ( !groupAttributeGuid.IsEmpty() )
{
groupGuid = action.GetWorklowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if ( !groupGuid.HasValue )
{
errorMessages.Add("The group could not be found!");
}
}
// get person alias guid
Guid personAliasGuid = Guid.Empty;
string personAttribute = GetAttributeValue( action, "Person" );
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Read( guid, rockContext );
if ( attribute != null )
{
string value = action.GetWorklowAttributeValue(guid);
personAliasGuid = value.AsGuid();
}
if ( personAliasGuid != Guid.Empty )
{
person = new PersonAliasService(rockContext).Queryable().AsNoTracking()
.Where(p => p.Guid.Equals(personAliasGuid))
.Select(p => p.Person)
.FirstOrDefault();
}
else {
errorMessages.Add("The person could not be found in the attribute!");
}
}
// get group member attribute value
attributeValue = GetAttributeValue(action, "AttributeValue");
guid = attributeValue.AsGuid();
if ( guid.IsEmpty() )
{
attributeValue = attributeValue.ResolveMergeFields(GetMergeFields(action));
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue(guid);
if ( workflowAttributeValue != null )
{
attributeValue = workflowAttributeValue;
}
}
// get optional role filter
groupRoleGuid = GetAttributeValue(action, "GroupRoleFilter").AsGuid();
// get attribute key
attributeKey = GetAttributeValue(action, "GroupMemberAttributeKey").Replace(" ", "");
// set attribute
if ( groupGuid.HasValue && person != null )
{
var qry = new GroupMemberService(rockContext).Queryable()
.Where(m => m.Group.Guid == groupGuid && m.PersonId == person.Id);
if ( groupRoleGuid != Guid.Empty )
{
qry = qry.Where(m => m.GroupRole.Guid == groupRoleGuid);
}
foreach ( var groupMember in qry.ToList() )
{
groupMember.LoadAttributes(rockContext);
if ( groupMember.Attributes.ContainsKey(attributeKey) )
{
var attribute = groupMember.Attributes[attributeKey];
Rock.Attribute.Helper.SaveAttributeValue(groupMember, attribute, attributeValue, rockContext);
}
else
{
action.AddLogEntry(string.Format("The group member attribute {0} does not exist!", attributeKey));
break;
}
}
}
errorMessages.ForEach( m => action.AddLogEntry( m, true ) );
return true;
}
/// <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 )
{
//// Spouse is determined if all these conditions are met
//// 1) Adult in the same family as Person (GroupType = Family, GroupRole = Adult, and in same Group)
//// 2) Opposite Gender as Person
//// 3) Both Persons are Married
Guid adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
Guid marriedGuid = Rock.SystemGuid.DefinedValue.PERSON_MARITAL_STATUS_MARRIED.AsGuid();
int marriedDefinedValueId = DefinedValueCache.Read( marriedGuid ).Id;
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var familyGroupMembers = new GroupMemberService( context ).Queryable()
.Where( m => m.Group.GroupType.Guid == familyGuid );
var personSpouseQuery = new PersonService( context ).Queryable()
.Select( p => familyGroupMembers.Where( s => s.PersonId == p.Id && s.Person.MaritalStatusValueId == marriedDefinedValueId && s.GroupRole.Guid == adultGuid )
.SelectMany( m => m.Group.Members )
.Where( m =>
m.PersonId != p.Id &&
m.GroupRole.Guid == adultGuid &&
m.Person.Gender != p.Gender &&
m.Person.MaritalStatusValueId == marriedDefinedValueId &&
!m.Person.IsDeceased )
.Select( m => m.Person.NickName ).FirstOrDefault() );
var selectSpouseExpression = SelectExpressionExtractor.Extract( personSpouseQuery, entityIdProperty, "p" );
return selectSpouseExpression;
}
/// <summary>
/// Job that will sync groups.
///
/// Called by the <see cref="IScheduler" /> when a
/// <see cref="ITrigger" /> fires that is associated with
/// the <see cref="IJob" />.
/// </summary>
public virtual void Execute( IJobExecutionContext context )
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
try
{
int notificationsSent = 0;
int pendingMembersCount = 0;
// get groups set to sync
RockContext rockContext = new RockContext();
Guid? groupTypeGuid = dataMap.GetString( "GroupType" ).AsGuidOrNull();
Guid? systemEmailGuid = dataMap.GetString( "NotificationEmail" ).AsGuidOrNull();
Guid? groupRoleFilterGuid = dataMap.GetString( "GroupRoleFilter" ).AsGuidOrNull();
int? pendingAge = dataMap.GetString( "PendingAge" ).AsIntegerOrNull();
bool includePreviouslyNotificed = dataMap.GetString( "IncludePreviouslyNotified" ).AsBoolean();
// get system email
SystemEmailService emailService = new SystemEmailService( rockContext );
SystemEmail systemEmail = null;
if ( systemEmailGuid.HasValue )
{
systemEmail = emailService.Get( systemEmailGuid.Value );
}
if ( systemEmail == null )
{
// no email specified, so nothing to do
return;
}
// get group members
if ( groupTypeGuid.HasValue && groupTypeGuid != Guid.Empty )
{
var qry = new GroupMemberService( rockContext ).Queryable( "Person, Group, Group.Members.GroupRole" )
.Where( m => m.Group.GroupType.Guid == groupTypeGuid.Value
&& m.GroupMemberStatus == GroupMemberStatus.Pending );
if ( !includePreviouslyNotificed )
{
qry = qry.Where( m => m.IsNotified == false );
}
if ( groupRoleFilterGuid.HasValue )
{
qry = qry.Where( m => m.GroupRole.Guid == groupRoleFilterGuid.Value );
}
if ( pendingAge.HasValue )
{
var ageDate = RockDateTime.Now.AddDays( pendingAge.Value * -1 );
qry = qry.Where( m => m.ModifiedDateTime > ageDate );
}
var pendingGroupMembers = qry.ToList();
var groups = pendingGroupMembers.GroupBy( m => m.Group );
foreach ( var groupKey in groups )
{
var group = groupKey.Key;
// get list of pending people
var qryPendingIndividuals = group.Members.Where( m => m.GroupMemberStatus == GroupMemberStatus.Pending );
if ( !includePreviouslyNotificed )
{
qryPendingIndividuals = qryPendingIndividuals.Where( m => m.IsNotified == false );
}
if ( groupRoleFilterGuid.HasValue )
{
qryPendingIndividuals = qryPendingIndividuals.Where( m => m.GroupRole.Guid == groupRoleFilterGuid.Value );
}
var pendingIndividuals = qryPendingIndividuals.Select( m => m.Person ).ToList();
// get list of leaders
var groupLeaders = group.Members.Where( m => m.GroupRole.IsLeader == true );
var appRoot = Rock.Web.Cache.GlobalAttributesCache.Read( rockContext ).GetValue( "PublicApplicationRoot" );
var recipients = new List<RecipientData>();
foreach ( var leader in groupLeaders )
{
// create merge object
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "PendingIndividuals", pendingIndividuals );
mergeFields.Add( "Group", group );
mergeFields.Add( "ParentGroup", group.ParentGroup );
mergeFields.Add( "Person", leader.Person );
recipients.Add( new RecipientData( leader.Person.Email, mergeFields ) );
}
if ( pendingIndividuals.Count() > 0 )
{
Email.Send( systemEmail.Guid, recipients, appRoot );
pendingMembersCount += pendingIndividuals.Count();
notificationsSent += recipients.Count();
}
// mark pending members as notified as we go in case the job fails
var notifiedPersonIds = pendingIndividuals.Select( p => p.Id );
foreach ( var pendingGroupMember in pendingGroupMembers.Where( m => m.IsNotified == false && notifiedPersonIds.Contains( m.PersonId ) ) )
{
pendingGroupMember.IsNotified = true;
}
rockContext.SaveChanges();
}
}
context.Result = string.Format( "Sent {0} emails to leaders for {1} pending individuals", notificationsSent, pendingMembersCount );
}
catch ( System.Exception ex )
{
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException( ex, context2 );
throw;
}
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
// Find all the Group Types
var groupTypeIds = GetAvailableGroupTypes();
if ( ( GetAttributeValue( "DisplayFilter" ) ?? "false" ).AsBoolean() )
{
int? groupTypeFilter = gfSettings.GetUserPreference( "Group Type" ).AsInteger( false );
if ( groupTypeFilter.HasValue )
{
groupTypeIds = groupTypeIds.Where( g => g == groupTypeFilter.Value ).ToList();
}
}
var rockContext = new RockContext();
SortProperty sortProperty = gGroups.SortProperty;
if ( sortProperty == null )
{
sortProperty = new SortProperty( new GridViewSortEventArgs( "GroupTypeOrder, GroupTypeName, GroupOrder, Name", SortDirection.Ascending ) );
}
bool onlySecurityGroups = GetAttributeValue( "LimittoSecurityRoleGroups" ).AsBoolean();
bool showDescriptionColumn = GetAttributeValue( "DisplayDescriptionColumn" ).AsBoolean();
bool showActiveStatusColumn = GetAttributeValue( "DisplayActiveStatusColumn" ).AsBoolean();
bool showSystemColumn = GetAttributeValue( "DisplaySystemColumn" ).AsBoolean();
if ( !showDescriptionColumn )
{
gGroups.TooltipField = "Description";
}
Dictionary<string, BoundField> boundFields = gGroups.Columns.OfType<BoundField>().ToDictionary( a => a.DataField );
boundFields["GroupTypeName"].Visible = GetAttributeValue( "DisplayGroupTypeColumn" ).AsBoolean();
boundFields["Description"].Visible = showDescriptionColumn;
Dictionary<string, BoolField> boolFields = gGroups.Columns.OfType<BoolField>().ToDictionary( a => a.DataField );
boolFields["IsActive"].Visible = showActiveStatusColumn;
boolFields["IsSystem"].Visible = showSystemColumn;
// Person context will exist if used on a person detail page
var personContext = ContextEntity<Person>();
if ( personContext != null )
{
boundFields["GroupRole"].Visible = true;
boundFields["DateAdded"].Visible = true;
boundFields["MemberCount"].Visible = false;
gGroups.Actions.ShowAdd = false;
gGroups.IsDeleteEnabled = false;
gGroups.Columns.OfType<DeleteField>().ToList().ForEach( f => f.Visible = false );
var qry = new GroupMemberService( rockContext ).Queryable()
.Where( m =>
m.PersonId == personContext.Id &&
groupTypeIds.Contains( m.Group.GroupTypeId ) &&
( !onlySecurityGroups || m.Group.IsSecurityRole ) );
// Filter by active/inactive
if ( ddlActiveFilter.SelectedIndex > -1 )
{
if ( ddlActiveFilter.SelectedValue == "inactive" )
{
qry = qry.Where( a => a.Group.IsActive == false );
}
else if ( ddlActiveFilter.SelectedValue == "active" )
{
qry = qry.Where( a => a.Group.IsActive == true );
}
}
gGroups.DataSource = qry
.Select( m => new
{
Id = m.Group.Id,
Name = m.Group.Name,
GroupTypeName = m.Group.GroupType.Name,
GroupOrder = m.Group.Order,
GroupTypeOrder = m.Group.GroupType.Order,
Description = m.Group.Description,
IsSystem = m.Group.IsSystem,
GroupRole = m.GroupRole.Name,
DateAdded = m.CreatedDateTime,
IsActive = m.Group.IsActive,
MemberCount = 0
} )
.Sort( sortProperty )
.ToList();
}
else
{
bool canEdit = IsUserAuthorized( Authorization.EDIT );
gGroups.Actions.ShowAdd = canEdit;
gGroups.IsDeleteEnabled = canEdit;
boundFields["GroupRole"].Visible = false;
boundFields["DateAdded"].Visible = false;
boundFields["MemberCount"].Visible = true;
var qry = new GroupService( rockContext ).Queryable()
.Where( g =>
groupTypeIds.Contains( g.GroupTypeId ) &&
( !onlySecurityGroups || g.IsSecurityRole ) );
// Filter by active/inactive
if ( ddlActiveFilter.SelectedIndex > -1 )
{
if ( ddlActiveFilter.SelectedValue == "inactive" )
{
qry = qry.Where( a => a.IsActive == false );
}
else if ( ddlActiveFilter.SelectedValue == "active" )
{
qry = qry.Where( a => a.IsActive == true );
}
}
gGroups.DataSource = qry.Select( g => new
{
Id = g.Id,
Name = g.Name,
GroupTypeName = g.GroupType.Name,
GroupOrder = g.Order,
GroupTypeOrder = g.GroupType.Order,
Description = g.Description,
IsSystem = g.IsSystem,
IsActive = g.IsActive,
GroupRole = string.Empty,
DateAdded = DateTime.MinValue,
MemberCount = g.Members.Count()
} )
.Sort( sortProperty )
.ToList();
}
gGroups.DataBind();
}
/// <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 )
{
Guid adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
Guid childGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var familyGroupMembers = new GroupMemberService( context ).Queryable()
.Where( m => m.Group.GroupType.Guid == familyGuid );
// this returns Enumerable of KidInfo per row. See this.GetGridField to see how it is processed
var personChildrenQuery = new PersonService( context ).Queryable()
.Select( p => familyGroupMembers.Where( s => s.PersonId == p.Id && s.GroupRole.Guid == adultGuid )
.SelectMany( m => m.Group.Members )
.Where( m => m.GroupRole.Guid == childGuid )
.OrderBy( m => m.Person.BirthYear ).ThenBy( m => m.Person.BirthMonth ).ThenBy( m => m.Person.BirthDay )
.Select( m => new KidInfo
{
NickName = m.Person.NickName,
LastName = m.Person.LastName,
SuffixValueId = m.Person.SuffixValueId,
Gender = m.Person.Gender,
BirthDate = m.Person.BirthDate
}).AsEnumerable() );
var selectChildrenExpression = SelectExpressionExtractor.Extract( personChildrenQuery, entityIdProperty, "p" );
return selectChildrenExpression;
}
/// <summary>
/// Job that will run quick SQL queries on a schedule.
///
/// Called by the <see cref="IScheduler" /> when a
/// <see cref="ITrigger" /> fires that is associated with
/// the <see cref="IJob" />.
/// </summary>
public virtual void Execute( IJobExecutionContext context )
{
JobDataMap dataMap = context.JobDetail.JobDataMap;
Guid? entryWorkflowType = dataMap.GetString( "EraEntryWorkflow" ).AsGuidOrNull();
Guid? exitWorkflowType = dataMap.GetString( "EraExitWorkflow" ).AsGuidOrNull();
bool updateVisitDates = dataMap.GetBooleanValue( "SetVisitDates" );
var groupTypeList = dataMap.GetString( "GroupTypes" );
// configuration
//
// giving
int exitGivingCount = 1;
// attendance
int exitAttendanceCountShort = 1;
int exitAttendanceCountLong = 8;
// get era dataset from stored proc
var resultContext = new RockContext();
var eraAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_CURRENTLY_AN_ERA.AsGuid() );
var eraStartAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_START_DATE.AsGuid() );
var eraEndAttribute = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_END_DATE.AsGuid() );
resultContext.Database.CommandTimeout = 3600;
var results = resultContext.Database.SqlQuery<EraResult>( "spCrm_FamilyAnalyticsEraDataset" ).ToList();
int personEntityTypeId = EntityTypeCache.Read( "Rock.Model.Person" ).Id;
int attributeEntityTypeId = EntityTypeCache.Read( "Rock.Model.Attribute" ).Id;
int eraAttributeId = AttributeCache.Read( SystemGuid.Attribute.PERSON_ERA_CURRENTLY_AN_ERA.AsGuid() ).Id;
int personAnalyticsCategoryId = CategoryCache.Read( SystemGuid.Category.HISTORY_PERSON_ANALYTICS.AsGuid() ).Id;
foreach (var result in results )
{
// create new rock context for each family (https://weblog.west-wind.com/posts/2014/Dec/21/Gotcha-Entity-Framework-gets-slow-in-long-Iteration-Loops)
RockContext updateContext = new RockContext();
var attributeValueService = new AttributeValueService( updateContext );
var historyService = new HistoryService( updateContext );
// if era ensure it still meets requirements
if ( result.IsEra )
{
if (result.ExitGiftCountDuration < exitGivingCount && result.ExitAttendanceCountDurationShort < exitAttendanceCountShort && result.ExitAttendanceCountDurationLong < exitAttendanceCountLong )
{
// exit era (delete attribute value from each person in family)
var family = new GroupService( updateContext ).Queryable( "Members, Members.Person" ).AsNoTracking().Where( m => m.Id == result.FamilyId ).FirstOrDefault();
if ( family != null ) {
foreach ( var person in family.Members.Select( m => m.Person ) ) {
// remove the era flag
var eraAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraAttributeValue != null )
{
attributeValueService.Delete( eraAttributeValue );
}
// set end date
var eraEndAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraEndAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraEndAttributeValue == null )
{
eraEndAttributeValue = new AttributeValue();
eraEndAttributeValue.EntityId = person.Id;
eraEndAttributeValue.AttributeId = eraEndAttribute.Id;
attributeValueService.Add( eraEndAttributeValue );
}
eraEndAttributeValue.Value = RockDateTime.Now.ToString();
// add a history record
if ( personAnalyticsCategoryId != 0 && personEntityTypeId != 0 && attributeEntityTypeId != 0 && eraAttributeId != 0 )
{
History historyRecord = new History();
historyService.Add( historyRecord );
historyRecord.EntityTypeId = personEntityTypeId;
historyRecord.EntityId = person.Id;
historyRecord.CreatedDateTime = RockDateTime.Now;
historyRecord.CreatedByPersonAliasId = person.PrimaryAliasId;
historyRecord.Caption = "eRA";
historyRecord.Summary = "Exited eRA Status";
historyRecord.Verb = "EXITED";
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
}
updateContext.SaveChanges();
}
// launch exit workflow
if ( exitWorkflowType.HasValue )
{
LaunchWorkflow( exitWorkflowType.Value, family );
}
}
}
}
else
{
// entered era
var family = new GroupService( updateContext ).Queryable( "Members" ).AsNoTracking().Where( m => m.Id == result.FamilyId ).FirstOrDefault();
if ( family != null )
{
foreach ( var person in family.Members.Select( m => m.Person ) )
{
// set era attribute to true
var eraAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraAttributeValue == null )
{
eraAttributeValue = new AttributeValue();
eraAttributeValue.EntityId = person.Id;
eraAttributeValue.AttributeId = eraAttribute.Id;
attributeValueService.Add( eraAttributeValue );
}
eraAttributeValue.Value = bool.TrueString;
// add start date
var eraStartAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraStartAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if (eraStartAttributeValue == null )
{
eraStartAttributeValue = new AttributeValue();
eraStartAttributeValue.EntityId = person.Id;
eraStartAttributeValue.AttributeId = eraStartAttribute.Id;
attributeValueService.Add( eraStartAttributeValue );
}
eraStartAttributeValue.Value = RockDateTime.Now.ToString();
// delete end date if it exists
var eraEndAttributeValue = attributeValueService.Queryable().Where( v => v.AttributeId == eraEndAttribute.Id && v.EntityId == person.Id ).FirstOrDefault();
if ( eraEndAttributeValue != null )
{
attributeValueService.Delete( eraEndAttributeValue );
}
// add a history record
if ( personAnalyticsCategoryId != 0 && personEntityTypeId != 0 && attributeEntityTypeId != 0 && eraAttributeId != 0 )
{
History historyRecord = new History();
historyService.Add( historyRecord );
historyRecord.EntityTypeId = personEntityTypeId;
historyRecord.EntityId = person.Id;
historyRecord.CreatedDateTime = RockDateTime.Now;
historyRecord.CreatedByPersonAliasId = person.PrimaryAliasId;
historyRecord.Caption = "eRA";
historyRecord.Summary = "Entered eRA Status";
historyRecord.Verb = "ENTERED";
historyRecord.RelatedEntityTypeId = attributeEntityTypeId;
historyRecord.RelatedEntityId = eraAttributeId;
historyRecord.CategoryId = personAnalyticsCategoryId;
}
updateContext.SaveChanges();
}
// launch entry workflow
if ( entryWorkflowType.HasValue )
{
LaunchWorkflow( entryWorkflowType.Value, family );
}
}
}
// update stats
}
// load giving attributes
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsGiving" );
// load attendance attributes
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsAttendance" );
// process history for group types
if (!string.IsNullOrWhiteSpace( groupTypeList ) )
{
string[] groupTypeGuids = groupTypeList.Split( ',' );
var inactiveRecordValue = DefinedValueCache.Read( SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE );
var groupTypeEntityTypeId = EntityTypeCache.Read( "Rock.Model.GroupType" ).Id;
foreach ( var groupTypeGuid in groupTypeGuids )
{
var groupType = GroupTypeCache.Read( groupTypeGuid.AsGuid() );
if ( groupType != null )
{
// if the person is in a group of that type and the last history record for that group type isn't START write a start
RockContext rockContext = new RockContext();
// get history for this group type
var historyRecords = new HistoryService( rockContext ).Queryable()
.Where( h =>
h.EntityTypeId == personEntityTypeId
&& h.RelatedEntityTypeId == groupTypeEntityTypeId
&& h.RelatedEntityId == groupType.Id
)
.GroupBy( h => h.EntityId )
.Select( g => g.OrderByDescending( h => h.CreatedDateTime ).Select( h => new { h.EntityId, h.Verb } ).FirstOrDefault() )
.ToList();
// get group member information
var groupMemberInfo = new GroupMemberService( rockContext ).Queryable()
.Where( m =>
m.Group.GroupTypeId == groupType.Id
&& m.GroupMemberStatus == GroupMemberStatus.Active
&& m.Group.IsActive
//&& m.Person.RecordStatusValueId != inactiveRecordValue.Id
)
.GroupBy( m => m.PersonId )
.Select( g => g.OrderBy( m => m.CreatedDateTime ).Select( m => new { m.PersonId, m.CreatedDateTime, PersonAliasId = m.Person.Aliases.Select( p => p.Id ).FirstOrDefault() } ).FirstOrDefault() )
.ToList();
var needsStartDate = groupMemberInfo.Where( m => !historyRecords.Any( h => h.EntityId == m.PersonId && h.Verb == "STARTED" ) );
foreach ( var startItem in needsStartDate )
{
using ( RockContext updateContext = new RockContext() )
{
var historyService = new HistoryService( updateContext );
History history = new History();
historyService.Add( history );
history.EntityTypeId = personEntityTypeId;
history.EntityId = startItem.PersonId;
history.RelatedEntityTypeId = groupTypeEntityTypeId;
history.RelatedEntityId = groupType.Id;
history.Caption = groupType.Name;
history.Summary = "Started Membership in Group Of Type";
history.Verb = "STARTED";
history.CreatedDateTime = startItem.CreatedDateTime;
history.CreatedByPersonAliasId = startItem.PersonAliasId;
history.CategoryId = personAnalyticsCategoryId;
updateContext.SaveChanges();
}
}
var needsStoppedDate = historyRecords.Where( h => h.Verb == "STARTED" && !groupMemberInfo.Any( m => m.PersonId == h.EntityId ) );
foreach ( var stopItem in needsStoppedDate )
{
using ( RockContext updateContext = new RockContext() )
{
var person = new PersonService( updateContext ).Get( stopItem.EntityId );
if ( person != null )
{
var historyService = new HistoryService( updateContext );
History history = new History();
historyService.Add( history );
history.EntityTypeId = personEntityTypeId;
history.EntityId = person.Id;
history.RelatedEntityTypeId = groupTypeEntityTypeId;
history.RelatedEntityId = groupType.Id;
history.Caption = groupType.Name;
history.Summary = "Stopped Membership in Group Of Type";
history.Verb = "STOPPED";
history.CreatedDateTime = RockDateTime.Now;
history.CreatedByPersonAliasId = person.PrimaryAliasId;
history.CategoryId = personAnalyticsCategoryId;
updateContext.SaveChanges();
}
}
}
}
}
}
// process visit dates
if ( updateVisitDates )
{
resultContext.Database.ExecuteSqlCommand( "spCrm_FamilyAnalyticsUpdateVisitDates" );
}
}
private void ListGroups()
{
RockContext rockContext = new RockContext();
var qry = new GroupMemberService( rockContext )
.Queryable( "Group" );
var parentGroupGuid = GetAttributeValue( "ParentGroup" ).AsGuidOrNull();
if ( parentGroupGuid!=null )
{
var availableGroupIds = ( List<int> ) GetCacheItem( "GroupListPersonalizedLava:" + parentGroupGuid.ToString() );
if ( availableGroupIds == null )
{
var parentGroup = new GroupService( rockContext ).Get( parentGroupGuid ?? new Guid() );
if ( parentGroup != null )
{
availableGroupIds = GetChildGroups( parentGroup ).Select( g => g.Id ).ToList();
}
else
{
availableGroupIds = new List<int>();
}
var cacheLength = GetAttributeValue( "CacheDuration" ).AsInteger();
AddCacheItem( "GroupListPersonalizedLava:" + parentGroupGuid.ToString(), availableGroupIds, cacheLength );
}
qry = qry.Where( m => availableGroupIds.Contains( m.GroupId ) );
}
qry = qry.Where( m => m.PersonId == CurrentPersonId
&& m.GroupMemberStatus == GroupMemberStatus.Active
&& m.Group.IsActive == true );
List<Guid> includeGroupTypeGuids = GetAttributeValue( "IncludeGroupTypes" ).SplitDelimitedValues().Select( a => Guid.Parse( a ) ).ToList();
if ( includeGroupTypeGuids.Count > 0 )
{
qry = qry.Where( t => includeGroupTypeGuids.Contains( t.Group.GroupType.Guid ) );
}
List<Guid> excludeGroupTypeGuids = GetAttributeValue( "ExcludeGroupTypes" ).SplitDelimitedValues().Select( a => Guid.Parse( a ) ).ToList();
if ( excludeGroupTypeGuids.Count > 0 )
{
qry = qry.Where( t => !excludeGroupTypeGuids.Contains( t.Group.GroupType.Guid ) );
}
var groups = new List<GroupInvolvementSummary>();
foreach ( var groupMember in qry.ToList() )
{
if ( groupMember.Group.IsAuthorized( Authorization.VIEW, CurrentPerson ) )
{
groups.Add( new GroupInvolvementSummary
{
Group = groupMember.Group,
Role = groupMember.GroupRole.Name,
IsLeader = groupMember.GroupRole.IsLeader,
GroupType = groupMember.Group.GroupType.Name
} );
}
}
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( this.RockPage, this.CurrentPerson );
mergeFields.Add( "Groups", groups );
Dictionary<string, object> linkedPages = new Dictionary<string, object>();
linkedPages.Add( "DetailPage", LinkedPageRoute( "DetailPage" ) );
mergeFields.Add( "LinkedPages", linkedPages );
string template = GetAttributeValue( "LavaTemplate" );
// show debug info
bool enableDebug = GetAttributeValue( "EnableDebug" ).AsBoolean();
if ( enableDebug && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
lContent.Text = template.ResolveMergeFields( mergeFields );
}
/// <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 )
{
Guid adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
Guid childGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var familyGroupMembers = new GroupMemberService( context ).Queryable()
.Where( m => m.Group.GroupType.Guid == familyGuid );
// this returns Enumerable of Person for Parents per row. The Grid then uses ListDelimiterField to convert the list into Parents Names
var personParentsQuery = new PersonService( context ).Queryable()
.Select( p => familyGroupMembers.Where( s => s.PersonId == p.Id && s.GroupRole.Guid == childGuid )
.SelectMany( m => m.Group.Members )
.Where( m => m.GroupRole.Guid == adultGuid )
.OrderBy( m => m.Person.Gender )
.Select( m => m.Person ).AsEnumerable() );
var selectParentsExpression = SelectExpressionExtractor.Extract<Rock.Model.Person>( personParentsQuery, entityIdProperty, "p" );
return selectParentsExpression;
}
/// <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 )
{
Guid adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
Guid childGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
Guid? phoneNumberTypeValueGuid = selection.AsGuidOrNull();
if ( !phoneNumberTypeValueGuid.HasValue )
{
phoneNumberTypeValueGuid = Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid();
}
int phoneNumberTypeValueId = DefinedValueCache.Read(phoneNumberTypeValueGuid.Value).Id;
var familyGroupMembers = new GroupMemberService(context).Queryable()
.Where(m => m.Group.GroupType.Guid == familyGuid);
// this returns Enumerable of PhoneNumber for Parents per row. The Grid then uses ListDelimiterField to convert the list into Parent's Phone Numbers
var personParentsPhoneQuery = new PersonService( context ).Queryable()
.Select( p => familyGroupMembers.Where( s => s.PersonId == p.Id && s.GroupRole.Guid == childGuid )
.SelectMany( m => m.Group.Members )
.Where( m => m.GroupRole.Guid == adultGuid )
.Select( m => m.Person )
.Where( m => m.PhoneNumbers.Count( t => t.NumberTypeValueId == phoneNumberTypeValueId ) != 0 )
.Select( m => m.PhoneNumbers.FirstOrDefault( t => t.NumberTypeValueId == phoneNumberTypeValueId ) ).AsEnumerable() );
var selectNumbersExpression = SelectExpressionExtractor.Extract<Rock.Model.Person>( personParentsPhoneQuery, entityIdProperty, "p" );
return selectNumbersExpression;
}
/// <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 RelatedPeopleSelectSettings( selection );
bool showRelationship = ( settings.ListFormat == ListFormatSpecifier.NameAndRelationship );
// Get Support Data.
var adultGuid = GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
var childGuid = GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
int familyGroupTypeId = GroupTypeCache.Read( SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid() ).Id;
int knownRelationshipGroupTypeId = GroupTypeCache.Read( SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid() ).Id;
//
// Construct a Query to return the list of Related People matching the filter conditions.
//
IQueryable<RelatedPersonInfo> allRelatedPeopleQuery = null;
// If we are looking for Parents...
// Add the Adults from the Family Group in which the Principal participates as a Child.
if ( settings.FamilyRelationshipTypeGuids.Contains( FamilyRelationshipParentGuid.AsGuid() ) )
{
var familyMembersQuery = GetRelatedPeopleQuery( context, new List<int> { familyGroupTypeId }, new List<Guid> { childGuid }, new List<Guid> { adultGuid }, showRelationship ? "Parent" : null );
allRelatedPeopleQuery = GetRelatedPeopleUnionQuery( allRelatedPeopleQuery, familyMembersQuery );
}
// If we are looking for Children...
// Add the Children from the Family Group in which the Principal participates as an Adult.
if ( settings.FamilyRelationshipTypeGuids.Contains( FamilyRelationshipChildGuid.AsGuid() ) )
{
var familyMembersQuery = GetRelatedPeopleQuery( context, new List<int> { familyGroupTypeId }, new List<Guid> { adultGuid }, new List<Guid> { childGuid }, showRelationship ? "Child" : null );
allRelatedPeopleQuery = GetRelatedPeopleUnionQuery( allRelatedPeopleQuery, familyMembersQuery );
}
// If we are looking for Siblings...
// Add other Children from the Family Group in which the Principal participates as a Child.
if ( settings.FamilyRelationshipTypeGuids.Contains( FamilyRelationshipSiblingGuid.AsGuid() ) )
{
var familyMembersQuery = GetRelatedPeopleQuery( context, new List<int> { familyGroupTypeId }, new List<Guid> { childGuid }, new List<Guid> { childGuid }, showRelationship ? "Sibling" : null );
allRelatedPeopleQuery = GetRelatedPeopleUnionQuery( allRelatedPeopleQuery, familyMembersQuery );
}
// If we are looking for a Spouse...
// Add other Married Adult in the Family Group in which the Principal participates as a Married Adult.
if ( settings.FamilyRelationshipTypeGuids.Contains( FamilyRelationshipSpouseGuid.AsGuid() ) )
{
var marriedStatusGuid = SystemGuid.DefinedValue.PERSON_MARITAL_STATUS_MARRIED.AsGuid();
int marriedStatusId = DefinedValueCache.Read( marriedStatusGuid ).Id;
var familyGroupMembers = new GroupMemberService( context ).Queryable()
.Where( m => m.Group.GroupTypeId == familyGroupTypeId );
var personSpouseQuery = new PersonService( context ).Queryable()
.SelectMany(
p =>
familyGroupMembers.Where( gm => gm.PersonId == p.Id && gm.Person.MaritalStatusValueId == marriedStatusId && gm.GroupRole.Guid == adultGuid )
.SelectMany( gm => gm.Group.Members )
.Where( gm => gm.PersonId != p.Id && gm.GroupRole.Guid == adultGuid && gm.Person.MaritalStatusValueId == marriedStatusId )
.Select(
gm =>
new RelatedPersonInfo
{
RelatedToPersonId = p.Id,
PersonId = gm.Person.Id,
FirstName = gm.Person.FirstName,
LastName = gm.Person.LastName,
Suffix = gm.Person.SuffixValue.Value,
RelationshipName = showRelationship ? "Spouse" : null
} ) );
allRelatedPeopleQuery = GetRelatedPeopleUnionQuery( allRelatedPeopleQuery, personSpouseQuery );
}
// If we are looking for a Known Relationship...
// Add other People from the Known Relationship Group having the specified Roles and in which the Principal is the Owner.
if ( settings.KnownRelationshipTypeGuids.Any() )
{
var ownerGuid = GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid();
var principalRoleGuids = new List<Guid>();
var targetRoleGuids = new List<Guid>( settings.KnownRelationshipTypeGuids );
principalRoleGuids.Add( ownerGuid );
var knownPersonsQuery = GetRelatedPeopleQuery( context, new List<int> { knownRelationshipGroupTypeId }, principalRoleGuids, targetRoleGuids, showRelationship ? "*" : null );
allRelatedPeopleQuery = GetRelatedPeopleUnionQuery( allRelatedPeopleQuery, knownPersonsQuery );
}
//
// Create a Select Expression to return the requested values.
//
var personQuery = new PersonService( context ).Queryable().Select( p => allRelatedPeopleQuery.Where( rpi => rpi.RelatedToPersonId == p.Id ).AsEnumerable() );
var selectExpression = SelectExpressionExtractor.Extract<Model.Person>( personQuery, entityIdProperty, "p" );
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 FilterSettings( selection );
var context = (RockContext)serviceInstance.Context;
//
// Define Candidate People.
//
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 Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService( context ).Queryable();
groupMemberQuery = groupMemberQuery.Where( gm => personKeys.Contains( gm.PersonId ) );
var result = FilterExpressionExtractor.Extract<Rock.Model.GroupMember>( groupMemberQuery, parameterExpression, "gm" );
return result;
}
private void ListGroups()
{
RockContext rockContext = new RockContext();
var qry = new GroupMemberService(rockContext)
.Queryable("Group")
.Where( m => m.PersonId == CurrentPersonId
&& m.GroupMemberStatus == GroupMemberStatus.Active
&& m.Group.IsActive == true);
List<Guid> includeGroupTypeGuids = GetAttributeValue( "IncludeGroupTypes" ).SplitDelimitedValues().Select( a => Guid.Parse( a ) ).ToList();
if ( includeGroupTypeGuids.Count > 0 )
{
qry = qry.Where( t => includeGroupTypeGuids.Contains( t.Group.GroupType.Guid ) );
}
List<Guid> excludeGroupTypeGuids = GetAttributeValue( "ExcludeGroupTypes" ).SplitDelimitedValues().Select( a => Guid.Parse( a ) ).ToList();
if ( excludeGroupTypeGuids.Count > 0 )
{
qry = qry.Where( t => !excludeGroupTypeGuids.Contains( t.Group.GroupType.Guid ) );
}
var groups = qry.Select( m => new GroupInvolvementSummary { Group = m.Group, Role = m.GroupRole.Name, IsLeader = m.GroupRole.IsLeader, GroupType = m.Group.GroupType.Name } ).ToList();
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Groups", groups );
mergeFields.Add( "CurrentPerson", CurrentPerson );
var globalAttributeFields = Rock.Web.Cache.GlobalAttributesCache.GetMergeFields( CurrentPerson );
globalAttributeFields.ToList().ForEach( d => mergeFields.Add( d.Key, d.Value ) );
Dictionary<string, object> linkedPages = new Dictionary<string, object>();
linkedPages.Add( "DetailPage", LinkedPageUrl( "DetailPage", null ) );
mergeFields.Add( "LinkedPages", linkedPages );
string template = GetAttributeValue( "LavaTemplate" );
// show debug info
bool enableDebug = GetAttributeValue( "EnableDebug" ).AsBoolean();
if ( enableDebug && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
lContent.Text = template.ResolveMergeFields( mergeFields );
}
/// <summary>
/// Maps the family address.
/// </summary>
/// <param name="tableData">The table data.</param>
/// <returns></returns>
private void MapFamilyAddress( IQueryable<Row> tableData )
{
var locationService = new LocationService();
int groupEntityTypeId = EntityTypeCache.Read( "Rock.Model.Group" ).Id;
List<DefinedValue> groupLocationTypeList = new DefinedValueService().Queryable().Where( dv => dv.DefinedType.Guid == new Guid( Rock.SystemGuid.DefinedType.GROUP_LOCATION_TYPE ) ).ToList();
List<GroupMember> groupMembershipList = new GroupMemberService().Queryable().Where( gm => gm.Group.GroupType.Guid == new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY ) ).ToList();
int homeGroupLocationTypeId = groupLocationTypeList.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME ) ).Id;
int workGroupLocationTypeId = groupLocationTypeList.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_WORK ) ).Id;
int previousGroupLocationTypeId = groupLocationTypeList.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS ) ).Id;
var newGroupLocations = new List<GroupLocation>();
int completed = 0;
int totalRows = tableData.Count();
int percentage = ( totalRows - 1 ) / 100 + 1;
ReportProgress( 0, string.Format( "Checking address import ({0:N0} found).", totalRows ) );
foreach ( var row in tableData )
{
int? individualId = row["Individual_ID"] as int?;
int? householdId = row["Household_ID"] as int?;
int? associatedPersonId = GetPersonId( individualId, householdId );
if ( associatedPersonId != null )
{
var familyGroup = groupMembershipList.Where( gm => gm.PersonId == (int)associatedPersonId )
.Select( gm => gm.Group ).FirstOrDefault();
if ( familyGroup != null )
{
var groupLocation = new GroupLocation();
string address = row["Address_1"] as string;
string supplemental = row["Address_2"] as string;
string city = row["City"] as string;
string state = row["State"] as string;
string country = row["country"] as string; // NOT A TYPO: F1 has property in lower-case
string zip = row["Postal_Code"] as string;
// Get new or existing location and associate it with group
var familyAddress = locationService.Get( address, supplemental, city, state, zip );
familyAddress.CreatedByPersonAliasId = ImportPersonAlias.Id;
familyAddress.Name = familyGroup.Name;
familyAddress.IsActive = true;
groupLocation.GroupId = familyGroup.Id;
groupLocation.LocationId = familyAddress.Id;
groupLocation.IsMailingLocation = true;
groupLocation.IsMappedLocation = true;
string addressType = row["Address_Type"] as string;
if ( addressType.Equals( "Primary" ) )
{
groupLocation.GroupLocationTypeValueId = homeGroupLocationTypeId;
}
else if ( addressType.Equals( "Business" ) || addressType.Equals( "Org" ) )
{
groupLocation.GroupLocationTypeValueId = workGroupLocationTypeId;
}
else if ( addressType.Equals( "Previous" ) )
{
groupLocation.GroupLocationTypeValueId = previousGroupLocationTypeId;
}
else if ( !string.IsNullOrEmpty( addressType ) )
{
groupLocation.GroupLocationTypeValueId = groupLocationTypeList.Where( dv => dv.Name.Equals( addressType ) )
.Select( dv => (int?)dv.Id ).FirstOrDefault();
}
newGroupLocations.Add( groupLocation );
completed++;
if ( completed % percentage < 1 )
{
int percentComplete = completed / percentage;
ReportProgress( percentComplete, string.Format( "{0:N0} addresses imported ({1}% complete).", completed, percentComplete ) );
}
else if ( completed % ReportingNumber < 1 )
{
RockTransactionScope.WrapTransaction( () =>
{
var groupLocationService = new GroupLocationService();
groupLocationService.RockContext.GroupLocations.AddRange( newGroupLocations );
groupLocationService.RockContext.SaveChanges();
} );
ReportPartialProgress();
}
}
}
}
RockTransactionScope.WrapTransaction( () =>
{
var groupLocationService = new GroupLocationService();
groupLocationService.RockContext.GroupLocations.AddRange( newGroupLocations );
groupLocationService.RockContext.SaveChanges();
} );
ReportProgress( 100, string.Format( "Finished address import: {0:N0} addresses imported.", completed ) );
}
/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public void Execute( IJobExecutionContext context )
{
var rockContext = new RockContext();
JobDataMap dataMap = context.JobDetail.JobDataMap;
Guid? systemEmailGuid = dataMap.GetString( "NotificationEmailTemplate" ).AsGuidOrNull();
if ( systemEmailGuid.HasValue )
{
var selectedGroupTypes = new List<Guid>();
if ( !string.IsNullOrWhiteSpace( dataMap.GetString( "GroupTypes" ) ) )
{
selectedGroupTypes = dataMap.GetString( "GroupTypes" ).Split( ',' ).Select( Guid.Parse ).ToList();
}
var excludedGroupRoleIds = new List<int>();
if ( !string.IsNullOrWhiteSpace( dataMap.GetString( "ExcludedGroupRoleIds" ) ) )
{
excludedGroupRoleIds = dataMap.GetString( "ExcludedGroupRoleIds" ).Split( ',' ).Select( int.Parse ).ToList();
}
var notificationOption = dataMap.GetString( "NotifyParentLeaders" ).ConvertToEnum<NotificationOption>( NotificationOption.None );
var accountAbilityGroupGuid = dataMap.GetString( "AccountabilityGroup" ).AsGuid();
// get groups matching of the types provided
GroupService groupService = new GroupService( rockContext );
var groups = groupService.Queryable().AsNoTracking()
.Where( g => selectedGroupTypes.Contains( g.GroupType.Guid )
&& g.IsActive == true
&& g.GroupRequirements.Any() );
foreach ( var group in groups )
{
// check for members that don't meet requirements
var groupMembersWithIssues = groupService.GroupMembersNotMeetingRequirements( group.Id, true );
if ( groupMembersWithIssues.Count > 0 )
{
// add issues to issue list
GroupsMissingRequirements groupMissingRequirements = new GroupsMissingRequirements();
groupMissingRequirements.Id = group.Id;
groupMissingRequirements.Name = group.Name;
if ( group.GroupType != null )
{
groupMissingRequirements.GroupTypeId = group.GroupTypeId;
groupMissingRequirements.GroupTypeName = group.GroupType.Name;
}
groupMissingRequirements.AncestorPathName = groupService.GroupAncestorPathName( group.Id );
// get list of the group leaders
groupMissingRequirements.Leaders = group.Members
.Where( m => m.GroupRole.IsLeader == true && !excludedGroupRoleIds.Contains( m.GroupRoleId ) )
.Select( m => new GroupMemberResult
{
Id = m.Id,
PersonId = m.PersonId,
FullName = m.Person.FullName
} )
.ToList();
List<GroupMembersMissingRequirements> groupMembers = new List<GroupMembersMissingRequirements>();
foreach ( var groupMemberIssue in groupMembersWithIssues )
{
GroupMembersMissingRequirements groupMember = new GroupMembersMissingRequirements();
groupMember.FullName = groupMemberIssue.Key.Person.FullName;
groupMember.Id = groupMemberIssue.Key.Id;
groupMember.PersonId = groupMemberIssue.Key.PersonId;
groupMember.GroupMemberRole = groupMemberIssue.Key.GroupRole.Name;
List<MissingRequirement> missingRequirements = new List<MissingRequirement>();
foreach ( var issue in groupMemberIssue.Value )
{
MissingRequirement missingRequirement = new MissingRequirement();
missingRequirement.Id = issue.Key.GroupRequirement.GroupRequirementType.Id;
missingRequirement.Name = issue.Key.GroupRequirement.GroupRequirementType.Name;
missingRequirement.Status = issue.Key.MeetsGroupRequirement;
missingRequirement.OccurrenceDate = issue.Value;
switch ( issue.Key.MeetsGroupRequirement )
{
case MeetsGroupRequirement.Meets:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.PositiveLabel;
break;
case MeetsGroupRequirement.MeetsWithWarning:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.WarningLabel;
break;
case MeetsGroupRequirement.NotMet:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.NegativeLabel;
break;
}
missingRequirements.Add( missingRequirement );
}
groupMember.MissingRequirements = missingRequirements;
groupMembers.Add( groupMember );
}
groupMissingRequirements.GroupMembersMissingRequirements = groupMembers;
_groupsMissingRequriements.Add( groupMissingRequirements );
// add leaders as people to notify
foreach ( var leader in group.Members.Where( m => m.GroupRole.IsLeader == true && !excludedGroupRoleIds.Contains( m.GroupRoleId ) ) )
{
NotificationItem notification = new NotificationItem();
notification.GroupId = group.Id;
notification.Person = leader.Person;
_notificationList.Add( notification );
}
// notify parents
if ( notificationOption != NotificationOption.None )
{
var parentLeaders = new GroupMemberService( rockContext ).Queryable( "Person" ).AsNoTracking()
.Where( m => m.GroupRole.IsLeader && !excludedGroupRoleIds.Contains( m.GroupRoleId ) );
if ( notificationOption == NotificationOption.DirectParent )
{
// just the parent group
parentLeaders = parentLeaders.Where( m => m.GroupId == group.ParentGroupId );
}
else
{
// all parents in the heirarchy
var parentIds = groupService.GetAllAncestorIds( group.Id );
parentLeaders = parentLeaders.Where( m => parentIds.Contains( m.GroupId ) );
}
foreach ( var parentLeader in parentLeaders.ToList() )
{
NotificationItem parentNotification = new NotificationItem();
parentNotification.Person = parentLeader.Person;
parentNotification.GroupId = group.Id;
_notificationList.Add( parentNotification );
}
}
}
}
// send out notificatons
var appRoot = Rock.Web.Cache.GlobalAttributesCache.Read( rockContext ).GetValue( "PublicApplicationRoot" );
var recipients = new List<RecipientData>();
var notificationRecipients = _notificationList.GroupBy( p => p.Person.Id ).ToList();
foreach ( var recipientId in notificationRecipients )
{
var recipient = _notificationList.Where( n => n.Person.Id == recipientId.Key ).Select( n => n.Person ).FirstOrDefault();
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( null );
mergeFields.Add( "Person", recipient );
var notificationGroupIds = _notificationList
.Where( n => n.Person.Id == recipient.Id )
.Select( n => n.GroupId )
.ToList();
var missingRequirements = _groupsMissingRequriements.Where( g => notificationGroupIds.Contains( g.Id ) ).ToList();
mergeFields.Add( "GroupsMissingRequirements", missingRequirements );
recipients.Add( new RecipientData( recipient.Email, mergeFields ) );
Email.Send( systemEmailGuid.Value, recipients, appRoot );
recipients.Clear();
}
// add accountability group members
if ( !accountAbilityGroupGuid.IsEmpty() )
{
var accountabilityGroupMembers = new GroupMemberService( rockContext ).Queryable().AsNoTracking()
.Where( m => m.Group.Guid == accountAbilityGroupGuid )
.Select( m => m.Person );
foreach ( var person in accountabilityGroupMembers )
{
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( null );
mergeFields.Add( "Person", person );
mergeFields.Add( "GroupsMissingRequirements", _groupsMissingRequriements );
recipients.Add( new RecipientData( person.Email, mergeFields ) );
}
}
Email.Send( systemEmailGuid.Value, recipients, appRoot );
context.Result = string.Format( "{0} requirement notification {1} sent", recipients.Count, "email".PluralizeIf( recipients.Count() != 1 ) );
}
else
{
context.Result = "Warning: No NotificationEmailTemplate found";
}
}
/// <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 )
{
Guid? groupLocationTypeValueGuid = selection.AsGuidOrNull();
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
int familyGroupTypeId = new GroupTypeService( context ).Get( familyGuid ).Id;
var groupMemberQuery = new GroupMemberService( context ).Queryable();
// NOTE: This builds the FullAddress similar to how Location.ToString() does, but using SQL functions (selecting the entire Location record then doing ToString() is slow)
var personLocationQuery = new PersonService( context ).Queryable()
.Select( p =>
groupMemberQuery
.Where( m => m.Group.GroupTypeId == familyGroupTypeId && m.PersonId == p.Id )
.SelectMany( m => m.Group.GroupLocations )
.Where( gl => gl.GroupLocationTypeValue.Guid == groupLocationTypeValueGuid )
.Select( s => ( s.Location.Street1 + " " + s.Location.Street2 + " " + s.Location.City + ", " + s.Location.State + " " + s.Location.PostalCode ).Replace( " ", " " ) )
.FirstOrDefault() );
var selectExpression = SelectExpressionExtractor.Extract<Rock.Model.Person>( personLocationQuery, entityIdProperty, "p" );
return selectExpression;
}
