/// <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 ); } } }