/// <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
{
// get groups set to sync
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService( rockContext );
var groupsThatSync = groupService.Queryable().Where( g => g.SyncDataViewId != null ).ToList();
foreach ( var syncGroup in groupsThatSync )
{
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
var syncSource = new DataViewService( rockContext ).Get( syncGroup.SyncDataViewId.Value );
// ensure this is a person dataview
bool isPersonDataSet = syncSource.EntityTypeId == EntityTypeCache.Read( typeof( Rock.Model.Person ) ).Id;
if ( isPersonDataSet )
{
SortProperty sortById = new SortProperty();
sortById.Property = "Id";
sortById.Direction = System.Web.UI.WebControls.SortDirection.Ascending;
List<string> errorMessages = new List<string>();
var sourceItems = syncSource.GetQuery( sortById, 180, out errorMessages ).Select( q => q.Id ).ToList();
var targetItems = groupMemberService.Queryable("Person").Where( gm => gm.GroupId == syncGroup.Id ).ToList();
// delete items from the target not in the source
foreach ( var targetItem in targetItems.Where( t => !sourceItems.Contains( t.PersonId ) ) )
{
// made a clone of the person as it will be detached when the group member is deleted. Also
// saving the delete before the email is sent in case an exception occurs so the user doesn't
// get an email everytime the agent runs.
Person recipient = (Person)targetItem.Person.Clone();
groupMemberService.Delete( targetItem );
rockContext.SaveChanges();
if ( syncGroup.ExitSystemEmailId.HasValue )
{
SendExitEmail( syncGroup.ExitSystemEmailId.Value, recipient, syncGroup );
}
}
// add items not in target but in the source
foreach ( var sourceItem in sourceItems.Where( s => !targetItems.Select( t => t.PersonId ).Contains( s ) ) )
{
// add source to target
var newGroupMember = new GroupMember { Id = 0 };
newGroupMember.PersonId = sourceItem;
newGroupMember.Group = syncGroup;
newGroupMember.GroupMemberStatus = GroupMemberStatus.Active;
newGroupMember.GroupRoleId = syncGroup.GroupType.DefaultGroupRoleId ?? syncGroup.GroupType.Roles.FirstOrDefault().Id;
groupMemberService.Add( newGroupMember );
if ( syncGroup.WelcomeSystemEmailId.HasValue )
{
SendWelcomeEmail( syncGroup.WelcomeSystemEmailId.Value, sourceItem, syncGroup, syncGroup.AddUserAccountsDuringSync ?? false );
}
}
rockContext.SaveChanges();
}
}
}
catch ( System.Exception ex )
{
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException( ex, context2 );
throw ex;
}
}
/// <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>();
// Determine which group to add the person to
Group group = null;
int? groupRoleId = null;
var groupAndRoleValues = ( GetAttributeValue( action, "GroupAndRole" ) ?? string.Empty ).Split( '|' );
if ( groupAndRoleValues.Count() > 1 )
{
var groupGuid = groupAndRoleValues[1].AsGuidOrNull();
if ( groupGuid.HasValue )
{
group = new GroupService( rockContext ).Get( groupGuid.Value );
if ( groupAndRoleValues.Count() > 2 )
{
var groupTypeRoleGuid = groupAndRoleValues[2].AsGuidOrNull();
if ( groupTypeRoleGuid.HasValue )
{
var groupRole = new GroupTypeRoleService( rockContext ).Get( groupTypeRoleGuid.Value );
if ( groupRole != null )
{
groupRoleId = groupRole.Id;
}
}
}
}
}
if ( group == null )
{
errorMessages.Add( "No group was provided" );
}
// determine the person that will be added to the group
Person person = null;
// get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value
var guidPersonAttribute = GetAttributeValue( action, "Person" ).AsGuidOrNull();
if ( guidPersonAttribute.HasValue )
{
var attributePerson = AttributeCache.Read( guidPersonAttribute.Value, rockContext );
if ( attributePerson != null )
{
string attributePersonValue = action.GetWorklowAttributeValue( guidPersonAttribute.Value );
if ( !string.IsNullOrWhiteSpace( attributePersonValue ) )
{
if ( attributePerson.FieldType.Class == typeof( Rock.Field.Types.PersonFieldType ).FullName )
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if ( !personAliasGuid.IsEmpty() )
{
person = new PersonAliasService( rockContext ).Queryable()
.Where( a => a.Guid.Equals( personAliasGuid ) )
.Select( a => a.Person )
.FirstOrDefault();
}
}
else
{
errorMessages.Add( "The attribute used to provide the person was not of type 'Person'." );
}
}
}
}
if ( person == null )
{
errorMessages.Add( string.Format( "Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString() ) );
}
// Remove Person from Group
if ( !errorMessages.Any() )
{
try {
var groupMemberService = new GroupMemberService( rockContext );
var groupMembers = groupMemberService.Queryable().Where( m => m.PersonId == person.Id );
if ( groupRoleId.HasValue )
{
groupMembers = groupMembers.Where( m => m.GroupRoleId == groupRoleId.Value );
}
foreach ( var groupMember in groupMembers )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
catch(Exception ex )
{
errorMessages.Add( string.Format("An error occurred while removing the group member: {0}", ex.Message ) );
}
}
errorMessages.ForEach( m => action.AddLogEntry( m, true ) );
return true;
}
/// <summary>
/// Handles the Click event of the btnDelete 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 btnDelete_Click( object sender, EventArgs e )
{
var familyGroupId = _family.Id;
var rockContext = new RockContext();
var familyMemberService = new GroupMemberService( rockContext );
var familyMembers = familyMemberService.GetByGroupId( familyGroupId, true );
if (familyMembers.Count() == 1)
{
var fm = familyMembers.FirstOrDefault();
// If the person's giving group id is this family, change their giving group id to null
if ( fm.Person.GivingGroupId == fm.GroupId )
{
var personService = new PersonService( rockContext );
var person = personService.Get( fm.PersonId );
var demographicChanges = new List<string>();
History.EvaluateChange( demographicChanges, "Giving Group", person.GivingGroup.Name, "" );
person.GivingGroupId = null;
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id, demographicChanges );
rockContext.SaveChanges();
}
// remove person from family
var oldMemberChanges = new List<string>();
History.EvaluateChange( oldMemberChanges, "Role", fm.GroupRole.Name, string.Empty );
History.EvaluateChange( oldMemberChanges, "Family", fm.Group.Name, string.Empty );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.Person.Id, oldMemberChanges, fm.Group.Name, typeof( Group ), fm.Group.Id );
familyMemberService.Delete( fm );
rockContext.SaveChanges();
}
var familyService = new GroupService( rockContext );
// get the family that we want to delete (if it has no members )
var family = familyService.Queryable()
.Where( g =>
g.Id == familyGroupId &&
!g.Members.Any() )
.FirstOrDefault();
if ( family != null )
{
familyService.Delete( family );
rockContext.SaveChanges();
}
Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
}
/// <summary>
/// Handles the Click event of the DeleteGroupMember control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs" /> instance containing the event data.</param>
protected void DeleteGroupMember_Click( object sender, Rock.Web.UI.Controls.RowEventArgs e )
{
RockContext rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
GroupMember groupMember = groupMemberService.Get( e.RowKeyId );
if ( groupMember != null )
{
string errorMessage;
if ( !groupMemberService.CanDelete( groupMember, out errorMessage ) )
{
mdGridWarning.Show( errorMessage, ModalAlertType.Information );
return;
}
int groupId = groupMember.GroupId;
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
Group group = new GroupService( rockContext ).Get( groupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
// person removed from SecurityRole, Flush
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
BindGroupMembersGrid();
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad( EventArgs e )
{
base.OnLoad( e );
if ( !Page.IsPostBack )
{
RockContext rockContext = new RockContext();
Group group = null;
Guid personGuid = Guid.Empty;
// get group from url
if ( Request["GroupId"] != null || Request["GroupGuid"] != null )
{
if ( Request["GroupId"] != null )
{
int groupId = 0;
if ( Int32.TryParse( Request["GroupId"], out groupId ) )
{
group = new GroupService( rockContext ).Queryable().Where( g => g.Id == groupId ).FirstOrDefault();
}
}
else
{
Guid groupGuid = Request["GroupGuid"].AsGuid();
group = new GroupService( rockContext ).Queryable().Where( g => g.Guid == groupGuid ).FirstOrDefault();
}
}
else
{
Guid groupGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "DefaultGroup" ), out groupGuid ) ) {
group = new GroupService( rockContext ).Queryable().Where( g => g.Guid == groupGuid ).FirstOrDefault(); ;
}
}
if ( group == null )
{
lAlerts.Text = "Could not determine the group to add to.";
return;
}
// get person
Person person = null;
if ( !string.IsNullOrWhiteSpace(Request["PersonGuid"]) )
{
person = new PersonService( rockContext ).Get( Request["PersonGuid"].AsGuid() );
}
if ( person == null )
{
lAlerts.Text += "A person could not be found for the identifier provided.";
return;
}
// hide alert
divAlert.Visible = false;
// get status
var groupMemberStatus = this.GetAttributeValue( "GroupMemberStatus" ).ConvertToEnum<GroupMemberStatus>( GroupMemberStatus.Active );
// load merge fields
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "Group", group );
mergeFields.Add( "Person", person );
mergeFields.Add( "CurrentPerson", CurrentPerson );
// show debug info?
bool enableDebug = GetAttributeValue( "EnableDebug" ).AsBoolean();
if ( enableDebug && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
var groupMemberService = new GroupMemberService(rockContext);
var groupMemberList = groupMemberService.Queryable()
.Where( m => m.GroupId == group.Id && m.PersonId == person.Id )
.ToList();
if (groupMemberList.Count > 0 )
{
foreach(var groupMember in groupMemberList )
{
if ( GetAttributeValue( "Inactivate" ).AsBoolean() )
{
groupMember.GroupMemberStatus = GroupMemberStatus.Inactive;
}
else
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
lContent.Text = GetAttributeValue( "SuccessMessage" ).ResolveMergeFields( mergeFields );
}
else
{
if ( GetAttributeValue( "WarnWhenNotInGroup").AsBoolean() )
{
lContent.Text = GetAttributeValue( "NotInGroupMessage" ).ResolveMergeFields( mergeFields );
}
else
{
lContent.Text = GetAttributeValue( "SuccessMessage" ).ResolveMergeFields( mergeFields );
}
}
}
}
/// <summary>
/// Generic method to delete the members of a group and then the group.
/// </summary>
/// <param name="group">The group.</param>
/// <param name="rockContext">The rock context.</param>
/// <exception cref="System.InvalidOperationException">Unable to delete group: + group.Name</exception>
private void DeleteGroupAndMemberData( Group group, RockContext rockContext )
{
GroupService groupService = new GroupService( rockContext );
// delete addresses
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
if ( group.GroupLocations.Count > 0 )
{
foreach ( var groupLocations in group.GroupLocations.ToList() )
{
group.GroupLocations.Remove( groupLocations );
groupLocationService.Delete( groupLocations );
}
}
// delete members
var groupMemberService = new GroupMemberService( rockContext );
var members = group.Members;
foreach ( var member in members.ToList() )
{
group.Members.Remove( member );
groupMemberService.Delete( member );
}
// delete attribute values
group.LoadAttributes( rockContext );
if ( group.AttributeValues != null )
{
var attributeValueService = new AttributeValueService( rockContext );
foreach ( var entry in group.AttributeValues )
{
var attributeValue = attributeValueService.GetByAttributeIdAndEntityId( entry.Value.AttributeId, group.Id );
if ( attributeValue != null )
{
attributeValueService.Delete( attributeValue );
}
}
}
// now delete the group
if ( groupService.Delete( group ) )
{
// ok
}
else
{
throw new InvalidOperationException( "Unable to delete group: " + group.Name );
}
}
/// <summary>
/// Handles the Delete event of the gContactList control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs"/> instance containing the event data.</param>
protected void gContactList_Delete( object sender, Rock.Web.UI.Controls.RowEventArgs e )
{
int? businessId = hfBusinessId.Value.AsIntegerOrNull();
if ( businessId.HasValue )
{
var businessContactId = e.RowKeyId;
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService( rockContext );
Guid businessContact = Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT.AsGuid();
Guid business = Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS.AsGuid();
Guid ownerGuid = Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid();
foreach ( var groupMember in groupMemberService.Queryable()
.Where( m =>
(
// The contact person in the business's known relationships
m.PersonId == businessContactId &&
m.GroupRole.Guid.Equals( businessContact ) &&
m.Group.Members.Any( o =>
o.PersonId == businessId &&
o.GroupRole.Guid.Equals( ownerGuid ) )
) ||
(
// The business in the person's know relationships
m.PersonId == businessId &&
m.GroupRole.Guid.Equals( business ) &&
m.Group.Members.Any( o =>
o.PersonId == businessContactId &&
o.GroupRole.Guid.Equals( ownerGuid ) )
)
) )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
BindContactListGrid( new PersonService( rockContext ).Get( businessId.Value ) );
}
}
/// <summary>
/// Generic method to delete the members of a group and then the group.
/// </summary>
/// <param name="group">The group.</param>
/// <param name="rockContext">The rock context.</param>
/// <exception cref="System.InvalidOperationException">Unable to delete group: + group.Name</exception>
private void DeleteGroupAndMemberData( Group group, RockContext rockContext )
{
GroupService groupService = new GroupService( rockContext );
// delete addresses
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
if ( group.GroupLocations.Count > 0 )
{
foreach ( var groupLocations in group.GroupLocations.ToList() )
{
group.GroupLocations.Remove( groupLocations );
groupLocationService.Delete( groupLocations );
}
}
// delete members
var groupMemberService = new GroupMemberService( rockContext );
var members = group.Members;
foreach ( var member in members.ToList() )
{
group.Members.Remove( member );
groupMemberService.Delete( member );
}
// now delete the group
if ( groupService.Delete( group ) )
{
// ok
}
else
{
throw new InvalidOperationException( "Unable to delete group: " + group.Name );
}
}
/// <summary>
/// Removes the person RSVP.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="groupId">The group identifier.</param>
/// <param name="scheduleId">The schedule identifier.</param>
/// <param name="scheduleDate">The schedule date.</param>
private void RemovePersonRsvp(Person person, int groupId, int scheduleId, DateTime? scheduleDate )
{
RockContext rockContext = new RockContext();
var attendanceService = new AttendanceService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
// delete the RSVP
var attendanceRecord = attendanceService.Queryable()
.Where( a =>
a.PersonAlias.PersonId == CurrentPersonId
&& a.GroupId == groupId
&& a.ScheduleId == scheduleId
&& a.RSVP == RSVP.Yes
&& DbFunctions.TruncateTime( a.StartDateTime ) == DbFunctions.TruncateTime( scheduleDate.Value ) )
.FirstOrDefault();
if ( attendanceRecord != null )
{
attendanceService.Delete( attendanceRecord );
}
// remove them from the group
var groupMember = groupMemberService.Queryable().Where( m => m.PersonId == CurrentPersonId && m.GroupId == groupId ).FirstOrDefault();
if ( groupMember != null )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
protected void btnMoveRegistration_Click( object sender, EventArgs e )
{
// set the new registration id
using ( var rockContext = new RockContext() )
{
var registrationService = new RegistrationService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var registration = registrationService.Get( Registration.Id );
registration.RegistrationInstanceId = ddlNewRegistrationInstance.SelectedValue.AsInteger();
// Move registrants to new group
int? groupId = ddlMoveGroup.SelectedValueAsInt();
if ( groupId.HasValue )
{
registration.GroupId = groupId;
rockContext.SaveChanges();
var group = new GroupService( rockContext ).Get( groupId.Value );
if ( group != null )
{
int? groupRoleId = null;
var template = registration.RegistrationInstance.RegistrationTemplate;
if ( group.GroupTypeId == template.GroupTypeId && template.GroupMemberRoleId.HasValue )
{
groupRoleId = template.GroupMemberRoleId.Value;
}
if ( !groupRoleId.HasValue )
{
groupRoleId = group.GroupType.DefaultGroupRoleId;
}
if ( !groupRoleId.HasValue )
{
groupRoleId = group.GroupType.Roles.OrderBy( r => r.Order ).Select( r => r.Id ).FirstOrDefault();
}
if ( groupRoleId.HasValue )
{
foreach ( var registrant in registration.Registrants.Where( r => r.PersonAlias != null ) )
{
var newGroupMembers = groupMemberService.GetByGroupIdAndPersonId( groupId.Value, registrant.PersonAlias.PersonId );
if ( !newGroupMembers.Any() )
{
// Get any existing group member attribute values
var existingAttributeValues = new Dictionary<string, string>();
if ( registrant.GroupMemberId.HasValue )
{
var existingGroupMember = groupMemberService.Get( registrant.GroupMemberId.Value );
if ( existingGroupMember != null )
{
existingGroupMember.LoadAttributes( rockContext );
foreach ( var attributeValue in existingGroupMember.AttributeValues )
{
existingAttributeValues.Add( attributeValue.Key, attributeValue.Value.Value );
}
}
registrant.GroupMember = null;
groupMemberService.Delete( existingGroupMember );
}
var newGroupMember = new GroupMember();
groupMemberService.Add( newGroupMember );
newGroupMember.Group = group;
newGroupMember.PersonId = registrant.PersonAlias.PersonId;
newGroupMember.GroupRoleId = groupRoleId.Value;
rockContext.SaveChanges();
newGroupMember = groupMemberService.Get( newGroupMember.Id );
newGroupMember.LoadAttributes();
foreach( var attr in newGroupMember.Attributes )
{
if ( existingAttributeValues.ContainsKey( attr.Key ) )
{
newGroupMember.SetAttributeValue( attr.Key, existingAttributeValues[attr.Key] );
}
}
newGroupMember.SaveAttributeValues( rockContext );
registrant.GroupMember = newGroupMember;
rockContext.SaveChanges();
}
}
}
}
}
// Reload registration
Registration = GetRegistration( Registration.Id );
lWizardInstanceName.Text = Registration.RegistrationInstance.Name;
ShowReadonlyDetails( Registration );
}
mdMoveRegistration.Hide();
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
// if a Location is getting edited, validate and save it
if ( gLocations.EditIndex >= 0 )
{
var row = gLocations.Rows[gLocations.EditIndex];
AddressControl acAddress = row.FindControl( "acAddress" ) as AddressControl;
if ( acAddress.IsValid )
{
gLocations_RowUpdating( sender, new GridViewUpdateEventArgs( gLocations.EditIndex ) );
}
else
{
// acAddress will render an error message
return;
}
}
if ( !IsUserAuthorized( Rock.Security.Authorization.EDIT ) )
{
return;
}
// confirmation was disabled by btnSave on client-side. So if returning without a redirect,
// it should be enabled. If returning with a redirect, the control won't be updated to reflect
// confirmation being enabled, so it's ok to enable it here
confirmExit.Enabled = true;
if ( Page.IsValid )
{
confirmExit.Enabled = true;
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var personService = new PersonService( rockContext );
var historyService = new HistoryService( rockContext );
var groupChanges = new List<string>();
// SAVE GROUP
_group = groupService.Get( _group.Id );
History.EvaluateChange( groupChanges, "Group Name", _group.Name, tbGroupName.Text );
_group.Name = tbGroupName.Text;
int? campusId = cpCampus.SelectedValueAsInt();
if ( _group.CampusId != campusId )
{
History.EvaluateChange(
groupChanges,
"Campus",
_group.CampusId.HasValue ? CampusCache.Read( _group.CampusId.Value ).Name : string.Empty,
campusId.HasValue ? CampusCache.Read( campusId.Value ).Name : string.Empty );
_group.CampusId = campusId;
}
rockContext.SaveChanges();
// SAVE GROUP MEMBERS
int? recordStatusValueID = ddlRecordStatus.SelectedValueAsInt();
int? reasonValueId = ddlReason.SelectedValueAsInt();
var newGroups = new List<Group>();
foreach ( var groupMemberInfo in GroupMembers )
{
var memberChanges = new List<string>();
var demographicChanges = new List<string>();
var role = _groupType.Roles.Where( r => r.Guid.Equals( groupMemberInfo.RoleGuid ) ).FirstOrDefault();
if ( role == null )
{
role = _groupType.Roles.FirstOrDefault();
}
bool isAdult = role != null && role.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT );
// People added to group (new or from other group )
if ( !groupMemberInfo.ExistingGroupMember )
{
Person person = null;
if ( groupMemberInfo.Id == -1 )
{
// added new person
demographicChanges.Add( "Created" );
person = new Person();
person.TitleValueId = groupMemberInfo.TitleValueId;
person.FirstName = groupMemberInfo.FirstName;
person.NickName = groupMemberInfo.NickName;
person.LastName = groupMemberInfo.LastName;
person.SuffixValueId = groupMemberInfo.SuffixValueId;
person.Gender = groupMemberInfo.Gender;
DateTime? birthdate = groupMemberInfo.BirthDate;
if ( birthdate.HasValue )
{
// If setting a future birthdate, subtract a century until birthdate is not greater than today.
var today = RockDateTime.Today;
while ( birthdate.Value.CompareTo( today ) > 0 )
{
birthdate = birthdate.Value.AddYears( -100 );
}
}
person.SetBirthDate( birthdate );
person.MaritalStatusValueId = groupMemberInfo.MaritalStatusValueId;
person.GradeOffset = groupMemberInfo.GradeOffset;
person.ConnectionStatusValueId = groupMemberInfo.ConnectionStatusValueId;
if ( isAdult )
{
person.GivingGroupId = _group.Id;
}
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
}
else
{
person = personService.Get( groupMemberInfo.Id );
}
if ( person == null )
{
// shouldn't happen
return;
}
if ( _isFamilyGroupType )
{
if ( person.RecordStatusValueId != recordStatusValueID )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
person.RecordStatusValueId = recordStatusValueID;
}
if ( person.RecordStatusValueId != recordStatusValueID )
{
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
person.RecordStatusReasonValueId = reasonValueId;
}
}
PersonService.AddPersonToGroup( person, person.Id == 0, _group.Id, role.Id, rockContext );
}
else
{
// existing group members
var groupMember = groupMemberService.Queryable( "Person", true ).Where( m =>
m.PersonId == groupMemberInfo.Id &&
m.Group.GroupTypeId == _groupType.Id &&
m.GroupId == _group.Id ).FirstOrDefault();
if ( groupMember != null )
{
if ( groupMemberInfo.Removed )
{
if ( !groupMemberInfo.IsInOtherGroups )
{
var newFamilyChanges = new List<string>();
// Family member was removed and should be created in their own new family
var newGroup = new Group();
newGroup.Name = groupMemberInfo.LastName + " " + _groupType.Name;
History.EvaluateChange( newFamilyChanges, "Family", string.Empty, newGroup.Name );
newGroup.GroupTypeId = _groupType.Id;
if ( _group.CampusId.HasValue )
{
History.EvaluateChange( newFamilyChanges, "Campus", string.Empty, CampusCache.Read( _group.CampusId.Value ).Name );
}
newGroup.CampusId = _group.CampusId;
groupService.Add( newGroup );
rockContext.SaveChanges();
// If person's previous giving group was this family, set it to their new family id
if ( _isFamilyGroupType && groupMember.Person.GivingGroup != null && groupMember.Person.GivingGroupId == _group.Id )
{
History.EvaluateChange( demographicChanges, "Giving Group", groupMember.Person.GivingGroup.Name, _group.Name );
groupMember.Person.GivingGroupId = newGroup.Id;
}
groupMember.Group = newGroup;
rockContext.SaveChanges();
var newMemberChanges = new List<string>();
if ( _isFamilyGroupType )
{
History.EvaluateChange( newMemberChanges, "Role", string.Empty, groupMember.GroupRole.Name );
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
groupMember.Person.Id,
newFamilyChanges,
newGroup.Name,
typeof( Group ),
newGroup.Id );
}
newGroups.Add( newGroup );
History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole.Name, string.Empty );
}
else
{
History.EvaluateChange( groupChanges, "Family", groupMember.Group.Name, string.Empty );
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
}
}
else
{
// Existing member was not remvoved
if ( role != null )
{
History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole != null ? groupMember.GroupRole.Name : string.Empty, role.Name );
groupMember.GroupRoleId = role.Id;
if ( _isFamilyGroupType )
{
if ( recordStatusValueID > 0 )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
groupMember.Person.RecordStatusValueId = recordStatusValueID;
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
groupMember.Person.RecordStatusReasonValueId = reasonValueId;
}
}
rockContext.SaveChanges();
}
}
}
}
// Remove anyone that was moved from another family
if ( groupMemberInfo.RemoveFromOtherGroups )
{
PersonService.RemovePersonFromOtherFamilies( _group.Id, groupMemberInfo.Id, rockContext );
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), groupMemberInfo.Id, demographicChanges );
if ( _isFamilyGroupType )
{
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), groupMemberInfo.Id, memberChanges, _group.Name, typeof( Group ), _group.Id );
}
}
// SAVE LOCATIONS
var groupLocationService = new GroupLocationService( rockContext );
// delete any group locations that were removed
var remainingLocationIds = GroupAddresses.Where( a => a.Id > 0 ).Select( a => a.Id ).ToList();
foreach ( var removedLocation in groupLocationService.Queryable( "GroupLocationTypeValue,Location" )
.Where( l => l.GroupId == _group.Id &&
!remainingLocationIds.Contains( l.Id ) ) )
{
History.EvaluateChange( groupChanges,
( removedLocation.GroupLocationTypeValue != null ? removedLocation.GroupLocationTypeValue.Value : "Unknown" ) + " Location",
removedLocation.Location.ToString(), string.Empty );
groupLocationService.Delete( removedLocation );
}
rockContext.SaveChanges();
foreach ( var groupAddressInfo in GroupAddresses.Where( a => a.Id >= 0 ) )
{
Location updatedAddress = null;
if ( groupAddressInfo.LocationIsDirty )
{
updatedAddress = new LocationService( rockContext ).Get( groupAddressInfo.Street1, groupAddressInfo.Street2, groupAddressInfo.City, groupAddressInfo.State, groupAddressInfo.PostalCode, groupAddressInfo.Country );
}
GroupLocation groupLocation = null;
if ( groupAddressInfo.Id > 0 )
{
groupLocation = groupLocationService.Get( groupAddressInfo.Id );
}
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
groupLocation.GroupId = _group.Id;
groupLocationService.Add( groupLocation );
}
History.EvaluateChange(
groupChanges,
"Location Type",
groupLocation.GroupLocationTypeValueId.HasValue ? DefinedValueCache.Read( groupLocation.GroupLocationTypeValueId.Value ).Value : string.Empty,
groupAddressInfo.LocationTypeName );
groupLocation.GroupLocationTypeValueId = groupAddressInfo.LocationTypeId;
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Is Mailing",
groupLocation.IsMailingLocation.ToString(),
groupAddressInfo.IsMailing.ToString() );
groupLocation.IsMailingLocation = groupAddressInfo.IsMailing;
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Is Map Location",
groupLocation.IsMappedLocation.ToString(),
groupAddressInfo.IsLocation.ToString() );
groupLocation.IsMappedLocation = groupAddressInfo.IsLocation;
if ( updatedAddress != null )
{
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Location",
groupLocation.Location != null ? groupLocation.Location.ToString() : string.Empty,
updatedAddress.ToString() );
groupLocation.Location = updatedAddress;
}
rockContext.SaveChanges();
// Add the same locations to any new families created by removing an existing family member
if ( newGroups.Any() )
{
// reload grouplocation for access to child properties
groupLocation = groupLocationService.Get( groupLocation.Id );
foreach ( var newGroup in newGroups )
{
var newGroupLocation = new GroupLocation();
newGroupLocation.GroupId = newGroup.Id;
newGroupLocation.LocationId = groupLocation.LocationId;
newGroupLocation.GroupLocationTypeValueId = groupLocation.GroupLocationTypeValueId;
newGroupLocation.IsMailingLocation = groupLocation.IsMailingLocation;
newGroupLocation.IsMappedLocation = groupLocation.IsMappedLocation;
groupLocationService.Add( newGroupLocation );
}
rockContext.SaveChanges();
}
}
_group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, _group );
_group.SaveAttributeValues( rockContext );
if ( _isFamilyGroupType )
{
foreach ( var fm in _group.Members )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.PersonId,
groupChanges,
_group.Name,
typeof( Group ),
_group.Id );
}
}
Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
} );
}
}
/// <summary>
/// Handles the Click event of the btnMoveGroupMember 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 btnMoveGroupMember_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService( rockContext );
var groupMember = groupMemberService.Get( hfGroupMemberId.Value.AsInteger() );
groupMember.LoadAttributes();
int destGroupId = gpMoveGroupMember.SelectedValue.AsInteger();
var destGroup = new GroupService( rockContext ).Get( destGroupId );
var destGroupMember = groupMemberService.Queryable().Where( a =>
a.GroupId == destGroupId
&& a.PersonId == groupMember.PersonId
&& a.GroupRoleId == grpMoveGroupMember.GroupRoleId ).FirstOrDefault();
if ( destGroupMember != null )
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format( "{0} is already in {1}", groupMember.Person, destGroupMember.Group );
return;
}
if ( !grpMoveGroupMember.GroupRoleId.HasValue )
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format( "Please select a Group Role" );
return;
}
string canDeleteWarning;
if ( !groupMemberService.CanDelete( groupMember, out canDeleteWarning ) )
{
nbMoveGroupMemberWarning.Visible = true;
nbMoveGroupMemberWarning.Text = string.Format( "Unable to remove {0} from {1}: {2}", groupMember.Person, groupMember.Group, canDeleteWarning );
return;
}
destGroupMember = new GroupMember();
destGroupMember.GroupId = destGroupId;
destGroupMember.GroupRoleId = grpMoveGroupMember.GroupRoleId.Value;
destGroupMember.PersonId = groupMember.PersonId;
destGroupMember.LoadAttributes();
foreach ( var attribute in groupMember.Attributes )
{
if ( destGroupMember.Attributes.Any( a => a.Key == attribute.Key && a.Value.FieldTypeId == attribute.Value.FieldTypeId ) )
{
destGroupMember.SetAttributeValue( attribute.Key, groupMember.GetAttributeValue( attribute.Key ) );
}
}
rockContext.WrapTransaction( () =>
{
groupMemberService.Add( destGroupMember );
rockContext.SaveChanges();
destGroupMember.SaveAttributeValues( rockContext );
// move any Note records that were associated with the old groupMember to the new groupMember record
if ( cbMoveGroupMemberMoveNotes.Checked )
{
destGroupMember.Note = groupMember.Note;
int groupMemberEntityTypeId = EntityTypeCache.GetId<Rock.Model.GroupMember>().Value;
var noteService = new NoteService( rockContext );
var groupMemberNotes = noteService.Queryable().Where( a => a.NoteType.EntityTypeId == groupMemberEntityTypeId && a.EntityId == groupMember.Id );
foreach ( var note in groupMemberNotes )
{
note.EntityId = destGroupMember.Id;
}
rockContext.SaveChanges();
}
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
destGroupMember.CalculateRequirements( rockContext, true );
} );
var queryString = new Dictionary<string, string>();
queryString.Add( "GroupMemberId", destGroupMember.Id.ToString() );
this.NavigateToPage( this.RockPage.Guid, queryString );
}
/// <summary>
/// Handles the ItemCommand event of the rGroupMembers control.
/// </summary>
/// <param name="source">The source of the event.</param>
/// <param name="e">The <see cref="System.Web.UI.WebControls.RepeaterCommandEventArgs"/> instance containing the event data.</param>
protected void rGroupMembers_ItemCommand( object source, System.Web.UI.WebControls.RepeaterCommandEventArgs e )
{
if ( CanEdit )
{
int groupMemberId = e.CommandArgument.ToString().AsIntegerOrNull() ?? 0;
if ( groupMemberId != 0 )
{
var rockContext = new RockContext();
var service = new GroupMemberService( rockContext );
var groupMember = service.Get( groupMemberId );
if ( groupMember != null )
{
if ( e.CommandName == "EditRole" )
{
ShowModal( groupMember.Person, groupMember.GroupRoleId, groupMemberId );
}
else if ( e.CommandName == "RemoveRole" )
{
if ( IsKnownRelationships )
{
var inverseGroupMember = service.GetInverseRelationship( groupMember, false );
if ( inverseGroupMember != null )
{
service.Delete( inverseGroupMember );
}
}
service.Delete( groupMember );
rockContext.SaveChanges();
BindData();
}
}
}
}
}
/// <summary>
/// Removes the person from other families, then deletes the other families if nobody is left in them
/// </summary>
/// <param name="familyId">The groupId of the family that they should stay in</param>
/// <param name="personId">The person identifier.</param>
/// <param name="rockContext">The rock context.</param>
public static void RemovePersonFromOtherFamilies( int familyId, int personId, RockContext rockContext )
{
var groupMemberService = new GroupMemberService( rockContext );
var groupService = new GroupService( rockContext );
var familyGroupTypeId = GroupTypeCache.GetFamilyGroupType().Id;
var family = groupService.Get( familyId );
// make sure they belong to the specified family before we delete them from other families
var isFamilyMember = groupMemberService.Queryable().Any( a => a.GroupId == familyId && a.PersonId == personId );
if ( !isFamilyMember )
{
throw new Exception( "Person is not in the specified family" );
}
var memberInOtherFamilies = groupMemberService.Queryable()
.Where( m =>
m.PersonId == personId &&
m.Group.GroupTypeId == familyGroupTypeId &&
m.GroupId != familyId )
.Select( a => new
{
GroupMember = a,
a.Group,
a.GroupRole,
a.GroupId,
a.Person
} )
.ToList();
foreach ( var fm in memberInOtherFamilies )
{
// If the person's giving group id was the family they are being removed from, update it to this new family's id
if ( fm.Person.GivingGroupId == fm.GroupId )
{
var person = fm.Person;
var demographicChanges = new List<string>();
History.EvaluateChange( demographicChanges, "Giving Group", person.GivingGroup.Name, family.Name );
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id,
demographicChanges );
person.GivingGroupId = familyId;
rockContext.SaveChanges();
}
var oldMemberChanges = new List<string>();
History.EvaluateChange( oldMemberChanges, "Role", fm.GroupRole.Name, string.Empty );
History.EvaluateChange( oldMemberChanges, "Family", fm.Group.Name, string.Empty );
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.Person.Id,
oldMemberChanges,
fm.Group.Name,
typeof( Group ),
fm.Group.Id );
groupMemberService.Delete( fm.GroupMember );
rockContext.SaveChanges();
// delete family if it doesn't have anybody in it anymore
var otherFamily = groupService.Queryable()
.Where( g =>
g.Id == fm.GroupId &&
!g.Members.Any() )
.FirstOrDefault();
if ( otherFamily != null )
{
groupService.Delete( otherFamily );
rockContext.SaveChanges();
}
}
}
/// <summary>
/// Handles the Click event of the lbMerge 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 lbMerge_Click( object sender, EventArgs e )
{
if ( MergeData.People.Count < 2 )
{
nbPeople.Visible = true;
return;
}
bool reconfirmRequired = ( MergeData.People.Select( p => p.Email ).Distinct().Count() > 1 && MergeData.People.Where( p => p.HasLogins ).Any() );
GetValuesSelection();
int? primaryPersonId = null;
var oldPhotos = new List<int>();
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var userLoginService = new UserLoginService( rockContext );
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var binaryFileService = new BinaryFileService( rockContext );
var phoneNumberService = new PhoneNumberService( rockContext );
var taggedItemService = new TaggedItemService( rockContext );
Person primaryPerson = personService.Get( MergeData.PrimaryPersonId ?? 0 );
if ( primaryPerson != null )
{
primaryPersonId = primaryPerson.Id;
var changes = new List<string>();
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPerson.Id ) )
{
changes.Add( string.Format( "Merged <span class='field-value'>{0} [ID: {1}]</span> with this record.", p.FullName, p.Id ) );
}
// Photo Id
int? newPhotoId = MergeData.GetSelectedValue( MergeData.GetProperty( "Photo" ) ).Value.AsIntegerOrNull();
if ( !primaryPerson.PhotoId.Equals( newPhotoId ) )
{
changes.Add( "Modified the photo." );
primaryPerson.PhotoId = newPhotoId;
}
primaryPerson.TitleValueId = GetNewIntValue( "Title", changes );
primaryPerson.FirstName = GetNewStringValue( "FirstName", changes );
primaryPerson.NickName = GetNewStringValue( "NickName", changes );
primaryPerson.MiddleName = GetNewStringValue( "MiddleName", changes );
primaryPerson.LastName = GetNewStringValue( "LastName", changes );
primaryPerson.SuffixValueId = GetNewIntValue( "Suffix", changes );
primaryPerson.RecordTypeValueId = GetNewIntValue( "RecordType", changes );
primaryPerson.RecordStatusValueId = GetNewIntValue( "RecordStatus", changes );
primaryPerson.RecordStatusReasonValueId = GetNewIntValue( "RecordStatusReason", changes );
primaryPerson.ConnectionStatusValueId = GetNewIntValue( "ConnectionStatus", changes );
primaryPerson.IsDeceased = GetNewBoolValue( "Deceased", changes ) ?? false;
primaryPerson.Gender = (Gender)GetNewEnumValue( "Gender", typeof( Gender ), changes );
primaryPerson.MaritalStatusValueId = GetNewIntValue( "MaritalStatus", changes );
primaryPerson.SetBirthDate( GetNewDateTimeValue( "BirthDate", changes ) );
primaryPerson.AnniversaryDate = GetNewDateTimeValue( "AnniversaryDate", changes );
primaryPerson.GraduationYear = GetNewIntValue( "GraduationYear", changes );
primaryPerson.Email = GetNewStringValue( "Email", changes );
primaryPerson.IsEmailActive = GetNewBoolValue( "EmailActive", changes ) ?? true;
primaryPerson.EmailNote = GetNewStringValue( "EmailNote", changes );
primaryPerson.EmailPreference = (EmailPreference)GetNewEnumValue( "EmailPreference", typeof( EmailPreference ), changes );
primaryPerson.SystemNote = GetNewStringValue( "InactiveReasonNote", changes );
primaryPerson.SystemNote = GetNewStringValue( "SystemNote", changes );
// Update phone numbers
var phoneTypes = DefinedTypeCache.Read( Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE.AsGuid() ).DefinedValues;
foreach ( var phoneType in phoneTypes )
{
var phoneNumber = primaryPerson.PhoneNumbers.Where( p => p.NumberTypeValueId == phoneType.Id ).FirstOrDefault();
string oldValue = phoneNumber != null ? phoneNumber.Number : string.Empty;
string key = "phone_" + phoneType.Id.ToString();
string newValue = GetNewStringValue( key, changes );
bool phoneNumberDeleted = false;
if ( !oldValue.Equals( newValue, StringComparison.OrdinalIgnoreCase ) )
{
// New phone doesn't match old
if ( !string.IsNullOrWhiteSpace( newValue ) )
{
// New value exists
if ( phoneNumber == null )
{
// Old value didn't exist... create new phone record
phoneNumber = new PhoneNumber { NumberTypeValueId = phoneType.Id };
primaryPerson.PhoneNumbers.Add( phoneNumber );
}
// Update phone number
phoneNumber.Number = newValue;
}
else
{
// New value doesn't exist
if ( phoneNumber != null )
{
// old value existed.. delete it
primaryPerson.PhoneNumbers.Remove( phoneNumber );
phoneNumberService.Delete( phoneNumber );
phoneNumberDeleted = true;
}
}
}
// check to see if IsMessagingEnabled is true for any of the merged people for this number/numbertype
if ( phoneNumber != null && !phoneNumberDeleted && !phoneNumber.IsMessagingEnabled )
{
var personIds = MergeData.People.Select( a => a.Id ).ToList();
var isMessagingEnabled = phoneNumberService.Queryable().Where( a => personIds.Contains( a.PersonId ) && a.Number == phoneNumber.Number && a.NumberTypeValueId == phoneNumber.NumberTypeValueId ).Any( a => a.IsMessagingEnabled );
if ( isMessagingEnabled )
{
phoneNumber.IsMessagingEnabled = true;
}
}
}
// Save the new record
rockContext.SaveChanges();
// Update the attributes
primaryPerson.LoadAttributes( rockContext );
foreach ( var property in MergeData.Properties.Where( p => p.Key.StartsWith( "attr_" ) ) )
{
string attributeKey = property.Key.Substring( 5 );
string oldValue = primaryPerson.GetAttributeValue( attributeKey ) ?? string.Empty;
string newValue = GetNewStringValue( property.Key, changes ) ?? string.Empty;
if ( !oldValue.Equals( newValue ) )
{
var attribute = primaryPerson.Attributes[attributeKey];
Rock.Attribute.Helper.SaveAttributeValue( primaryPerson, attribute, newValue, rockContext );
}
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
primaryPerson.Id, changes );
// Delete the unselected photos
string photoKeeper = primaryPerson.PhotoId.HasValue ? primaryPerson.PhotoId.Value.ToString() : string.Empty;
foreach ( var photoValue in MergeData.Properties
.Where( p => p.Key == "Photo" )
.SelectMany( p => p.Values )
.Where( v => v.Value != "" && v.Value != photoKeeper )
.Select( v => v.Value ) )
{
int photoId = 0;
if ( int.TryParse( photoValue, out photoId ) )
{
var photo = binaryFileService.Get( photoId );
if ( photo != null )
{
string errorMessages;
if ( binaryFileService.CanDelete( photo, out errorMessages ) )
{
binaryFileService.Delete( photo );
}
}
}
}
rockContext.SaveChanges();
// Delete merged person's family records and any families that would be empty after merge
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
// Delete the merged person's phone numbers (we've already updated the primary persons values)
foreach ( var phoneNumber in phoneNumberService.GetByPersonId( p.Id ) )
{
phoneNumberService.Delete( phoneNumber );
}
// If there was more than one email address and user has logins, then set any of the local
// logins ( database & AD ) to require a reconfirmation
if ( reconfirmRequired )
{
foreach ( var login in userLoginService.GetByPersonId( p.Id ) )
{
var component = Rock.Security.AuthenticationContainer.GetComponent( login.EntityType.Name );
if ( component != null && !component.RequiresRemoteAuthentication )
{
login.IsConfirmed = false;
}
}
}
rockContext.SaveChanges();
// Delete the merged person's other family member records and the family if they were the only one in the family
Guid familyGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
foreach ( var familyMember in groupMemberService.Queryable().Where( m => m.PersonId == p.Id && m.Group.GroupType.Guid == familyGuid ) )
{
groupMemberService.Delete( familyMember );
rockContext.SaveChanges();
// Get the family
var family = groupService.Queryable( "Members" ).Where( f => f.Id == familyMember.GroupId ).FirstOrDefault();
if ( !family.Members.Any() )
{
// If there are not any other family members, delete the family record.
// If theres any people that have this group as a giving group, set it to null (the person being merged should be the only one)
foreach ( Person gp in personService.Queryable().Where( g => g.GivingGroupId == family.Id ) )
{
gp.GivingGroupId = null;
}
// save to the database prior to doing groupService.Delete since .Delete quietly might not delete if thinks the Family is used for a GivingGroupId
rockContext.SaveChanges();
// Delete the family
string errorMessage;
if ( groupService.CanDelete( family, out errorMessage ) )
{
var oldFamilyChanges = new List<string>();
History.EvaluateChange( oldFamilyChanges, "Family", family.Name, string.Empty );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
primaryPersonId.Value, oldFamilyChanges, family.Name, typeof( Group ), family.Id );
groupService.Delete( family );
rockContext.SaveChanges();
}
}
}
}
// Flush any security roles that the merged person's other records were a part of
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
foreach ( var groupMember in groupMemberService.Queryable().Where( m => m.PersonId == p.Id ) )
{
Group group = new GroupService( rockContext ).Get( groupMember.GroupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
}
// now that the Merge is complete, the EntitySet can be marked to be deleted by the RockCleanup job
var entitySetService = new EntitySetService( rockContext );
var entitySet = entitySetService.Get( MergeData.EntitySetId );
if ( entitySet != null )
{
entitySet.ExpireDateTime = RockDateTime.Now.AddMinutes(-1);
entitySet.EntitySetPurposeValueId = null;
rockContext.SaveChanges();
}
}
} );
foreach ( var p in MergeData.People.Where( p => p.Id != primaryPersonId.Value ) )
{
// Run merge proc to merge all associated data
var parms = new Dictionary<string, object>();
parms.Add( "OldId", p.Id );
parms.Add( "NewId", primaryPersonId.Value );
DbService.ExecuteCommand( "spCrm_PersonMerge", CommandType.StoredProcedure, parms );
}
NavigateToLinkedPage( "PersonDetailPage", "PersonId", primaryPersonId.Value );
}
void modalAddPerson_SaveClick( object sender, EventArgs e )
{
if ( ppPerson.PersonId.HasValue )
{
int? roleId = grpRole.GroupRoleId;
if ( roleId.HasValue )
{
var rockContext = new RockContext();
var memberService = new GroupMemberService( rockContext );
var group = memberService.Queryable()
.Where( m =>
m.PersonId == Person.Id &&
m.GroupRole.Guid == ownerRoleGuid
)
.Select( m => m.Group )
.FirstOrDefault();
if ( group != null )
{
GroupMember groupMember = null;
int? groupMemberId = hfRoleId.Value.AsIntegerOrNull();
if ( groupMemberId.HasValue )
{
groupMember = memberService.Queryable()
.Where( m => m.Id == groupMemberId.Value )
.FirstOrDefault();
}
if ( groupMember == null )
{
groupMember = new GroupMember();
groupMember.GroupId = group.Id;
memberService.Add( groupMember );
}
GroupMember formerInverseGroupMember = null;
if ( IsKnownRelationships )
{
formerInverseGroupMember = memberService.GetInverseRelationship( groupMember, false, CurrentPersonAlias );
}
groupMember.PersonId = ppPerson.PersonId.Value;
groupMember.GroupRoleId = roleId.Value;
rockContext.SaveChanges();
if ( IsKnownRelationships )
{
var inverseGroupMember = memberService.GetInverseRelationship(
groupMember, bool.Parse( GetAttributeValue( "CreateGroup" ) ), CurrentPersonAlias );
if ( inverseGroupMember != null )
{
rockContext.SaveChanges();
if ( formerInverseGroupMember != null && formerInverseGroupMember.Id != inverseGroupMember.Id )
{
memberService.Delete( formerInverseGroupMember );
rockContext.SaveChanges();
}
}
}
}
}
}
HideDialog();
BindData();
}
/// <summary>
/// Deletes the family's addresses, phone numbers, photos, viewed records, and people.
/// TODO: delete attendance codes for attendance data that's about to be deleted when
/// we delete the person record.
/// </summary>
/// <param name="families">The families.</param>
/// <param name="rockContext">The rock context.</param>
private void DeleteExistingFamilyData( XElement families, RockContext rockContext )
{
PersonService personService = new PersonService( rockContext );
PhoneNumberService phoneNumberService = new PhoneNumberService( rockContext );
PersonViewedService personViewedService = new PersonViewedService( rockContext );
PageViewService pageViewService = new PageViewService( rockContext );
BinaryFileService binaryFileService = new BinaryFileService( rockContext );
PersonAliasService personAliasService = new PersonAliasService( rockContext );
PersonDuplicateService personDuplicateService = new PersonDuplicateService( rockContext );
NoteService noteService = new NoteService( rockContext );
AuthService authService = new AuthService( rockContext );
CommunicationService communicationService = new CommunicationService( rockContext );
CommunicationRecipientService communicationRecipientService = new CommunicationRecipientService( rockContext );
FinancialBatchService financialBatchService = new FinancialBatchService( rockContext );
FinancialTransactionService financialTransactionService = new FinancialTransactionService( rockContext );
PersonPreviousNameService personPreviousNameService = new PersonPreviousNameService( rockContext );
ConnectionRequestService connectionRequestService = new ConnectionRequestService( rockContext );
ConnectionRequestActivityService connectionRequestActivityService = new ConnectionRequestActivityService( rockContext );
// delete the batch data
List<int> imageIds = new List<int>();
foreach ( var batch in financialBatchService.Queryable().Where( b => b.Name.StartsWith( "SampleData" ) ) )
{
imageIds.AddRange( batch.Transactions.SelectMany( t => t.Images ).Select( i => i.BinaryFileId ).ToList() );
financialTransactionService.DeleteRange( batch.Transactions );
financialBatchService.Delete( batch );
}
// delete all transaction images
foreach ( var image in binaryFileService.GetByIds( imageIds ) )
{
binaryFileService.Delete( image );
}
foreach ( var elemFamily in families.Elements( "family" ) )
{
Guid guid = elemFamily.Attribute( "guid" ).Value.Trim().AsGuid();
GroupService groupService = new GroupService( rockContext );
Group family = groupService.Get( guid );
if ( family != null )
{
var groupMemberService = new GroupMemberService( rockContext );
var members = groupMemberService.GetByGroupId( family.Id, true );
// delete the people records
string errorMessage;
List<int> photoIds = members.Select( m => m.Person ).Where( p => p.PhotoId != null ).Select( a => (int)a.PhotoId ).ToList();
foreach ( var person in members.Select( m => m.Person ) )
{
person.GivingGroup = null;
person.GivingGroupId = null;
person.PhotoId = null;
// delete phone numbers
foreach ( var phone in phoneNumberService.GetByPersonId( person.Id ) )
{
if ( phone != null )
{
phoneNumberService.Delete( phone );
}
}
// delete communication recipient
foreach ( var recipient in communicationRecipientService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id ) )
{
communicationRecipientService.Delete( recipient );
}
// delete communication
foreach ( var communication in communicationService.Queryable().Where( c => c.SenderPersonAliasId == person.PrimaryAlias.Id ) )
{
communicationService.Delete( communication );
}
// delete person viewed records
foreach ( var view in personViewedService.GetByTargetPersonId( person.Id ) )
{
personViewedService.Delete( view );
}
// delete page viewed records
foreach ( var view in pageViewService.GetByPersonId( person.Id ) )
{
pageViewService.Delete( view );
}
// delete notes created by them or on their record.
foreach ( var note in noteService.Queryable().Where ( n => n.CreatedByPersonAlias.PersonId == person.Id
|| (n.NoteType.EntityTypeId == _personEntityTypeId && n.EntityId == person.Id ) ) )
{
noteService.Delete( note );
}
// delete previous names on their records
foreach ( var previousName in personPreviousNameService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id ) )
{
personPreviousNameService.Delete( previousName );
}
// delete any GroupMember records they have
foreach ( var groupMember in groupMemberService.Queryable().Where( gm => gm.PersonId == person.Id ) )
{
groupMemberService.Delete( groupMember );
}
//// delete any Authorization data
//foreach ( var auth in authService.Queryable().Where( a => a.PersonId == person.Id ) )
//{
// authService.Delete( auth );
//}
// delete their aliases
foreach ( var alias in personAliasService.Queryable().Where( a => a.PersonId == person.Id ) )
{
foreach ( var duplicate in personDuplicateService.Queryable().Where( d => d.DuplicatePersonAliasId == alias.Id ) )
{
personDuplicateService.Delete( duplicate );
}
personAliasService.Delete( alias );
}
// delete any connection requests tied to them
foreach ( var request in connectionRequestService.Queryable().Where( r => r.PersonAlias.PersonId == person.Id || r.ConnectorPersonAlias.PersonId == person.Id ) )
{
connectionRequestActivityService.DeleteRange( request.ConnectionRequestActivities );
connectionRequestService.Delete( request );
}
// Save these changes so the CanDelete passes the check...
//rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
if ( personService.CanDelete( person, out errorMessage ) )
{
personService.Delete( person );
//rockContext.ChangeTracker.DetectChanges();
//rockContext.SaveChanges( disablePrePostProcessing: true );
}
else
{
throw new Exception( string.Format( "Trying to delete {0}, but: {1}", person.FullName, errorMessage ) );
}
}
//rockContext.ChangeTracker.DetectChanges();
rockContext.SaveChanges( disablePrePostProcessing: true );
// delete all member photos
foreach ( var photo in binaryFileService.GetByIds( photoIds ) )
{
binaryFileService.Delete( photo );
}
DeleteGroupAndMemberData( family, rockContext );
}
}
}
void rGroupMembers_ItemCommand( object source, System.Web.UI.WebControls.RepeaterCommandEventArgs e )
{
int groupMemberId = int.MinValue;
if ( int.TryParse( e.CommandArgument.ToString(), out groupMemberId ) )
{
var rockContext = new RockContext();
var service = new GroupMemberService( rockContext );
var groupMember = service.Get( groupMemberId );
if ( groupMember != null )
{
if ( e.CommandName == "EditRole" )
{
ShowModal(groupMember.Person, groupMember.GroupRoleId, groupMemberId);
}
else if ( e.CommandName == "RemoveRole" )
{
if ( IsKnownRelationships )
{
var inverseGroupMember = service.GetInverseRelationship( groupMember, false, CurrentPersonAlias );
if ( inverseGroupMember != null )
{
service.Delete( inverseGroupMember );
}
}
service.Delete( groupMember );
rockContext.SaveChanges();
BindData();
}
}
}
}
/// <summary>
/// Deletes the group member.
/// </summary>
/// <param name="groupMemberId">The group member identifier.</param>
private void DeleteGroupMember( int groupMemberId )
{
RockContext rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
var groupMember = groupMemberService.Get( groupMemberId );
if ( groupMember != null )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
/// <summary>
/// Handles the Delete event of the gContactList control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Rock.Web.UI.Controls.RowEventArgs"/> instance containing the event data.</param>
protected void gContactList_Delete( object sender, Rock.Web.UI.Controls.RowEventArgs e )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var business = personService.Get( int.Parse( hfBusinessId.Value ) );
int? businessContactRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT ) ) )
.Select( r => r.Id )
.FirstOrDefault();
var groupMemberService = new GroupMemberService( rockContext );
var groupMember = business.GivingGroup.Members.Where( role => role.GroupRoleId == businessContactRoleId && role.PersonId == e.RowKeyId ).FirstOrDefault();
if ( groupMember != null )
{
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
}
BindContactListGrid( business );
}
/// <summary>
/// Executes this instance.
/// </summary>
public void Execute()
{
using ( var rockContext = new RockContext() )
{
var relationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid() );
if ( relationshipGroupType != null )
{
var ownerRole = relationshipGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ) )
.FirstOrDefault();
var friendRole = relationshipGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_FACEBOOK_FRIEND.AsGuid() ) )
.FirstOrDefault();
if ( ownerRole != null && friendRole != null )
{
var userLoginService = new UserLoginService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
// Convert list of facebook ids into list of usernames
var friendUserNames = FacebookIds.Select( i => "FACEBOOK_" + i ).ToList();
// Get the list of person ids associated with friends usernames
var friendPersonIds = userLoginService.Queryable()
.Where( l =>
l.PersonId.HasValue &&
l.PersonId != PersonId &&
friendUserNames.Contains( l.UserName ) )
.Select( l => l.PersonId.Value )
.Distinct()
.ToList();
// Get the person's group id
var personGroup = groupMemberService.Queryable()
.Where( m =>
m.PersonId == PersonId &&
m.GroupRoleId == ownerRole.Id &&
m.Group.GroupTypeId == relationshipGroupType.Id )
.Select( m => m.Group )
.FirstOrDefault();
// Verify that a 'known relationships' type group existed for the person, if not create it
if ( personGroup == null )
{
var groupMember = new GroupMember();
groupMember.PersonId = PersonId;
groupMember.GroupRoleId = ownerRole.Id;
personGroup = new Group();
personGroup.Name = relationshipGroupType.Name;
personGroup.GroupTypeId = relationshipGroupType.Id;
personGroup.Members.Add( groupMember );
var groupService = new GroupService( rockContext );
groupService.Add( personGroup );
rockContext.SaveChanges();
}
// Get the person's relationship group id
var personGroupId = personGroup.Id;
// Get all of the friend's relationship group ids
var friendGroupIds = groupMemberService.Queryable()
.Where( m =>
m.Group.GroupTypeId == relationshipGroupType.Id &&
m.GroupRoleId == ownerRole.Id &&
friendPersonIds.Contains( m.PersonId ) )
.Select( m => m.GroupId )
.Distinct()
.ToList();
// Find all the existing friend relationships in Rock ( both directions )
var existingFriends = groupMemberService.Queryable()
.Where( m =>
m.Group.GroupTypeId == relationshipGroupType.Id && (
( friendPersonIds.Contains( m.PersonId ) && m.GroupId == personGroupId ) ||
( m.PersonId == PersonId && m.GroupId != personGroupId )
) )
.ToList();
// Create temp group members for current Facebook friends
var currentFriends = new List<GroupMember>();
// ( Person > Friend )
foreach ( int personId in friendPersonIds )
{
var groupMember = new GroupMember();
groupMember.GroupId = personGroupId;
groupMember.PersonId = personId;
groupMember.GroupRoleId = friendRole.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
currentFriends.Add( groupMember );
}
// ( Friend > Person )
foreach ( int familyId in friendGroupIds )
{
var groupMember = new GroupMember();
groupMember.GroupId = familyId;
groupMember.PersonId = PersonId;
groupMember.GroupRoleId = friendRole.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
currentFriends.Add( groupMember );
}
// Add any current friends that do not exist in Rock yet
foreach ( var groupMember in currentFriends
.Where( f => !existingFriends.Any( e => e.IsEqualTo( f ) ) ) )
{
groupMemberService.Add( groupMember );
}
// Delete any existing friends that are no longer facebook friends
foreach ( var groupMember in existingFriends
.Where( f => !currentFriends.Any( e => e.IsEqualTo( f ) ) ) )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
}
}
}
/// <summary>
/// Sets the owner.
/// </summary>
/// <param name="business">The business.</param>
private void SetOwner( Person business )
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService( rockContext );
// Find the original owner/business relationships and remove them if they've changed
var ownersKnownRelationshipGroupMember = groupMemberService.Queryable()
.Where( g =>
g.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS ) ) &&
g.PersonId == business.Id )
.FirstOrDefault();
if ( ownersKnownRelationshipGroupMember != null )
{
var businessesKnownRelationshipGroupMember = groupMemberService.GetInverseRelationship( ownersKnownRelationshipGroupMember, false, CurrentPersonAlias );
if ( ppOwner.PersonId != businessesKnownRelationshipGroupMember.PersonId )
{
// the id of the person in the owner person picker doesn't match the id of the person in the businesses known relationship group with the principle role.
var ownersKnownRelationshipGroup = ownersKnownRelationshipGroupMember.Group;
ownersKnownRelationshipGroup.Members.Remove( ownersKnownRelationshipGroupMember );
groupMemberService.Delete( ownersKnownRelationshipGroupMember );
var businessesKnownRelationshipGroup = businessesKnownRelationshipGroupMember.Group;
businessesKnownRelationshipGroup.Members.Remove( businessesKnownRelationshipGroupMember );
groupMemberService.Delete( businessesKnownRelationshipGroupMember );
rockContext.SaveChanges();
SetRelationships( business );
}
}
else
{
SetRelationships( business );
}
}
/// <summary>
/// Handles the SaveClick event of the mdPlaceElsewhere 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 mdPlaceElsewhere_SaveClick( object sender, EventArgs e )
{
using ( var rockContext = new RockContext() )
{
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var groupMember = groupMemberService.Get( hfPlaceElsewhereGroupMemberId.Value.AsInteger() );
if ( groupMember != null )
{
string errorMessage;
if ( !groupMemberService.CanDelete( groupMember, out errorMessage ) )
{
nbPlaceElsewhereWarning.Text = errorMessage;
return;
}
var trigger = _group.GetGroupMemberWorkflowTriggers().FirstOrDefault( a => a.Id == hfPlaceElsewhereTriggerId.Value.AsInteger() );
if ( trigger != null )
{
// create a transaction for the selected trigger
var transaction = new Rock.Transactions.GroupMemberPlacedElsewhereTransaction( groupMember, tbPlaceElsewhereNote.Text, trigger );
// delete the group member from the current group
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
// queue up the transaction
Rock.Transactions.RockQueue.TransactionQueue.Enqueue( transaction );
}
}
mdPlaceElsewhere.Hide();
mdPlaceElsewhere.Visible = false;
BindGroupMembersGrid();
}
}
/// <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;
bool requirePasswordReset = dataMap.GetBoolean( "RequirePasswordReset" );
int groupsSynced = 0;
int groupsChanged = 0;
try
{
// get groups set to sync
GroupService groupService = new GroupService( new RockContext() );
var groupIdsThatSync = groupService.Queryable().Where( g => g.SyncDataViewId != null ).Select( a => a.Id ).ToList();
foreach ( var syncGroupId in groupIdsThatSync )
{
bool hasGroupChanged = false;
// use a fresh rockContext per group so that ChangeTracker doesn't get bogged down
using ( var rockContext = new RockContext() )
{
var syncGroup = new GroupService( rockContext ).Get( syncGroupId );
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
// increase the timeout just in case the dataview source is slow
rockContext.Database.CommandTimeout = 180;
var syncSource = new DataViewService( rockContext ).Get( syncGroup.SyncDataViewId.Value );
// ensure this is a person dataview
bool isPersonDataSet = syncSource.EntityTypeId == EntityTypeCache.Read( typeof( Rock.Model.Person ) ).Id;
if ( isPersonDataSet )
{
SortProperty sortById = new SortProperty();
sortById.Property = "Id";
sortById.Direction = System.Web.UI.WebControls.SortDirection.Ascending;
List<string> errorMessages = new List<string>();
var personService = new PersonService( rockContext );
var parameterExpression = personService.ParameterExpression;
var whereExpression = syncSource.GetExpression( personService, parameterExpression, out errorMessages );
var sourceItems = personService.Get( parameterExpression, whereExpression ).Select( q => q.Id ).ToList();
var targetItems = groupMemberService.Queryable().Where( gm => gm.GroupId == syncGroup.Id ).ToList();
// delete items from the target not in the source
foreach ( var targetItem in targetItems.Where( t => !sourceItems.Contains( t.PersonId ) ) )
{
// made a clone of the person as it will be detached when the group member is deleted. Also
// saving the delete before the email is sent in case an exception occurs so the user doesn't
// get an email everytime the agent runs.
Person recipient = (Person)targetItem.Person.Clone();
groupMemberService.Delete( targetItem );
rockContext.SaveChanges();
hasGroupChanged = true;
if ( syncGroup.ExitSystemEmailId.HasValue )
{
SendExitEmail( syncGroup.ExitSystemEmailId.Value, recipient, syncGroup );
}
}
// add items not in target but in the source
foreach ( var sourceItem in sourceItems.Where( s => !targetItems.Select( t => t.PersonId ).Contains( s ) ) )
{
// add source to target
var newGroupMember = new GroupMember { Id = 0 };
newGroupMember.PersonId = sourceItem;
newGroupMember.Group = syncGroup;
newGroupMember.GroupMemberStatus = GroupMemberStatus.Active;
newGroupMember.GroupRoleId = syncGroup.GroupType.DefaultGroupRoleId ?? syncGroup.GroupType.Roles.FirstOrDefault().Id;
groupMemberService.Add( newGroupMember );
hasGroupChanged = true;
if ( syncGroup.WelcomeSystemEmailId.HasValue )
{
SendWelcomeEmail( syncGroup.WelcomeSystemEmailId.Value, sourceItem, syncGroup, syncGroup.AddUserAccountsDuringSync ?? false, requirePasswordReset );
}
}
if ( hasGroupChanged )
{
groupsChanged++;
}
groupsSynced++;
rockContext.SaveChanges();
if ( hasGroupChanged && ( syncGroup.IsSecurityRole || syncGroup.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) ) )
{
Rock.Security.Role.Flush( syncGroup.Id );
}
}
}
}
var resultMessage = string.Empty;
if ( groupsSynced == 0 )
{
resultMessage = "No groups to sync";
}
else if ( groupsSynced == 1 )
{
resultMessage = "1 group was sync'ed";
}
else
{
resultMessage = string.Format( "{0} groups were sync'ed", groupsSynced );
}
resultMessage += string.Format( " and {0} groups where changed", groupsChanged );
context.Result = resultMessage;
}
catch ( System.Exception ex )
{
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException( ex, context2 );
throw;
}
}
/// <summary>
/// Handles the Click event of the btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
// confirmation was disabled by btnSave on client-side. So if returning without a redirect,
// it should be enabled. If returning with a redirect, the control won't be updated to reflect
// confirmation being enabled, so it's ok to enable it here
confirmExit.Enabled = true;
if ( Page.IsValid )
{
confirmExit.Enabled = true;
RockTransactionScope.WrapTransaction( () =>
{
var rockContext = new RockContext();
var familyService = new GroupService( rockContext );
var familyMemberService = new GroupMemberService( rockContext );
var personService = new PersonService( rockContext );
var historyService = new HistoryService( rockContext );
var familyChanges = new List<string>();
// SAVE FAMILY
_family = familyService.Get( _family.Id );
History.EvaluateChange( familyChanges, "Family Name", _family.Name, tbFamilyName.Text );
_family.Name = tbFamilyName.Text;
int? campusId = cpCampus.SelectedValueAsInt();
if ( _family.CampusId != campusId )
{
History.EvaluateChange( familyChanges, "Campus",
_family.CampusId.HasValue ? CampusCache.Read( _family.CampusId.Value ).Name : string.Empty,
campusId.HasValue ? CampusCache.Read( campusId.Value ).Name : string.Empty );
_family.CampusId = campusId;
}
var familyGroupTypeId = _family.GroupTypeId;
rockContext.SaveChanges();
// SAVE FAMILY MEMBERS
int? recordStatusValueID = ddlRecordStatus.SelectedValueAsInt();
int? reasonValueId = ddlReason.SelectedValueAsInt();
var newFamilies = new List<Group>();
foreach ( var familyMember in FamilyMembers )
{
var memberChanges = new List<string>();
var demographicChanges = new List<string>();
var role = familyRoles.Where( r => r.Guid.Equals( familyMember.RoleGuid ) ).FirstOrDefault();
if ( role == null )
{
role = familyRoles.FirstOrDefault();
}
bool isChild = role != null && role.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) );
// People added to family (new or from other family)
if ( !familyMember.ExistingFamilyMember )
{
var groupMember = new GroupMember();
if ( familyMember.Id == -1 )
{
// added new person
demographicChanges.Add( "Created" );
var person = new Person();
person.FirstName = familyMember.FirstName;
person.NickName = familyMember.NickName;
History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName );
person.LastName = familyMember.LastName;
History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );
person.Gender = familyMember.Gender;
History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );
person.BirthDate = familyMember.BirthDate;
History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );
if ( !isChild )
{
person.GivingGroupId = _family.Id;
History.EvaluateChange( demographicChanges, "Giving Group", string.Empty, _family.Name );
}
person.EmailPreference = EmailPreference.EmailAllowed;
groupMember.Person = person;
}
else
{
// added from other family
groupMember.Person = personService.Get( familyMember.Id );
}
if ( recordStatusValueID > 0 )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
groupMember.Person.RecordStatusValueId = recordStatusValueID;
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
groupMember.Person.RecordStatusReasonValueId = reasonValueId;
}
groupMember.GroupId = _family.Id;
if ( role != null )
{
History.EvaluateChange( memberChanges, "Role", string.Empty, role.Name );
groupMember.GroupRoleId = role.Id;
}
if ( groupMember.Person != null )
{
familyMemberService.Add( groupMember );
rockContext.SaveChanges();
familyMember.Id = groupMember.Person.Id;
}
}
else
{
// existing family members
var groupMember = familyMemberService.Queryable( "Person" ).Where( m =>
m.PersonId == familyMember.Id &&
m.Group.GroupTypeId == familyGroupTypeId &&
m.GroupId == _family.Id ).FirstOrDefault();
if ( groupMember != null )
{
if ( familyMember.Removed )
{
var newFamilyChanges = new List<string>();
// Family member was removed and should be created in their own new family
var newFamily = new Group();
newFamily.Name = familyMember.LastName + " Family";
History.EvaluateChange( newFamilyChanges, "Family", string.Empty, newFamily.Name );
newFamily.GroupTypeId = familyGroupTypeId;
if ( _family.CampusId.HasValue )
{
History.EvaluateChange( newFamilyChanges, "Campus", string.Empty, CampusCache.Read( _family.CampusId.Value ).Name );
}
newFamily.CampusId = _family.CampusId;
familyService.Add( newFamily );
rockContext.SaveChanges();
// If person's previous giving group was this family, set it to their new family id
if ( groupMember.Person.GivingGroup != null && groupMember.Person.GivingGroupId == _family.Id )
{
History.EvaluateChange( demographicChanges, "Giving Group", groupMember.Person.GivingGroup.Name, _family.Name );
groupMember.Person.GivingGroupId = newFamily.Id;
}
groupMember.Group = newFamily;
rockContext.SaveChanges();
var newMemberChanges = new List<string>();
History.EvaluateChange( newMemberChanges, "Role", string.Empty, groupMember.GroupRole.Name );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
groupMember.Person.Id, newFamilyChanges, newFamily.Name, typeof( Group ), newFamily.Id );
newFamilies.Add( newFamily );
History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole.Name, string.Empty );
}
else
{
// Existing member was not remvoved
if ( role != null )
{
History.EvaluateChange( memberChanges, "Role",
groupMember.GroupRole != null ? groupMember.GroupRole.Name : string.Empty, role.Name );
groupMember.GroupRoleId = role.Id;
if ( recordStatusValueID > 0 )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
groupMember.Person.RecordStatusValueId = recordStatusValueID;
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
groupMember.Person.RecordStatusReasonValueId = reasonValueId;
}
rockContext.SaveChanges();
}
}
}
}
// Remove anyone that was moved from another family
if ( familyMember.RemoveFromOtherFamilies )
{
var otherFamilies = familyMemberService.Queryable()
.Where( m =>
m.PersonId == familyMember.Id &&
m.Group.GroupTypeId == familyGroupTypeId &&
m.GroupId != _family.Id )
.ToList();
foreach ( var otherFamilyMember in otherFamilies )
{
var fm = familyMemberService.Get( otherFamilyMember.Id );
// If the person's giving group id was the family they are being removed from, update it to this new family's id
if ( fm.Person.GivingGroupId == fm.GroupId )
{
var person = personService.Get( fm.PersonId );
History.EvaluateChange( demographicChanges, "Giving Group", person.GivingGroup.Name, _family.Name );
person.GivingGroupId = _family.Id;
rockContext.SaveChanges();
}
var oldMemberChanges = new List<string>();
History.EvaluateChange( oldMemberChanges, "Role", fm.GroupRole.Name, string.Empty );
History.EvaluateChange( oldMemberChanges, "Family", fm.Group.Name, string.Empty );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.Person.Id, oldMemberChanges, fm.Group.Name, typeof( Group ), fm.Group.Id );
familyMemberService.Delete( fm );
rockContext.SaveChanges();
var f = familyService.Queryable()
.Where( g =>
g.Id == otherFamilyMember.GroupId &&
!g.Members.Any() )
.FirstOrDefault();
if ( f != null )
{
familyService.Delete( f );
rockContext.SaveChanges();
}
}
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
familyMember.Id, demographicChanges );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
familyMember.Id, memberChanges, _family.Name, typeof( Group ), _family.Id );
}
// SAVE LOCATIONS
var groupLocationService = new GroupLocationService( rockContext );
// delete any group locations that were removed
var remainingLocationIds = FamilyAddresses.Where( a => a.Id > 0 ).Select( a => a.Id ).ToList();
foreach ( var removedLocation in groupLocationService.Queryable( "GroupLocationTypeValue,Location" )
.Where( l => l.GroupId == _family.Id &&
!remainingLocationIds.Contains( l.Id ) ) )
{
History.EvaluateChange( familyChanges, removedLocation.GroupLocationTypeValue.Name + " Location",
removedLocation.Location.ToString(), string.Empty );
groupLocationService.Delete( removedLocation );
}
rockContext.SaveChanges();
foreach ( var familyAddress in FamilyAddresses )
{
Location updatedAddress = null;
if ( familyAddress.LocationIsDirty )
{
updatedAddress = new LocationService( rockContext ).Get(
familyAddress.Street1, familyAddress.Street2, familyAddress.City,
familyAddress.State, familyAddress.Zip );
}
GroupLocation groupLocation = null;
if ( familyAddress.Id > 0 )
{
groupLocation = groupLocationService.Get( familyAddress.Id );
}
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
groupLocation.GroupId = _family.Id;
groupLocationService.Add( groupLocation );
}
History.EvaluateChange( familyChanges, "Location Type",
groupLocation.GroupLocationTypeValueId.HasValue ? DefinedValueCache.Read( groupLocation.GroupLocationTypeValueId.Value ).Name : string.Empty,
familyAddress.LocationTypeName );
groupLocation.GroupLocationTypeValueId = familyAddress.LocationTypeId;
History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Is Mailing",
groupLocation.IsMailingLocation.ToString(), familyAddress.IsMailing.ToString() );
groupLocation.IsMailingLocation = familyAddress.IsMailing;
History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Is Map Location",
groupLocation.IsMappedLocation.ToString(), familyAddress.IsLocation.ToString() );
groupLocation.IsMappedLocation = familyAddress.IsLocation;
if ( updatedAddress != null )
{
History.EvaluateChange( familyChanges, familyAddress.LocationTypeName + " Location",
groupLocation.Location != null ? groupLocation.Location.ToString() : "", updatedAddress.ToString() );
groupLocation.Location = updatedAddress;
}
rockContext.SaveChanges();
// Add the same locations to any new families created by removing an existing family member
if ( newFamilies.Any() )
{
//reload grouplocation for access to child properties
groupLocation = groupLocationService.Get( groupLocation.Id );
foreach ( var newFamily in newFamilies )
{
var newFamilyLocation = new GroupLocation();
newFamilyLocation.GroupId = newFamily.Id;
newFamilyLocation.LocationId = groupLocation.LocationId;
newFamilyLocation.GroupLocationTypeValueId = groupLocation.GroupLocationTypeValueId;
newFamilyLocation.IsMailingLocation = groupLocation.IsMailingLocation;
newFamilyLocation.IsMappedLocation = groupLocation.IsMappedLocation;
groupLocationService.Add( newFamilyLocation );
}
rockContext.SaveChanges();
}
}
foreach ( var fm in _family.Members )
{
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.PersonId, familyChanges, _family.Name, typeof( Group ), _family.Id );
}
_family = familyService.Get( _family.Id );
if ( _family.Members.Any( m => m.PersonId == Person.Id ) )
{
Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
}
else
{
var fm = _family.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 )
.FirstOrDefault();
if ( fm == null )
{
fm = _family.Members
.Where( m =>
m.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) )
.OrderByDescending( m => m.Person.Age )
.FirstOrDefault();
}
if ( fm == null )
{
fm = _family.Members
.OrderByDescending( m => m.Person.Age )
.FirstOrDefault();
}
if ( fm != null )
{
Response.Redirect( string.Format( "~/Person/{0}", fm.PersonId ), false );
}
else
{
Response.Redirect( "~", false );
}
}
} );
}
}
private void OptInOutPerson( RockContext rockContext, Person person, bool optIn )
{
var groupMemberService = new GroupMemberService( rockContext );
var groupMembers = groupMemberService
.Queryable()
.Where( m =>
m.PersonId == person.Id &&
m.Group.Guid.Equals( _optOutGroupGuid.Value ) )
.ToList();
if ( !optIn && !groupMembers.Any() )
{
var optOutGroup = new GroupService( rockContext ).Get( _optOutGroupGuid.Value );
if ( optOutGroup != null )
{
var groupMember = new GroupMember();
groupMember.GroupId = optOutGroup.Id;
groupMember.PersonId = person.Id;
groupMember.GroupRoleId = optOutGroup.GroupType.DefaultGroupRoleId ?? 0;
optOutGroup.Members.Add( groupMember );
}
}
if ( optIn && groupMembers.Any() )
{
foreach ( var groupMember in groupMembers )
{
groupMemberService.Delete( groupMember );
}
}
}