/// <summary> /// Marks the selected people/photos as verified by setting their group member status Active. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected void bbtnVerify_Click( object sender, EventArgs e ) { nbMessage.Visible = true; int count = 0; RockContext rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); Group group = groupService.Get( Rock.SystemGuid.Group.GROUP_PHOTO_REQUEST.AsGuid() ); GroupMember groupMember = null; var itemsSelected = new List<int>(); gList.SelectedKeys.ToList().ForEach( i => itemsSelected.Add( i.ToString().AsInteger() ) ); if ( itemsSelected.Any() ) { foreach ( int currentRowsPersonId in itemsSelected ) { groupMember = group.Members.Where( m => m.PersonId == currentRowsPersonId ).FirstOrDefault(); if ( groupMember != null ) { count++; groupMember.GroupMemberStatus = GroupMemberStatus.Active; } } } if ( count > 0 ) { nbMessage.NotificationBoxType = NotificationBoxType.Success; nbMessage.Text = string.Format( "Verified {0} photo{1}.", count, count > 1 ? "s" : "" ); } else { nbMessage.NotificationBoxType = NotificationBoxType.Warning; nbMessage.Text = "No photos selected."; } rockContext.SaveChanges(); _photoRequestGroup = group; BindGrid(); }
/// <summary> /// Marks the selected people/photos as verified by setting their group member status Active. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> protected void bbtnVerify_Click( object sender, EventArgs e ) { nbMessage.Visible = true; int count = 0; RockContext rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); Group group = groupService.Get( Rock.SystemGuid.Group.GROUP_PHOTO_REQUEST.AsGuid() ); GroupMember groupMember = null; foreach ( GridViewRow row in gList.Rows ) { var cb = row.FindControl( "cbSelected" ) as CheckBox; if ( cb != null && cb.Checked ) { int currentRowsPersonId = (int)gList.DataKeys[row.RowIndex].Value; groupMember = group.Members.Where( m => m.PersonId == currentRowsPersonId ).FirstOrDefault(); if ( groupMember != null ) { count++; groupMember.GroupMemberStatus = GroupMemberStatus.Active; } } } if ( count > 0 ) { nbMessage.NotificationBoxType = NotificationBoxType.Success; nbMessage.Text = string.Format( "Verified {0} photo{1}.", count, count > 1 ? "s" : "" ); } else { nbMessage.NotificationBoxType = NotificationBoxType.Warning; nbMessage.Text = "No changes were made."; } rockContext.SaveChanges(); _photoRequestGroup = group; BindGrid(); }
protected void Page_Load(object sender, EventArgs e) { Guid? rootGroupGuid = GetAttributeValue("RootGroup").AsGuidOrNull(); GroupService gs = new GroupService(new RockContext()); if (rootGroupGuid != null) { var staffGroup = gs.Get(rootGroupGuid.Value); var groupMembers = staffGroup.Members.OrderByDescending(g => g.GroupMemberStatus).Select(m => m.Person).OrderBy(m => m.LastName).ThenBy(m => m.FirstName).ToList(); var groupName = staffGroup.Name.ToString(); this.lblGroupName.Text = groupName; var people = new List<PersonData>(); foreach (var person in groupMembers) { person.LoadAttributes(); people.Add(new PersonData { Name = person.FullName, PhotoUrl = person.PhotoUrl, Position = person.GetAttributeValue("Position") }); } this.rptStaff.DataSource = people; this.rptStaff.DataBind(); } }
/// <summary> /// Adds a KnownRelationship record between the two supplied Guids with the given 'is' relationship type: /// /// Role / inverse Role /// ================================ /// step-parent / step-child /// grandparent / grandchild /// previous-spouse / previous-spouse /// can-check-in / allow-check-in-by /// parent / child /// sibling / sibling /// invited / invited-by /// related / related /// /// ...for xml such as: /// <relationships> /// <relationship a="Ben" personGuid="3C402382-3BD2-4337-A996-9E62F1BAB09D" /// has="step-parent" forGuid="3D7F6605-3666-4AB5-9F4E-D7FEBF93278E" name="Brian" /> /// </relationships> /// /// </summary> /// <param name="elemRelationships"></param> private void AddRelationships( XElement elemRelationships, RockContext rockContext ) { if ( elemRelationships == null ) { return; } Guid ownerRoleGuid = Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid(); Guid knownRelationshipsGroupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid(); var memberService = new GroupMemberService( rockContext ); var groupTypeRoles = new GroupTypeRoleService( rockContext ).Queryable( "GroupType" ) .Where( r => r.GroupType.Guid == knownRelationshipsGroupTypeGuid ).ToList(); //// We have to create (or fetch existing) two groups for each relationship, adding the //// other person as a member of that group with the appropriate GroupTypeRole (GTR): //// * a group with person as owner (GTR) and forPerson as type/role (GTR) //// * a group with forPerson as owner (GTR) and person as inverse-type/role (GTR) foreach ( var elemRelationship in elemRelationships.Elements( "relationship" ) ) { // skip any illegally formatted items if ( elemRelationship.Attribute( "personGuid" ) == null || elemRelationship.Attribute( "forGuid" ) == null || elemRelationship.Attribute( "has" ) == null ) { continue; } Guid personGuid = elemRelationship.Attribute( "personGuid" ).Value.Trim().AsGuid(); Guid forGuid = elemRelationship.Attribute( "forGuid" ).Value.Trim().AsGuid(); int ownerPersonId = _peopleDictionary[personGuid]; int forPersonId = _peopleDictionary[forGuid]; string relationshipType = elemRelationship.Attribute( "has" ).Value.Trim(); int roleId = -1; switch ( relationshipType ) { case "step-parent": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_STEP_PARENT.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "step-child": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_STEP_CHILD.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "can-check-in": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CAN_CHECK_IN.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "allow-check-in-by": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_ALLOW_CHECK_IN_BY.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "grandparent": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_GRANDPARENT.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "grandchild": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_GRANDCHILD.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "invited": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "invited-by": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED_BY.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "previous-spouse": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_PREVIOUS_SPOUSE.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "sibling": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_SIBLING.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "parent": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_PARENT.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "child": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CHILD.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; case "related": roleId = groupTypeRoles.Where( r => r.Guid == Rock.SystemGuid.GroupRole.GROUPROLE_IMPLIED_RELATIONSHIPS_RELATED.AsGuid() ) .Select( r => r.Id ).FirstOrDefault(); break; default: //// throw new NotSupportedException( string.Format( "unknown relationship type {0}", elemRelationship.Attribute( "has" ).Value ) ); // just skip unknown relationship types continue; } // find the person's KnownRelationship "owner" group var knownRelationshipGroup = memberService.Queryable() .Where( m => m.PersonId == ownerPersonId && m.GroupRole.Guid == ownerRoleGuid ) .Select( m => m.Group ) .FirstOrDefault(); // create it if it does not yet exist if ( knownRelationshipGroup == null ) { var ownerRole = new GroupTypeRoleService( rockContext ).Get( ownerRoleGuid ); if ( ownerRole != null && ownerRole.GroupTypeId.HasValue ) { var ownerGroupMember = new GroupMember(); ownerGroupMember.PersonId = ownerPersonId; ownerGroupMember.GroupRoleId = ownerRole.Id; knownRelationshipGroup = new Group(); knownRelationshipGroup.Name = ownerRole.GroupType.Name; knownRelationshipGroup.GroupTypeId = ownerRole.GroupTypeId.Value; knownRelationshipGroup.Members.Add( ownerGroupMember ); var groupService = new GroupService( rockContext ); groupService.Add( knownRelationshipGroup ); //rockContext.ChangeTracker.DetectChanges(); rockContext.SaveChanges( disablePrePostProcessing: true ); knownRelationshipGroup = groupService.Get( knownRelationshipGroup.Id ); } } // Now find (and add if not found) the forPerson as a member with the "has" role-type var groupMember = memberService.Queryable() .Where( m => m.GroupId == knownRelationshipGroup.Id && m.PersonId == forPersonId && m.GroupRoleId == roleId ) .FirstOrDefault(); if ( groupMember == null ) { groupMember = new GroupMember() { GroupId = knownRelationshipGroup.Id, PersonId = forPersonId, GroupRoleId = roleId, }; rockContext.GroupMembers.Add( groupMember ); } // Now create thee inverse relationship. // // (NOTE: Don't panic if your VS tooling complains that there is // an unused variable here. There is no need to do anything with the // inverseGroupMember relationship because it was already added to the // context. All we have to do below is save the changes to the context // when we're ready.) var inverseGroupMember = memberService.GetInverseRelationship( groupMember, createGroup: true ); } }
/// <summary> /// Handles adding groups from the given XML element snippet. /// </summary> /// <param name="elemGroups">The elem groups.</param> /// <param name="rockContext">The rock context.</param> /// <exception cref="System.NotSupportedException"></exception> private void AddGroups( XElement elemGroups, RockContext rockContext ) { // Add groups if ( elemGroups == null ) { return; } GroupService groupService = new GroupService( rockContext ); DefinedTypeCache smallGroupTopicType = DefinedTypeCache.Read( Rock.SystemGuid.DefinedType.SMALL_GROUP_TOPIC.AsGuid() ); // Next create the group along with its members. foreach ( var elemGroup in elemGroups.Elements( "group" ) ) { Guid guid = elemGroup.Attribute( "guid" ).Value.Trim().AsGuid(); string type = elemGroup.Attribute( "type" ).Value; Group group = new Group() { Guid = guid, Name = elemGroup.Attribute( "name" ).Value.Trim(), IsActive = true, IsPublic = true }; // skip any where there is no group type given -- they are invalid entries. if ( string.IsNullOrEmpty( elemGroup.Attribute( "type" ).Value.Trim() ) ) { return; } int? roleId; GroupTypeCache groupType; switch ( elemGroup.Attribute( "type" ).Value.Trim() ) { case "serving": groupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_SERVING_TEAM.AsGuid() ); group.GroupTypeId = groupType.Id; roleId = groupType.DefaultGroupRoleId; break; case "smallgroup": groupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_SMALL_GROUP.AsGuid() ); group.GroupTypeId = groupType.Id; roleId = groupType.DefaultGroupRoleId; break; default: throw new NotSupportedException( string.Format( "unknown group type {0}", elemGroup.Attribute( "type" ).Value.Trim() ) ); } if ( elemGroup.Attribute( "description" ) != null ) { group.Description = elemGroup.Attribute( "description" ).Value; } if ( elemGroup.Attribute( "parentGroupGuid" ) != null ) { var parentGroup = groupService.Get( elemGroup.Attribute( "parentGroupGuid" ).Value.AsGuid() ); if ( parentGroup != null ) { group.ParentGroupId = parentGroup.Id; } } // Set the group's meeting location if ( elemGroup.Attribute( "meetsAtHomeOfFamily" ) != null ) { int meetingLocationValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_MEETING_LOCATION.AsGuid() ).Id; var groupLocation = new GroupLocation() { IsMappedLocation = false, IsMailingLocation = false, GroupLocationTypeValueId = meetingLocationValueId, LocationId = _familyLocationDictionary[elemGroup.Attribute( "meetsAtHomeOfFamily" ).Value.AsGuid()], }; // Set the group location's GroupMemberPersonId if given (required?) if ( elemGroup.Attribute( "meetsAtHomeOfPerson" ) != null ) { groupLocation.GroupMemberPersonAliasId = _peopleAliasDictionary[elemGroup.Attribute( "meetsAtHomeOfPerson" ).Value.AsGuid()]; } group.GroupLocations.Add( groupLocation ); } group.LoadAttributes( rockContext ); // Set the study topic if ( elemGroup.Attribute( "studyTopic" ) != null ) { var topic = elemGroup.Attribute( "studyTopic" ).Value; DefinedValue smallGroupTopicDefinedValue = _smallGroupTopicDefinedType.DefinedValues.FirstOrDefault( a => a.Value == topic ); // add it as new if we didn't find it. if ( smallGroupTopicDefinedValue == null ) { smallGroupTopicDefinedValue = AddDefinedTypeValue( topic, _smallGroupTopicDefinedType, rockContext ); } group.SetAttributeValue( "Topic", smallGroupTopicDefinedValue.Guid.ToString() ); } // Set the schedule and meeting time if ( elemGroup.Attribute( "groupSchedule" ) != null ) { string[] schedule = elemGroup.Attribute( "groupSchedule" ).Value.SplitDelimitedValues( whitespace: false ); if ( schedule[0] == "weekly" ) { var dow = schedule[1]; var time = schedule[2]; AddWeeklySchedule( group, dow, time ); } } // Add each person as a member foreach ( var elemPerson in elemGroup.Elements( "person" ) ) { Guid personGuid = elemPerson.Attribute( "guid" ).Value.Trim().AsGuid(); GroupMember groupMember = new GroupMember(); groupMember.GroupMemberStatus = GroupMemberStatus.Active; if ( elemPerson.Attribute( "isLeader" ) != null ) { bool isLeader = elemPerson.Attribute( "isLeader" ).Value.Trim().AsBoolean(); if ( isLeader ) { var gtLeaderRole = groupType.Roles.Where( r => r.IsLeader ).FirstOrDefault(); if ( gtLeaderRole != null ) { groupMember.GroupRoleId = gtLeaderRole.Id; } } } else { groupMember.GroupRoleId = roleId ?? -1; } groupMember.PersonId = _peopleDictionary[personGuid]; group.Members.Add( groupMember ); } groupService.Add( group ); // Now we have to save changes in order for the attributes to be saved correctly. rockContext.SaveChanges(); group.SaveAttributeValues( rockContext ); if ( !_groupDictionary.ContainsKey( group.Guid ) ) { _groupDictionary.Add( group.Guid, group.Id ); } // Now add any group location schedules LocationService locationService = new LocationService( rockContext ); ScheduleService scheduleService = new ScheduleService( rockContext ); Guid locationTypeMeetingLocationGuid = new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_MEETING_LOCATION ); var locationTypeMeetingLocationId = Rock.Web.Cache.DefinedValueCache.Read( locationTypeMeetingLocationGuid ).Id; foreach ( var elemLocation in elemGroup.Elements( "location" ) ) { Guid locationGuid = elemLocation.Attribute( "guid" ).Value.Trim().AsGuid(); Location location = locationService.Get( locationGuid ); GroupLocation groupLocation = new GroupLocation(); groupLocation.Location = location; groupLocation.GroupLocationTypeValueId = locationTypeMeetingLocationId; group.GroupLocations.Add( groupLocation ); foreach ( var elemSchedule in elemLocation.Elements( "schedule" ) ) { try { Guid scheduleGuid = elemSchedule.Attribute( "guid" ).Value.Trim().AsGuid(); Schedule schedule = scheduleService.Get( scheduleGuid ); groupLocation.Schedules.Add( schedule ); } catch { } } TimeSpan ts = _stopwatch.Elapsed; AppendFormat( "{0:00}:{1:00}.{2:00} group location schedules added<br/>", ts.Minutes, ts.Seconds, ts.Milliseconds / 10 ); } } }
/// <summary> /// Handles the Click event of the btnEdit 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 btnEdit_Click( object sender, EventArgs e ) { GroupService groupService = new GroupService(); Group group = groupService.Get( int.Parse( hfGroupId.Value ) ); ShowEditDetails( group ); }
/// <summary> /// Handles the Click event of the btnCancel 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 btnCancel_Click( object sender, EventArgs e ) { if ( hfGroupId.Value.Equals( "0" ) ) { if ( RockPage.Layout.FileName.Equals( "TwoColumnLeft" ) ) { // Cancelling on Add. Return to tree view with parent category selected var qryParams = new Dictionary<string, string>(); string parentGroupId = PageParameter( "parentGroupId" ); if ( !string.IsNullOrWhiteSpace( parentGroupId ) ) { qryParams["groupId"] = parentGroupId; } NavigateToPage( RockPage.Guid, qryParams ); } else { // Cancelling on Add. Return to Grid NavigateToParentPage(); } } else { // Cancelling on Edit. Return to Details GroupService groupService = new GroupService(); Group group = groupService.Get( int.Parse( hfGroupId.Value ) ); ShowReadonlyDetails( group ); } }
/// <summary> /// Handles the Delete event to delete the photo. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs"/> instance containing the event data.</param> protected void rGrid_Delete( object sender, RowEventArgs e ) { RockContext rockContext = new RockContext(); int currentRowsPersonId = (int)e.RowKeyValues["PersonId"]; GroupService groupService = new GroupService( rockContext ); BinaryFileService binaryFileService = new BinaryFileService( rockContext ); // Set their group member record to Active Group group = groupService.Get( Rock.SystemGuid.Group.GROUP_PHOTO_REQUEST.AsGuid() ); GroupMember groupMember = group.Members.Where( m => m.PersonId == currentRowsPersonId ).FirstOrDefault(); if ( groupMember != null ) { binaryFileService.Delete( groupMember.Person.Photo ); groupMember.GroupMemberStatus = GroupMemberStatus.Active; groupMember.Person.Photo = null; groupMember.Person.PhotoId = null; rockContext.SaveChanges(); _photoRequestGroup = group; BindGrid(); } }
/// <summary> /// Handles the Click event of the btnSaveGroup 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 btnSaveGroup_Click( object sender, EventArgs e ) { var rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); Group group = groupService.Get( _groupId ); if ( group != null && group.IsAuthorized( Authorization.EDIT, CurrentPerson ) ) { group.Name = tbName.Text; group.Description = tbDescription.Text; group.IsActive = cbIsActive.Checked; if ( pnlSchedule.Visible ) { if ( group.Schedule == null ) { group.Schedule = new Schedule(); group.Schedule.iCalendarContent = null; } group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek; group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime; } // set attributes group.LoadAttributes( rockContext ); Rock.Attribute.Helper.GetEditValues( phAttributes, group ); // configure locations if ( GetAttributeValue( "EnableLocationEdit" ).AsBoolean() ) { // get selected location Location location = null; int? memberPersonAliasId = null; if ( LocationTypeTab.Equals( MEMBER_LOCATION_TAB_TITLE ) ) { if ( ddlMember.SelectedValue != null ) { var ids = ddlMember.SelectedValue.Split( new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries ); if ( ids.Length == 2 ) { var dbLocation = new LocationService( rockContext ).Get( int.Parse( ids[0] ) ); if ( dbLocation != null ) { location = dbLocation; } memberPersonAliasId = new PersonAliasService( rockContext ).GetPrimaryAliasId( int.Parse( ids[1] ) ); } } } else { if ( locpGroupLocation.Location != null ) { location = new LocationService( rockContext ).Get( locpGroupLocation.Location.Id ); } } if ( location != null ) { GroupLocation groupLocation = group.GroupLocations.FirstOrDefault(); if ( groupLocation == null ) { groupLocation = new GroupLocation(); group.GroupLocations.Add( groupLocation ); } groupLocation.GroupMemberPersonAliasId = memberPersonAliasId; groupLocation.Location = location; groupLocation.LocationId = groupLocation.Location.Id; groupLocation.GroupLocationTypeValueId = ddlLocationType.SelectedValueAsId(); } } rockContext.SaveChanges(); group.SaveAttributeValues( rockContext ); } this.IsEditingGroup = false; // reload the group info pnlGroupEdit.Visible = false; pnlGroupView.Visible = true; DisplayViewGroup(); }
/// <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 ( string.IsNullOrWhiteSpace( txtFirstName.Text ) || string.IsNullOrWhiteSpace( txtLastName.Text ) || string.IsNullOrWhiteSpace( txtEmail.Text ) ) { ShowError( "Missing Information", "Please enter a value for First Name, Last Name, and Email" ); } else { var rockContext = new RockContext(); var person = GetPerson( rockContext ); if ( person != null ) { Guid? groupGuid = GetAttributeValue( "Group" ).AsGuidOrNull(); if ( groupGuid.HasValue ) { var groupService = new GroupService( rockContext ); var groupMemberService = new GroupMemberService( rockContext ); var group = groupService.Get( groupGuid.Value ); if ( group != null && group.GroupType.DefaultGroupRoleId.HasValue ) { string linkedPage = GetAttributeValue( "ConfirmationPage" ); if ( !string.IsNullOrWhiteSpace( linkedPage ) ) { var member = group.Members.Where( m => m.PersonId == person.Id ).FirstOrDefault(); // If person has not registered or confirmed their registration if ( member == null || member.GroupMemberStatus != GroupMemberStatus.Active ) { Guid confirmationEmailTemplateGuid = Guid.Empty; if ( !Guid.TryParse( GetAttributeValue( "ConfirmationEmail" ), out confirmationEmailTemplateGuid ) ) { confirmationEmailTemplateGuid = Guid.Empty; } if ( member == null ) { member = new GroupMember(); member.GroupId = group.Id; member.PersonId = person.Id; member.GroupRoleId = group.GroupType.DefaultGroupRoleId.Value; // If a confirmation email is configured, set status to Pending otherwise set it to active member.GroupMemberStatus = confirmationEmailTemplateGuid != Guid.Empty ? GroupMemberStatus.Pending : GroupMemberStatus.Active; groupMemberService.Add( member ); rockContext.SaveChanges(); member = groupMemberService.Get( member.Id ); } // Send the confirmation if ( confirmationEmailTemplateGuid != Guid.Empty ) { var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields( this.RockPage, this.CurrentPerson ); mergeFields.Add( "Member", member ); var pageParams = new Dictionary<string, string>(); pageParams.Add( "gm", member.UrlEncodedKey ); var pageReference = new Rock.Web.PageReference( linkedPage, pageParams ); mergeFields.Add( "ConfirmationPage", pageReference.BuildUrl() ); var recipients = new List<RecipientData>(); recipients.Add( new RecipientData( person.Email, mergeFields ) ); Email.Send( confirmationEmailTemplateGuid, recipients, ResolveRockUrl( "~/" ), ResolveRockUrl( "~~/" ) ); } ShowSuccess( GetAttributeValue( "SuccessMessage" ) ); } else { var pageParams = new Dictionary<string, string>(); pageParams.Add( "gm", member.UrlEncodedKey ); var pageReference = new Rock.Web.PageReference( linkedPage, pageParams ); Response.Redirect( pageReference.BuildUrl(), false ); } } else { ShowError( "Configuration Error", "Invalid Confirmation Page setting" ); } } else { ShowError( "Configuration Error", "The configured group does not exist, or it's group type does not have a default role configured." ); } } else { ShowError( "Configuration Error", "Invalid Group setting" ); } } } }
/// <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 ) { bool hasValidationErrors = false; var rockContext = new RockContext(); GroupTypeService groupTypeService = new GroupTypeService( rockContext ); GroupService groupService = new GroupService( rockContext ); AttributeService attributeService = new AttributeService( rockContext ); GroupLocationService groupLocationService = new GroupLocationService( rockContext ); int parentGroupTypeId = hfParentGroupTypeId.ValueAsInt(); var groupTypeUIList = new List<GroupType>(); foreach ( var checkinGroupTypeEditor in phCheckinGroupTypes.Controls.OfType<CheckinGroupTypeEditor>().ToList() ) { var groupType = checkinGroupTypeEditor.GetCheckinGroupType( rockContext ); groupTypeUIList.Add( groupType ); } var groupTypeDBList = new List<GroupType>(); var groupTypesToDelete = new List<GroupType>(); var groupsToDelete = new List<Group>(); var groupTypesToAddUpdate = new List<GroupType>(); var groupsToAddUpdate = new List<Group>(); GroupType parentGroupTypeDB = groupTypeService.Get( parentGroupTypeId ); GroupType parentGroupTypeUI = parentGroupTypeDB.Clone( false ); parentGroupTypeUI.ChildGroupTypes = groupTypeUIList; PopulateDeleteLists( groupTypesToDelete, groupsToDelete, parentGroupTypeDB, parentGroupTypeUI ); PopulateAddUpdateLists( groupTypesToAddUpdate, groupsToAddUpdate, parentGroupTypeUI ); int binaryFileFieldTypeID = FieldTypeCache.Read( Rock.SystemGuid.FieldType.BINARY_FILE.AsGuid() ).Id; rockContext.WrapTransaction( () => { // delete in reverse order to get deepest child items first groupsToDelete.Reverse(); foreach ( var groupToDelete in groupsToDelete ) { groupService.Delete( groupToDelete ); } // delete in reverse order to get deepest child items first groupTypesToDelete.Reverse(); foreach ( var groupTypeToDelete in groupTypesToDelete ) { groupTypeService.Delete( groupTypeToDelete ); } rockContext.SaveChanges(); // Add/Update grouptypes and groups that are in the UI // Note: We'll have to save all the groupTypes without changing the DB value of ChildGroupTypes, then come around again and save the ChildGroupTypes // since the ChildGroupTypes may not exist in the database yet foreach ( GroupType groupTypeUI in groupTypesToAddUpdate ) { GroupType groupTypeDB = groupTypeService.Get( groupTypeUI.Guid ); if ( groupTypeDB == null ) { groupTypeDB = new GroupType(); groupTypeDB.Id = 0; groupTypeDB.Guid = groupTypeUI.Guid; groupTypeDB.IsSystem = false; groupTypeDB.ShowInNavigation = false; groupTypeDB.ShowInGroupList = false; groupTypeDB.TakesAttendance = true; groupTypeDB.AttendanceRule = AttendanceRule.None; groupTypeDB.AttendancePrintTo = PrintTo.Default; groupTypeDB.AllowMultipleLocations = true; groupTypeDB.EnableLocationSchedules = true; } groupTypeDB.Name = groupTypeUI.Name; groupTypeDB.Order = groupTypeUI.Order; groupTypeDB.InheritedGroupTypeId = groupTypeUI.InheritedGroupTypeId; groupTypeDB.Attributes = groupTypeUI.Attributes; groupTypeDB.AttributeValues = groupTypeUI.AttributeValues; if ( groupTypeDB.Id == 0 ) { groupTypeService.Add( groupTypeDB ); } if ( !groupTypeDB.IsValid ) { hasValidationErrors = true; CheckinGroupTypeEditor groupTypeEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupTypeEditor>().First( a => a.GroupTypeGuid == groupTypeDB.Guid ); groupTypeEditor.Expanded = true; return; } rockContext.SaveChanges(); groupTypeDB.SaveAttributeValues( rockContext ); // get fresh from database to make sure we have Id so we can update the CheckinLabel Attributes groupTypeDB = groupTypeService.Get( groupTypeDB.Guid ); // rebuild the CheckinLabel attributes from the UI (brute-force) foreach ( var labelAttributeDB in CheckinGroupTypeEditor.GetCheckinLabelAttributes( groupTypeDB.Attributes, rockContext ) ) { var attribute = attributeService.Get( labelAttributeDB.Value.Guid ); Rock.Web.Cache.AttributeCache.Flush( attribute.Id ); attributeService.Delete( attribute ); } rockContext.SaveChanges(); foreach ( var checkinLabelAttributeInfo in GroupTypeCheckinLabelAttributesState[groupTypeUI.Guid] ) { var attribute = new Rock.Model.Attribute(); attribute.AttributeQualifiers.Add( new AttributeQualifier { Key = "binaryFileType", Value = Rock.SystemGuid.BinaryFiletype.CHECKIN_LABEL } ); attribute.Guid = Guid.NewGuid(); attribute.FieldTypeId = binaryFileFieldTypeID; attribute.EntityTypeId = EntityTypeCache.GetId( typeof( GroupType ) ); attribute.EntityTypeQualifierColumn = "Id"; attribute.EntityTypeQualifierValue = groupTypeDB.Id.ToString(); attribute.DefaultValue = checkinLabelAttributeInfo.BinaryFileGuid.ToString(); attribute.Key = checkinLabelAttributeInfo.AttributeKey; attribute.Name = checkinLabelAttributeInfo.FileName; if ( !attribute.IsValid ) { hasValidationErrors = true; CheckinGroupTypeEditor groupTypeEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupTypeEditor>().First( a => a.GroupTypeGuid == groupTypeDB.Guid ); groupTypeEditor.Expanded = true; return; } attributeService.Add( attribute ); } rockContext.SaveChanges(); } // Add/Update Groups foreach ( var groupUI in groupsToAddUpdate ) { Group groupDB = groupService.Get( groupUI.Guid ); if ( groupDB == null ) { groupDB = new Group(); groupDB.Guid = groupUI.Guid; } groupDB.Name = groupUI.Name; // delete any GroupLocations that were removed in the UI foreach ( var groupLocationDB in groupDB.GroupLocations.ToList() ) { if ( !groupUI.GroupLocations.Select( a => a.LocationId ).Contains( groupLocationDB.LocationId ) ) { groupLocationService.Delete( groupLocationDB ); } } // add any GroupLocations that were added in the UI foreach ( var groupLocationUI in groupUI.GroupLocations ) { if ( !groupDB.GroupLocations.Select( a => a.LocationId ).Contains( groupLocationUI.LocationId ) ) { GroupLocation groupLocationDB = new GroupLocation { LocationId = groupLocationUI.LocationId }; groupDB.GroupLocations.Add( groupLocationDB ); } } groupDB.Order = groupUI.Order; // get GroupTypeId from database in case the groupType is new groupDB.GroupTypeId = groupTypeService.Get( groupUI.GroupType.Guid ).Id; groupDB.Attributes = groupUI.Attributes; groupDB.AttributeValues = groupUI.AttributeValues; if ( groupDB.Id == 0 ) { groupService.Add( groupDB ); } if ( !groupDB.IsValid ) { hasValidationErrors = true; hasValidationErrors = true; CheckinGroupEditor groupEditor = phCheckinGroupTypes.ControlsOfTypeRecursive<CheckinGroupEditor>().First( a => a.GroupGuid == groupDB.Guid ); groupEditor.Expanded = true; return; } rockContext.SaveChanges(); groupDB.SaveAttributeValues(); } /* now that we have all the grouptypes saved, now lets go back and save them again with the current UI ChildGroupTypes */ // save main parentGroupType with current UI ChildGroupTypes parentGroupTypeDB.ChildGroupTypes = new List<GroupType>(); parentGroupTypeDB.ChildGroupTypes.Clear(); foreach ( var childGroupTypeUI in parentGroupTypeUI.ChildGroupTypes ) { var childGroupTypeDB = groupTypeService.Get( childGroupTypeUI.Guid ); parentGroupTypeDB.ChildGroupTypes.Add( childGroupTypeDB ); } rockContext.SaveChanges(); // loop thru all the other GroupTypes in the UI and save their childgrouptypes foreach ( var groupTypeUI in groupTypesToAddUpdate ) { var groupTypeDB = groupTypeService.Get( groupTypeUI.Guid ); groupTypeDB.ChildGroupTypes = new List<GroupType>(); groupTypeDB.ChildGroupTypes.Clear(); foreach ( var childGroupTypeUI in groupTypeUI.ChildGroupTypes ) { var childGroupTypeDB = groupTypeService.Get( childGroupTypeUI.Guid ); groupTypeDB.ChildGroupTypes.Add( childGroupTypeDB ); } } rockContext.SaveChanges(); } ); if ( !hasValidationErrors ) { NavigateToParentPage(); } }
/// <summary> /// Checks the settings. /// </summary> /// <returns></returns> private bool CheckSettings() { _rockContext = _rockContext ?? new RockContext(); _mode = GetAttributeValue( "Mode" ); _autoFill = GetAttributeValue( "AutoFillForm" ).AsBoolean(); tbEmail.Required = _autoFill; string registerButtonText = GetAttributeValue( "RegisterButtonAltText" ); if ( string.IsNullOrWhiteSpace( registerButtonText ) ) { registerButtonText = "Register"; } btnRegister.Text = registerButtonText; var groupService = new GroupService( _rockContext ); bool groupIsFromQryString = true; Guid? groupGuid = GetAttributeValue( "Group" ).AsGuidOrNull(); if ( groupGuid.HasValue ) { _group = groupService.Get( groupGuid.Value ); groupIsFromQryString = false; } if ( _group == null ) { groupGuid = PageParameter( "GroupGuid" ).AsGuidOrNull(); if ( groupGuid.HasValue ) { _group = groupService.Get( groupGuid.Value ); } } if ( _group == null ) { int? groupId = PageParameter( "GroupId" ).AsIntegerOrNull(); if ( groupId.HasValue ) { _group = groupService.Get( groupId.Value ); } } if ( _group == null ) { nbNotice.Heading = "Unknown Group"; nbNotice.Text = "<p>This page requires a valid group id parameter, and there was not one provided.</p>"; return false; } else { if ( groupIsFromQryString && ( _group.IsSecurityRole || _group.GroupType.Guid == Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) ) { nbNotice.Heading = "Invalid Group"; nbNotice.Text = "<p>The selected group is a security group and this block cannot be used to add people to a security group (unless configured for that specific group).</p>"; return false; } else { _defaultGroupRole = _group.GroupType.DefaultGroupRole; } } _dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() ); if ( _dvcConnectionStatus == null ) { nbNotice.Heading = "Invalid Connection Status"; nbNotice.Text = "<p>The selected Connection Status setting does not exist.</p>"; return false; } _dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() ); if ( _dvcRecordStatus == null ) { nbNotice.Heading = "Invalid Record Status"; nbNotice.Text = "<p>The selected Record Status setting does not exist.</p>"; return false; } _married = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_MARITAL_STATUS_MARRIED.AsGuid() ); _homeAddressType = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME.AsGuid() ); _familyType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid() ); _adultRole = _familyType.Roles.FirstOrDefault( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ) ); if ( _married == null || _homeAddressType == null || _familyType == null || _adultRole == null ) { nbNotice.Heading = "Missing System Value"; nbNotice.Text = "<p>There is a missing or invalid system value. Check the settings for Marital Status of 'Married', Location Type of 'Home', Group Type of 'Family', and Family Group Role of 'Adult'.</p>"; return false; } return true; }
/// <summary> /// Adds the registrants to group. /// </summary> /// <param name="rockContext">The rock context.</param> /// <param name="registration">The registration.</param> private void AddRegistrantsToGroup( RockContext rockContext, Registration registration ) { // If the registration instance linkage specified a group to add registrant to, add them if they're not already // part of that group if ( registration.GroupId.HasValue ) { var groupService = new GroupService( rockContext ); var personAliasService = new PersonAliasService( rockContext ); var groupMemberService = new GroupMemberService( rockContext ); var group = groupService.Get( registration.GroupId.Value ); if ( group != null ) { foreach ( var registrant in registration.Registrants.Where( r => r.PersonAliasId.HasValue ).ToList() ) { var personAlias = personAliasService.Get( registrant.PersonAliasId.Value ); GroupMember groupMember = group.Members.Where( m => m.PersonId == personAlias.PersonId ).FirstOrDefault(); if ( groupMember == null ) { groupMember = new GroupMember(); groupMemberService.Add( groupMember ); groupMember.GroupId = group.Id; groupMember.PersonId = personAlias.PersonId; if ( RegistrationTemplate.GroupTypeId.HasValue && RegistrationTemplate.GroupTypeId == group.GroupTypeId && RegistrationTemplate.GroupMemberRoleId.HasValue ) { groupMember.GroupRoleId = RegistrationTemplate.GroupMemberRoleId.Value; groupMember.GroupMemberStatus = RegistrationTemplate.GroupMemberStatus; } else { if ( group.GroupType.DefaultGroupRoleId.HasValue ) { groupMember.GroupRoleId = group.GroupType.DefaultGroupRoleId.Value; } else { groupMember.GroupRoleId = group.GroupType.Roles.Select( r => r.Id ).FirstOrDefault(); } groupMember.GroupMemberStatus = GroupMemberStatus.Active; } } rockContext.SaveChanges(); registrant.GroupMemberId = groupMember != null ? groupMember.Id : (int?)null; rockContext.SaveChanges(); // Set any of the template's group member attributes groupMember.LoadAttributes(); var registrantInfo = RegistrationState.Registrants.FirstOrDefault( r => r.Guid == registrant.Guid ); if ( registrantInfo != null ) { foreach ( var field in RegistrationTemplate.Forms .SelectMany( f => f.Fields .Where( t => t.FieldSource == RegistrationFieldSource.GroupMemberAttribute && t.AttributeId.HasValue ) ) ) { // Find the registrant's value var fieldValue = registrantInfo.FieldValues .Where( f => f.Key == field.Id ) .Select( f => f.Value.FieldValue ) .FirstOrDefault(); if ( fieldValue != null ) { var attribute = AttributeCache.Read( field.AttributeId.Value ); if ( attribute != null ) { string originalValue = groupMember.GetAttributeValue( attribute.Key ); string newValue = fieldValue.ToString(); groupMember.SetAttributeValue( attribute.Key, fieldValue.ToString() ); if ( ( originalValue ?? string.Empty ).Trim() != ( newValue ?? string.Empty ).Trim() ) { string formattedOriginalValue = string.Empty; if ( !string.IsNullOrWhiteSpace( originalValue ) ) { formattedOriginalValue = attribute.FieldType.Field.FormatValue( null, originalValue, attribute.QualifierValues, false ); } string formattedNewValue = string.Empty; if ( !string.IsNullOrWhiteSpace( newValue ) ) { formattedNewValue = attribute.FieldType.Field.FormatValue( null, newValue, attribute.QualifierValues, false ); } Helper.SaveAttributeValue( groupMember, attribute, newValue, rockContext ); } } } } } } } } }
/// <summary> /// Handles the Click event of the lbSave 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 lbSave_Click( object sender, EventArgs e ) { var rockContext = new RockContext(); Rock.Data.RockTransactionScope.WrapTransaction( () => { var personService = new PersonService( rockContext ); var changes = new List<string>(); var business = new Person(); if ( int.Parse( hfBusinessId.Value ) != 0 ) { business = personService.Get( int.Parse( hfBusinessId.Value ) ); } // int? orphanedPhotoId = null; // if ( business.PhotoId != imgPhoto.BinaryFileId ) // { // orphanedPhotoId = business.PhotoId; // business.PhotoId = imgPhoto.BinaryFileId; // if ( orphanedPhotoId.HasValue ) // { // if ( business.PhotoId.HasValue ) // { // changes.Add( "Modified the photo." ); // } // else // { // changes.Add( "Deleted the photo." ); // } // } // else if ( business.PhotoId.HasValue ) // { // changes.Add( "Added a photo." ); // } // } // Business Name History.EvaluateChange( changes, "First Name", business.FirstName, tbBusinessName.Text ); business.FirstName = tbBusinessName.Text; // Phone Number var phoneNumberTypeIds = new List<int>(); var homePhoneTypeId = new DefinedValueService( rockContext ).GetByGuid( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id; if ( !string.IsNullOrWhiteSpace( PhoneNumber.CleanNumber( pnbPhone.Number ) ) ) { var phoneNumber = business.PhoneNumbers.FirstOrDefault( n => n.NumberTypeValueId == homePhoneTypeId ); string oldPhoneNumber = string.Empty; if ( phoneNumber == null ) { phoneNumber = new PhoneNumber { NumberTypeValueId = homePhoneTypeId }; business.PhoneNumbers.Add( phoneNumber ); } else { oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode; } phoneNumber.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode ); phoneNumber.Number = PhoneNumber.CleanNumber( pnbPhone.Number ); phoneNumber.IsMessagingEnabled = cbSms.Checked; phoneNumber.IsUnlisted = cbUnlisted.Checked; phoneNumberTypeIds.Add( homePhoneTypeId ); History.EvaluateChange( changes, string.Format( "{0} Phone", DefinedValueCache.GetName( homePhoneTypeId ) ), oldPhoneNumber, phoneNumber.NumberFormattedWithCountryCode ); } // Remove any blank numbers var phoneNumberService = new PhoneNumberService( rockContext ); foreach ( var phoneNumber in business.PhoneNumbers .Where( n => n.NumberTypeValueId.HasValue && !phoneNumberTypeIds.Contains( n.NumberTypeValueId.Value ) ) .ToList() ) { History.EvaluateChange( changes, string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ), phoneNumber.NumberFormatted, string.Empty ); business.PhoneNumbers.Remove( phoneNumber ); phoneNumberService.Delete( phoneNumber ); } // Record Type - this is always "business". it will never change. business.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid() ).Id; // Record Status int? newRecordStatusId = ddlRecordStatus.SelectedValueAsInt(); History.EvaluateChange( changes, "Record Status", DefinedValueCache.GetName( business.RecordStatusValueId ), DefinedValueCache.GetName( newRecordStatusId ) ); business.RecordStatusValueId = newRecordStatusId; // Record Status Reason int? newRecordStatusReasonId = null; if ( business.RecordStatusValueId.HasValue && business.RecordStatusValueId.Value == DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ) ).Id ) { newRecordStatusReasonId = ddlReason.SelectedValueAsInt(); } History.EvaluateChange( changes, "Record Status Reason", DefinedValueCache.GetName( business.RecordStatusReasonValueId ), DefinedValueCache.GetName( newRecordStatusReasonId ) ); business.RecordStatusReasonValueId = newRecordStatusReasonId; // Email business.IsEmailActive = true; History.EvaluateChange( changes, "Email", business.Email, tbEmail.Text ); business.Email = tbEmail.Text.Trim(); var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum<EmailPreference>(); History.EvaluateChange( changes, "EmailPreference", business.EmailPreference, newEmailPreference ); business.EmailPreference = newEmailPreference; if ( business.IsValid ) { if ( rockContext.SaveChanges() > 0 ) { if ( changes.Any() ) { HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), business.Id, changes ); } // if ( orphanedPhotoId.HasValue ) // { // BinaryFileService binaryFileService = new BinaryFileService( personService.RockContext ); // var binaryFile = binaryFileService.Get( orphanedPhotoId.Value ); // if ( binaryFile != null ) // { // // marked the old images as IsTemporary so they will get cleaned up later // binaryFile.IsTemporary = true; // binaryFileService.Save( binaryFile, CurrentPersonAlias ); // } // } // Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false ); } } // Group var familyGroupType = GroupTypeCache.GetFamilyGroupType(); var groupService = new GroupService( rockContext ); var businessGroup = new Group(); if ( business.GivingGroupId != null ) { businessGroup = groupService.Get( (int)business.GivingGroupId ); } businessGroup.GroupTypeId = familyGroupType.Id; businessGroup.Name = tbBusinessName.Text + " Business"; businessGroup.CampusId = ddlCampus.SelectedValueAsInt(); var knownRelationshipGroup = new Group(); var impliedRelationshipGroup = new Group(); if ( business.GivingGroupId == null ) { groupService.Add( businessGroup ); // If there isn't a Giving Group then there aren't any other groups. // We also need to add the Known Relationship and Implied Relationship groups for this business. var knownRelationshipGroupTypeId = new GroupTypeService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS ) ).Id; knownRelationshipGroup.GroupTypeId = knownRelationshipGroupTypeId; knownRelationshipGroup.Name = "Known Relationship"; groupService.Add( knownRelationshipGroup ); var impliedRelationshipGroupTypeId = new GroupTypeService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_IMPLIED_RELATIONSHIPS ) ).Id; impliedRelationshipGroup.GroupTypeId = impliedRelationshipGroupTypeId; impliedRelationshipGroup.Name = "Implied Relationship"; groupService.Add( impliedRelationshipGroup ); } rockContext.SaveChanges(); // Giving Group int? newGivingGroupId = ddlGivingGroup.SelectedValueAsId(); if ( business.GivingGroupId != newGivingGroupId ) { string oldGivingGroupName = business.GivingGroup != null ? business.GivingGroup.Name : string.Empty; string newGivingGroupName = newGivingGroupId.HasValue ? ddlGivingGroup.Items.FindByValue( newGivingGroupId.Value.ToString() ).Text : string.Empty; History.EvaluateChange( changes, "Giving Group", oldGivingGroupName, newGivingGroupName ); } business.GivingGroup = businessGroup; // GroupMember var groupMemberService = new GroupMemberService( rockContext ); int? adultRoleId = new GroupTypeRoleService( rockContext ).Queryable() .Where( r => r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) ) .Select( r => r.Id ) .FirstOrDefault(); var groupMember = businessGroup.Members.Where( role => role.GroupRoleId == adultRoleId ).FirstOrDefault(); if ( groupMember == null ) { groupMember = new GroupMember(); businessGroup.Members.Add( groupMember ); // If we're in here, then this is a new business. // Add the known relationship and implied relationship GroupMember entries. var knownRelationshipGroupMember = new GroupMember(); knownRelationshipGroupMember.Person = business; knownRelationshipGroupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ).Id; knownRelationshipGroupMember.GroupId = knownRelationshipGroup.Id; knownRelationshipGroup.Members.Add( knownRelationshipGroupMember ); var impliedRelationshipGroupMember = new GroupMember(); impliedRelationshipGroupMember.Person = business; impliedRelationshipGroupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_IMPLIED_RELATIONSHIPS_OWNER.AsGuid() ).Id; impliedRelationshipGroupMember.GroupId = impliedRelationshipGroup.Id; impliedRelationshipGroup.Members.Add( impliedRelationshipGroupMember ); } groupMember.Person = business; groupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ).Id; groupMember.GroupMemberStatus = GroupMemberStatus.Active; // GroupLocation & Location var groupLocationService = new GroupLocationService( rockContext ); var groupLocation = businessGroup.GroupLocations.FirstOrDefault(); if ( groupLocation == null ) { groupLocation = new GroupLocation(); businessGroup.GroupLocations.Add( groupLocation ); } groupLocation.GroupLocationTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME ).Id; var locationService = new LocationService( rockContext ); var location = groupLocation.Location; if ( location == null ) { location = new Location(); groupLocation.Location = location; } location.Street1 = tbStreet1.Text.Trim(); location.Street2 = tbStreet2.Text.Trim(); location.City = tbCity.Text.Trim(); location.State = ddlState.SelectedValue; location.Zip = tbZipCode.Text.Trim(); rockContext.SaveChanges(); hfBusinessId.Value = business.Id.ToString(); // Set the Known Relationships between the Owner and the Business. if ( ppOwner.PersonId != null ) { SetOwner( business ); } } ); NavigateToParentPage(); }
private void BindFamilies() { if ( Person != null && Person.Id > 0 ) { Guid familyGroupGuid = new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY ); using ( _rockContext = new RockContext() ) { var memberService = new GroupMemberService( _rockContext ); var families = memberService.Queryable( true ) .Where( m => m.PersonId == Person.Id && m.Group.GroupType.Guid == familyGroupGuid ) .Select( m => m.Group ) .ToList(); if ( !families.Any() ) { var familyGroupType = GroupTypeCache.GetFamilyGroupType(); if ( familyGroupType != null ) { var groupMember = new GroupMember(); groupMember.PersonId = Person.Id; groupMember.GroupRoleId = familyGroupType.DefaultGroupRoleId.Value; var family = new Group(); family.Name = Person.LastName; family.GroupTypeId = familyGroupType.Id; family.Members.Add( groupMember ); var groupService = new GroupService( _rockContext ); groupService.Add( family ); _rockContext.SaveChanges(); families.Add( groupService.Get( family.Id ) ); } } rptrFamilies.DataSource = families; rptrFamilies.DataBind(); } } }
/// <summary> /// Binds the data. /// </summary> private void BindData() { if ( Person != null && Person.Id > 0 ) { if ( ownerRoleGuid != Guid.Empty ) { 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 && bool.Parse( GetAttributeValue( "CreateGroup" ) ) ) { var role = new GroupTypeRoleService( rockContext ).Get( ownerRoleGuid ); if ( role != null && role.GroupTypeId.HasValue ) { var groupMember = new GroupMember(); groupMember.PersonId = Person.Id; groupMember.GroupRoleId = role.Id; group = new Group(); group.Name = role.GroupType.Name; group.GroupTypeId = role.GroupTypeId.Value; group.Members.Add( groupMember ); var groupService = new GroupService( rockContext ); groupService.Add( group ); rockContext.SaveChanges(); group = groupService.Get( group.Id ); } } if ( group != null ) { if ( group.IsAuthorized( Authorization.VIEW, CurrentPerson ) ) { phGroupTypeIcon.Controls.Clear(); if ( !string.IsNullOrWhiteSpace( group.GroupType.IconCssClass ) ) { phGroupTypeIcon.Controls.Add( new LiteralControl( string.Format( "<i class='{0}'></i>", group.GroupType.IconCssClass ) ) ); } lGroupName.Text = group.Name; phEditActions.Visible = group.IsAuthorized( Authorization.EDIT, CurrentPerson ); // TODO: How many implied relationships should be displayed rGroupMembers.DataSource = new GroupMemberService( rockContext ).GetByGroupId( group.Id ) .Where( m => m.PersonId != Person.Id ) .OrderBy( m => m.Person.LastName ) .ThenBy( m => m.Person.FirstName ) .Take( 50 ) .ToList(); rGroupMembers.DataBind(); } } } } }
/// <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 ); } } }
/// <summary> /// Handles the DeleteGroupClick event of the groupEditor 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 groupEditor_DeleteGroupClick( object sender, EventArgs e ) { CheckinGroupEditor groupEditor = sender as CheckinGroupEditor; GroupService groupService = new GroupService( new RockContext() ); Group groupDB = groupService.Get( groupEditor.GroupGuid ); if ( groupDB != null ) { string errorMessage; if ( !groupService.CanDelete( groupDB, out errorMessage ) ) { nbDeleteWarning.Text = "WARNING - Cannot Delete: " + errorMessage; nbDeleteWarning.Visible = true; return; } } groupEditor.Parent.Controls.Remove( groupEditor ); }
/// <summary> /// Delete all groups found in the given XML. /// </summary> /// <param name="elemGroups">The elem groups.</param> /// <param name="rockContext">The rock context.</param> private void DeleteExistingGroups( XElement elemGroups, RockContext rockContext ) { if ( elemGroups == null ) { return; } GroupService groupService = new GroupService( rockContext ); foreach ( var elemGroup in elemGroups.Elements( "group" ) ) { Guid guid = elemGroup.Attribute( "guid" ).Value.Trim().AsGuid(); Group group = groupService.Get( guid ); if ( group != null ) { DeleteGroupAndMemberData( group, rockContext ); } } }
/// <summary> /// Shows the edit details. /// </summary> /// <param name="group">The group.</param> private void ShowEditDetails( Group group ) { if ( group.Id == 0 ) { lReadOnlyTitle.Text = ActionTitle.Add( Group.FriendlyTypeName ).FormatAsHtmlTitle(); hlInactive.Visible = false; } else { lReadOnlyTitle.Text = group.Name.FormatAsHtmlTitle(); } SetEditMode( true ); tbName.Text = group.Name; tbDescription.Text = group.Description; cbIsSecurityRole.Checked = group.IsSecurityRole; cbIsActive.Checked = group.IsActive; var rockContext = new RockContext(); var groupService = new GroupService( rockContext ); var attributeService = new AttributeService( rockContext ); LoadDropDowns(); gpParentGroup.SetValue( group.ParentGroup ?? groupService.Get( group.ParentGroupId ?? 0 ) ); // GroupType depends on Selected ParentGroup ddlParentGroup_SelectedIndexChanged( null, null ); gpParentGroup.Label = "Parent Group"; if ( group.Id == 0 && ddlGroupType.Items.Count > 1 ) { if ( GetAttributeValue( "LimittoSecurityRoleGroups" ).AsBoolean() ) { // default GroupType for new Group to "Security Roles" if LimittoSecurityRoleGroups var securityRoleGroupType = GroupTypeCache.GetSecurityRoleGroupType(); if ( securityRoleGroupType != null ) { ddlGroupType.SetValue( securityRoleGroupType.Id ); } else { ddlGroupType.SelectedIndex = 0; } } else { // if this is a new group (and not "LimitToSecurityRoleGroups", and there is more than one choice for GroupType, default to no selection so they are forced to choose (vs unintentionallly choosing the default one) ddlGroupType.SelectedIndex = 0; } } else { ddlGroupType.SetValue( group.GroupTypeId ); } ddlCampus.SetValue( group.CampusId ); var groupLocations = new List<GroupLocation>(); foreach ( var groupLocation in group.GroupLocations ) { var groupLocationState = new GroupLocation(); groupLocationState.CopyPropertiesFrom( groupLocation ); if ( groupLocation.Location != null ) { groupLocationState.Location = new Location(); groupLocationState.Location.CopyPropertiesFrom( groupLocation.Location ); } if ( groupLocation.GroupLocationTypeValue != null ) { groupLocationState.GroupLocationTypeValue = new DefinedValue(); groupLocationState.GroupLocationTypeValue.CopyPropertiesFrom( groupLocation.GroupLocationTypeValue ); } groupLocations.Add( groupLocationState ); } GroupLocationsState = new ViewStateList<GroupLocation>(); GroupLocationsState.AddAll( groupLocations ); ShowGroupTypeEditDetails( GroupTypeCache.Read( group.GroupTypeId ), group, true ); // if this block's attribute limit group to SecurityRoleGroups, don't let them edit the SecurityRole checkbox value if ( GetAttributeValue( "LimittoSecurityRoleGroups" ).AsBoolean() ) { cbIsSecurityRole.Enabled = false; cbIsSecurityRole.Checked = true; } string qualifierValue = group.Id.ToString(); GroupMemberAttributesState = new ViewStateList<Attribute>(); GroupMemberAttributesState.AddAll( attributeService.GetByEntityTypeId( new GroupMember().TypeId ).AsQueryable() .Where( a => a.EntityTypeQualifierColumn.Equals( "GroupId", StringComparison.OrdinalIgnoreCase ) && a.EntityTypeQualifierValue.Equals( qualifierValue ) ) .OrderBy( a => a.Order ) .ThenBy( a => a.Name ) .ToList() ); BindGroupMemberAttributesGrid(); BindInheritedAttributes( group.GroupTypeId, attributeService ); }
/// <summary> /// Handles the Delete event of the gGroups control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="RowEventArgs" /> instance containing the event data.</param> protected void gGroups_Delete( object sender, RowEventArgs e ) { var rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); AuthService authService = new AuthService( rockContext ); Group group = groupService.Get( e.RowKeyId ); if ( group != null ) { if ( !group.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) ) { mdGridWarning.Show( "You are not authorized to delete this group", ModalAlertType.Information ); return; } string errorMessage; if ( !groupService.CanDelete( group, out errorMessage ) ) { mdGridWarning.Show( errorMessage, ModalAlertType.Information ); return; } bool isSecurityRoleGroup = group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ); if ( isSecurityRoleGroup ) { Rock.Security.Role.Flush( group.Id ); foreach ( var auth in authService.Queryable().Where( a => a.GroupId == group.Id ).ToList() ) { authService.Delete( auth ); } } groupService.Delete( group ); rockContext.SaveChanges(); if ( isSecurityRoleGroup ) { Rock.Security.Authorization.Flush(); } } BindGrid(); }
/// <summary> /// Gets the expression. /// </summary> /// <param name="entityType">Type of the entity.</param> /// <param name="serviceInstance">The service instance.</param> /// <param name="parameterExpression">The parameter expression.</param> /// <param name="selection">The selection.</param> /// <returns></returns> public override Expression GetExpression( Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection ) { var settings = new GroupBranchFilterSettings( selection ); if ( !settings.IsValid() ) { return null; } var groupService = new GroupService( (RockContext)serviceInstance.Context ); // Get the qualifying Groups. var parentGroup = groupService.Get( settings.ParentGroupId ); var groupIdList = GetGroupBranchKeys( groupService, parentGroup, settings.IncludedGroups ); // Filter by Groups var groupsQry = groupService.Queryable().Where( x => groupIdList.Contains( x.Id ) ); var qry = groupService.Queryable().Where( g => groupsQry.Any( x => x.Id == g.Id ) ); var extractedFilterExpression = FilterExpressionExtractor.Extract<Model.Group>( qry, parameterExpression, "g" ); return extractedFilterExpression; }
/// <summary> /// Loads the groups. /// </summary> private void LoadDropDowns() { var groupEntityType = EntityTypeCache.Read( typeof( Group ) ); var currentGroup = RockPage.GetCurrentContext( groupEntityType ) as Group; var groupIdString = Request.QueryString["groupId"]; if ( groupIdString != null ) { var groupId = groupIdString.AsInteger(); if ( currentGroup == null || currentGroup.Id != groupId ) { currentGroup = SetGroupContext( groupId, false ); } } var parts = ( GetAttributeValue( "GroupFilter" ) ?? string.Empty ).Split( '|' ); Guid? groupTypeGuid = null; Guid? rootGroupGuid = null; if ( parts.Length >= 1 ) { groupTypeGuid = parts[0].AsGuidOrNull(); if ( parts.Length >= 2 ) { rootGroupGuid = parts[1].AsGuidOrNull(); } } var rockContext = new RockContext(); var groupService = new GroupService( rockContext ); var groupTypeService = new GroupTypeService( rockContext ); IQueryable<Group> qryGroups = null; // if rootGroup is set, use that as the filter. Otherwise, use GroupType as the filter if ( rootGroupGuid.HasValue ) { var rootGroup = groupService.Get( rootGroupGuid.Value ); if ( rootGroup != null ) { qryGroups = groupService.GetAllDescendents( rootGroup.Id ).AsQueryable(); } } else if ( groupTypeGuid.HasValue ) { SetGroupTypeContext( groupTypeGuid ); if ( GetAttributeValue( "IncludeGroupTypeChildren" ).AsBoolean() ) { var childGroupTypeGuids = groupTypeService.Queryable().Where( t => t.ParentGroupTypes.Select( p => p.Guid ).Contains( groupTypeGuid.Value ) ) .Select( t => t.Guid ).ToList(); qryGroups = groupService.Queryable().Where( a => childGroupTypeGuids.Contains( a.GroupType.Guid ) ); } else { qryGroups = groupService.Queryable().Where( a => a.GroupType.Guid == groupTypeGuid.Value ); } } // no results if ( qryGroups == null ) { nbSelectGroupTypeWarning.Visible = true; lCurrentSelection.Text = string.Empty; rptGroups.Visible = false; } else { nbSelectGroupTypeWarning.Visible = false; rptGroups.Visible = true; lCurrentSelection.Text = currentGroup != null ? currentGroup.ToString() : GetAttributeValue( "NoGroupText" ); var groupList = qryGroups.OrderBy( a => a.Order ) .ThenBy( a => a.Name ).ToList() .Select( a => new GroupItem() { Name = a.Name, Id = a.Id } ) .ToList(); // check if the group can be unselected if ( !string.IsNullOrEmpty( GetAttributeValue( "ClearSelectionText" ) ) ) { var blankGroup = new GroupItem { Name = GetAttributeValue( "ClearSelectionText" ), Id = Rock.Constants.All.Id }; groupList.Insert( 0, blankGroup ); } rptGroups.DataSource = groupList; rptGroups.DataBind(); } }
/// <summary> /// Raises the <see cref="E:System.Web.UI.Control.Init" /> event. /// </summary> /// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param> protected override void OnInit( EventArgs e ) { base.OnInit( e ); try { var groupGuid = GetAttributeValue( "Group" ).AsGuidOrNull(); string personKey = PageParameter( "Person" ); if ( !groupGuid.HasValue ) { ShowConfigError( "The 'Group' configuration for this block has not been set." ); } else if ( string.IsNullOrWhiteSpace( personKey ) ) { ShowError( "Missing Parameter Value" ); } else { RockContext rockContext = new RockContext(); Person targetPerson = null; targetPerson = new PersonService( rockContext ).GetByUrlEncodedKey( personKey ); if ( targetPerson == null ) { ShowError( "We can't find a record in our system for you." ); } else { GroupService groupService = new GroupService( rockContext ); Group group = groupService.Get( groupGuid.Value ); if ( group == null ) { ShowConfigError( "The 'Group' configuration for this block is incorrect." ); } else { AddOrUpdatePersonInGroup( targetPerson, group, rockContext ); } } } } catch ( System.FormatException ) { ShowError( "Something is wrong with that link. Are you sure you copied it correctly?" ); } catch ( SystemException ex ) { ShowError( ex.Message ); } }
/// <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 ) { int? parentGroupId = null; RockContext rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); AuthService authService = new AuthService( rockContext ); Group group = groupService.Get( int.Parse( hfGroupId.Value ) ); if ( group != null ) { if ( !group.IsAuthorized( Authorization.EDIT, this.CurrentPerson ) ) { mdDeleteWarning.Show( "You are not authorized to delete this group.", ModalAlertType.Information ); return; } parentGroupId = group.ParentGroupId; string errorMessage; if ( !groupService.CanDelete( group, out errorMessage ) ) { mdDeleteWarning.Show( errorMessage, ModalAlertType.Information ); return; } bool isSecurityRoleGroup = group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ); if ( isSecurityRoleGroup ) { Rock.Security.Role.Flush( group.Id ); foreach ( var auth in authService.Queryable().Where( a => a.GroupId == group.Id ).ToList() ) { authService.Delete( auth ); } } groupService.Delete( group ); rockContext.SaveChanges(); if ( isSecurityRoleGroup ) { Rock.Security.Authorization.Flush(); } } // reload page, selecting the deleted group's parent var qryParams = new Dictionary<string, string>(); if ( parentGroupId != null ) { qryParams["GroupId"] = parentGroupId.ToString(); } NavigateToPage( RockPage.Guid, qryParams ); }
/// <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 ) { int? parentGroupId = null; // NOTE: Very similar code in GroupList.gGroups_Delete RockTransactionScope.WrapTransaction( () => { GroupService groupService = new GroupService(); AuthService authService = new AuthService(); Group group = groupService.Get( int.Parse( hfGroupId.Value ) ); if ( group != null ) { parentGroupId = group.ParentGroupId; string errorMessage; if ( !groupService.CanDelete( group, out errorMessage ) ) { mdDeleteWarning.Show( errorMessage, ModalAlertType.Information ); return; } bool isSecurityRoleGroup = group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ); if ( isSecurityRoleGroup ) { Rock.Security.Role.Flush( group.Id ); foreach ( var auth in authService.Queryable().Where( a => a.GroupId.Equals( group.Id ) ).ToList() ) { authService.Delete( auth, CurrentPersonId ); authService.Save( auth, CurrentPersonId ); } } groupService.Delete( group, CurrentPersonId ); groupService.Save( group, CurrentPersonId ); if ( isSecurityRoleGroup ) { Rock.Security.Authorization.Flush(); } } } ); // reload page, selecting the deleted group's parent var qryParams = new Dictionary<string, string>(); if ( parentGroupId != null ) { qryParams["groupId"] = parentGroupId.ToString(); } NavigateToPage( RockPage.Guid, qryParams ); }
/// <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 ) { ParseControls( true ); var rockContext = new RockContext(); var service = new RegistrationTemplateService( rockContext ); RegistrationTemplate RegistrationTemplate = null; int? RegistrationTemplateId = hfRegistrationTemplateId.Value.AsIntegerOrNull(); if ( RegistrationTemplateId.HasValue ) { RegistrationTemplate = service.Get( RegistrationTemplateId.Value ); } bool newTemplate = false; if ( RegistrationTemplate == null ) { newTemplate = true; RegistrationTemplate = new RegistrationTemplate(); } RegistrationNotify notify = RegistrationNotify.None; foreach( ListItem li in cblNotify.Items ) { if ( li.Selected ) { notify = notify | (RegistrationNotify)li.Value.AsInteger(); } } RegistrationTemplate.IsActive = cbIsActive.Checked; RegistrationTemplate.Name = tbName.Text; RegistrationTemplate.CategoryId = cpCategory.SelectedValueAsInt(); RegistrationTemplate.GroupTypeId = gtpGroupType.SelectedGroupTypeId; RegistrationTemplate.GroupMemberRoleId = rpGroupTypeRole.GroupRoleId; RegistrationTemplate.GroupMemberStatus = ddlGroupMemberStatus.SelectedValueAsEnum<GroupMemberStatus>(); RegistrationTemplate.RequiredSignatureDocumentTemplateId = ddlSignatureDocumentTemplate.SelectedValueAsInt(); RegistrationTemplate.SignatureDocumentAction = cbDisplayInLine.Checked ? SignatureDocumentAction.Embed : SignatureDocumentAction.Email; RegistrationTemplate.RegistrationWorkflowTypeId = wtpRegistrationWorkflow.SelectedValueAsInt(); RegistrationTemplate.Notify = notify; RegistrationTemplate.AddPersonNote = cbAddPersonNote.Checked; RegistrationTemplate.LoginRequired = cbLoginRequired.Checked; RegistrationTemplate.AllowExternalRegistrationUpdates = cbAllowExternalUpdates.Checked; RegistrationTemplate.AllowGroupPlacement = cbAllowGroupPlacement.Checked; RegistrationTemplate.AllowMultipleRegistrants = cbMultipleRegistrants.Checked; RegistrationTemplate.MaxRegistrants = nbMaxRegistrants.Text.AsInteger(); RegistrationTemplate.RegistrantsSameFamily = rblRegistrantsInSameFamily.SelectedValueAsEnum<RegistrantsSameFamily>(); RegistrationTemplate.ShowCurrentFamilyMembers = cbShowCurrentFamilyMembers.Checked; RegistrationTemplate.SetCostOnInstance = !tglSetCostOnTemplate.Checked; RegistrationTemplate.Cost = cbCost.Text.AsDecimal(); RegistrationTemplate.MinimumInitialPayment = cbMinimumInitialPayment.Text.AsDecimalOrNull(); RegistrationTemplate.FinancialGatewayId = fgpFinancialGateway.SelectedValueAsInt(); RegistrationTemplate.BatchNamePrefix = txtBatchNamePrefix.Text; RegistrationTemplate.ConfirmationFromName = tbConfirmationFromName.Text; RegistrationTemplate.ConfirmationFromEmail = tbConfirmationFromEmail.Text; RegistrationTemplate.ConfirmationSubject = tbConfirmationSubject.Text; RegistrationTemplate.ConfirmationEmailTemplate = ceConfirmationEmailTemplate.Text; RegistrationTemplate.ReminderFromName = tbReminderFromName.Text; RegistrationTemplate.ReminderFromEmail = tbReminderFromEmail.Text; RegistrationTemplate.ReminderSubject = tbReminderSubject.Text; RegistrationTemplate.ReminderEmailTemplate = ceReminderEmailTemplate.Text; RegistrationTemplate.PaymentReminderFromName = tbPaymentReminderFromName.Text; RegistrationTemplate.PaymentReminderFromEmail = tbPaymentReminderFromEmail.Text; RegistrationTemplate.PaymentReminderSubject = tbPaymentReminderSubject.Text; RegistrationTemplate.PaymentReminderEmailTemplate = cePaymentReminderEmailTemplate.Text; RegistrationTemplate.PaymentReminderTimeSpan = nbPaymentReminderTimeSpan.Text.AsInteger(); RegistrationTemplate.RegistrationTerm = string.IsNullOrWhiteSpace( tbRegistrationTerm.Text ) ? "Registration" : tbRegistrationTerm.Text; RegistrationTemplate.RegistrantTerm = string.IsNullOrWhiteSpace( tbRegistrantTerm.Text ) ? "Registrant" : tbRegistrantTerm.Text; RegistrationTemplate.FeeTerm = string.IsNullOrWhiteSpace( tbFeeTerm.Text ) ? "Additional Options" : tbFeeTerm.Text; RegistrationTemplate.DiscountCodeTerm = string.IsNullOrWhiteSpace( tbDiscountCodeTerm.Text ) ? "Discount Code" : tbDiscountCodeTerm.Text; RegistrationTemplate.SuccessTitle = tbSuccessTitle.Text; RegistrationTemplate.SuccessText = ceSuccessText.Text; if ( !Page.IsValid || !RegistrationTemplate.IsValid ) { return; } foreach ( var form in FormState ) { if ( !form.IsValid ) { return; } if ( FormFieldsState.ContainsKey( form.Guid ) ) { foreach( var formField in FormFieldsState[ form.Guid ]) { if ( !formField.IsValid ) { return; } } } } // Get the valid group member attributes var group = new Group(); group.GroupTypeId = gtpGroupType.SelectedGroupTypeId ?? 0; var groupMember = new GroupMember(); groupMember.Group = group; groupMember.LoadAttributes(); var validGroupMemberAttributeIds = groupMember.Attributes.Select( a => a.Value.Id ).ToList(); // Remove any group member attributes that are not valid based on selected group type foreach( var fieldList in FormFieldsState.Select( s => s.Value ) ) { foreach( var formField in fieldList .Where( a => a.FieldSource == RegistrationFieldSource.GroupMemberAttribute && a.AttributeId.HasValue && !validGroupMemberAttributeIds.Contains( a.AttributeId.Value ) ) .ToList() ) { fieldList.Remove( formField ); } } // Perform Validation var validationErrors = new List<string>(); if ( ( ( RegistrationTemplate.SetCostOnInstance ?? false ) || RegistrationTemplate.Cost > 0 || FeeState.Any() ) && !RegistrationTemplate.FinancialGatewayId.HasValue ) { validationErrors.Add( "A Financial Gateway is required when the registration has a cost or additional fees or is configured to allow instances to set a cost." ); } if ( validationErrors.Any() ) { nbValidationError.Visible = true; nbValidationError.Text = "<ul class='list-unstyled'><li>" + validationErrors.AsDelimited( "</li><li>" ) + "</li></ul>"; } else { // Save the entity field changes to registration template if ( RegistrationTemplate.Id.Equals( 0 ) ) { service.Add( RegistrationTemplate ); } rockContext.SaveChanges(); var attributeService = new AttributeService( rockContext ); var registrationTemplateFormService = new RegistrationTemplateFormService( rockContext ); var registrationTemplateFormFieldService = new RegistrationTemplateFormFieldService( rockContext ); var registrationTemplateDiscountService = new RegistrationTemplateDiscountService( rockContext ); var registrationTemplateFeeService = new RegistrationTemplateFeeService( rockContext ); var registrationRegistrantFeeService = new RegistrationRegistrantFeeService( rockContext ); var groupService = new GroupService( rockContext ); // delete forms that aren't assigned in the UI anymore var formUiGuids = FormState.Select( f => f.Guid ).ToList(); foreach ( var form in registrationTemplateFormService .Queryable() .Where( f => f.RegistrationTemplateId == RegistrationTemplate.Id && !formUiGuids.Contains( f.Guid ) ) ) { foreach( var formField in form.Fields.ToList() ) { form.Fields.Remove( formField ); registrationTemplateFormFieldService.Delete( formField ); } registrationTemplateFormService.Delete( form ); } // delete fields that aren't assigned in the UI anymore var fieldUiGuids = FormFieldsState.SelectMany( a => a.Value).Select( f => f.Guid ).ToList(); foreach ( var formField in registrationTemplateFormFieldService .Queryable() .Where( a => formUiGuids.Contains( a.RegistrationTemplateForm.Guid ) && !fieldUiGuids.Contains( a.Guid ) ) ) { registrationTemplateFormFieldService.Delete( formField ); } // delete discounts that aren't assigned in the UI anymore var discountUiGuids = DiscountState.Select( u => u.Guid ).ToList(); foreach ( var discount in registrationTemplateDiscountService .Queryable() .Where( d => d.RegistrationTemplateId == RegistrationTemplate.Id && !discountUiGuids.Contains( d.Guid ) ) ) { registrationTemplateDiscountService.Delete( discount ); } // delete fees that aren't assigned in the UI anymore var feeUiGuids = FeeState.Select( u => u.Guid ).ToList(); var deletedfees = registrationTemplateFeeService .Queryable() .Where( d => d.RegistrationTemplateId == RegistrationTemplate.Id && !feeUiGuids.Contains( d.Guid ) ) .ToList(); var deletedFeeIds = deletedfees.Select( f => f.Id ).ToList(); foreach ( var registrantFee in registrationRegistrantFeeService .Queryable() .Where( f => deletedFeeIds.Contains( f.RegistrationTemplateFeeId ) ) .ToList() ) { registrationRegistrantFeeService.Delete( registrantFee ); } foreach ( var fee in deletedfees ) { registrationTemplateFeeService.Delete( fee ); } int? entityTypeId = EntityTypeCache.Read( typeof( Rock.Model.RegistrationRegistrant ) ).Id; var qualifierColumn = "RegistrationTemplateId"; var qualifierValue = RegistrationTemplate.Id.ToString(); // Get the registration attributes still in the UI var attributesUI = FormFieldsState .SelectMany( s => s.Value.Where( a => a.FieldSource == RegistrationFieldSource.RegistrationAttribute && a.Attribute != null ) ) .Select( f => f.Attribute ) .ToList(); var selectedAttributeGuids = attributesUI.Select( a => a.Guid ); // Delete the registration attributes that were removed from the UI var attributesDB = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue ); foreach ( var attr in attributesDB.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ).ToList() ) { attributeService.Delete( attr ); Rock.Web.Cache.AttributeCache.Flush( attr.Id ); } rockContext.SaveChanges(); // Save all of the registration attributes still in the UI foreach ( var attr in attributesUI ) { Helper.SaveAttributeEdits( attr, entityTypeId, qualifierColumn, qualifierValue, rockContext ); } // add/updated forms/fields foreach ( var formUI in FormState ) { var form = RegistrationTemplate.Forms.FirstOrDefault( f => f.Guid.Equals( formUI.Guid ) ); if ( form == null ) { form = new RegistrationTemplateForm(); form.Guid = formUI.Guid; RegistrationTemplate.Forms.Add( form ); } form.Name = formUI.Name; form.Order = formUI.Order; if ( FormFieldsState.ContainsKey( form.Guid ) ) { foreach ( var formFieldUI in FormFieldsState[form.Guid] ) { var formField = form.Fields.FirstOrDefault( a => a.Guid.Equals( formFieldUI.Guid ) ); if ( formField == null ) { formField = new RegistrationTemplateFormField(); formField.Guid = formFieldUI.Guid; form.Fields.Add( formField ); } formField.AttributeId = formFieldUI.AttributeId; if ( !formField.AttributeId.HasValue && formFieldUI.FieldSource == RegistrationFieldSource.RegistrationAttribute && formFieldUI.Attribute != null ) { var attr = AttributeCache.Read( formFieldUI.Attribute.Guid, rockContext ); if ( attr != null ) { formField.AttributeId = attr.Id; } } formField.FieldSource = formFieldUI.FieldSource; formField.PersonFieldType = formFieldUI.PersonFieldType; formField.IsInternal = formFieldUI.IsInternal; formField.IsSharedValue = formFieldUI.IsSharedValue; formField.ShowCurrentValue = formFieldUI.ShowCurrentValue; formField.PreText = formFieldUI.PreText; formField.PostText = formFieldUI.PostText; formField.IsGridField = formFieldUI.IsGridField; formField.IsRequired = formFieldUI.IsRequired; formField.Order = formFieldUI.Order; } } } // add/updated discounts foreach ( var discountUI in DiscountState ) { var discount = RegistrationTemplate.Discounts.FirstOrDefault( a => a.Guid.Equals( discountUI.Guid ) ); if ( discount == null ) { discount = new RegistrationTemplateDiscount(); discount.Guid = discountUI.Guid; RegistrationTemplate.Discounts.Add( discount ); } discount.Code = discountUI.Code; discount.DiscountPercentage = discountUI.DiscountPercentage; discount.DiscountAmount = discountUI.DiscountAmount; discount.Order = discountUI.Order; } // add/updated fees foreach ( var feeUI in FeeState ) { var fee = RegistrationTemplate.Fees.FirstOrDefault( a => a.Guid.Equals( feeUI.Guid ) ); if ( fee == null ) { fee = new RegistrationTemplateFee(); fee.Guid = feeUI.Guid; RegistrationTemplate.Fees.Add( fee ); } fee.Name = feeUI.Name; fee.FeeType = feeUI.FeeType; fee.CostValue = feeUI.CostValue; fee.DiscountApplies = feeUI.DiscountApplies; fee.AllowMultiple = feeUI.AllowMultiple; fee.Order = feeUI.Order; } rockContext.SaveChanges(); AttributeCache.FlushEntityAttributes(); // If this is a new template, give the current user and the Registration Administrators role administrative // rights to this template, and staff, and staff like roles edit rights if ( newTemplate ) { RegistrationTemplate.AllowPerson( Authorization.ADMINISTRATE, CurrentPerson, rockContext ); var registrationAdmins = groupService.Get( Rock.SystemGuid.Group.GROUP_EVENT_REGISTRATION_ADMINISTRATORS.AsGuid() ); RegistrationTemplate.AllowSecurityRole( Authorization.ADMINISTRATE, registrationAdmins, rockContext ); var staffLikeUsers = groupService.Get( Rock.SystemGuid.Group.GROUP_STAFF_LIKE_MEMBERS.AsGuid() ); RegistrationTemplate.AllowSecurityRole( Authorization.EDIT, staffLikeUsers, rockContext ); var staffUsers = groupService.Get( Rock.SystemGuid.Group.GROUP_STAFF_MEMBERS.AsGuid() ); RegistrationTemplate.AllowSecurityRole( Authorization.EDIT, staffUsers, rockContext ); } var qryParams = new Dictionary<string, string>(); qryParams["RegistrationTemplateId"] = RegistrationTemplate.Id.ToString(); NavigateToPage( RockPage.Guid, qryParams ); } }
/// <summary> /// Handles the Click event of the btnSave control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param> protected void btnSave_Click( object sender, EventArgs e ) { Group group; bool wasSecurityRole = false; RockContext rockContext = new RockContext(); GroupService groupService = new GroupService( rockContext ); GroupLocationService groupLocationService = new GroupLocationService( rockContext ); AttributeService attributeService = new AttributeService( rockContext ); AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext ); CategoryService categoryService = new CategoryService( rockContext ); if ( ( ddlGroupType.SelectedValueAsInt() ?? 0 ) == 0 ) { ddlGroupType.ShowErrorMessage( Rock.Constants.WarningMessage.CannotBeBlank( GroupType.FriendlyTypeName ) ); return; } int groupId = int.Parse( hfGroupId.Value ); if ( groupId == 0 ) { group = new Group(); group.IsSystem = false; group.Name = string.Empty; } else { group = groupService.Get( groupId ); wasSecurityRole = group.IsSecurityRole; var selectedLocations = GroupLocationsState.Select( l => l.Guid ); foreach ( var groupLocation in group.GroupLocations.Where( l => !selectedLocations.Contains( l.Guid ) ).ToList() ) { group.GroupLocations.Remove( groupLocation ); groupLocationService.Delete( groupLocation ); } } foreach ( var groupLocationState in GroupLocationsState ) { GroupLocation groupLocation = group.GroupLocations.Where( l => l.Guid == groupLocationState.Guid ).FirstOrDefault(); if ( groupLocation == null ) { groupLocation = new GroupLocation(); group.GroupLocations.Add( groupLocation ); } else { groupLocationState.Id = groupLocation.Id; groupLocationState.Guid = groupLocation.Guid; } groupLocation.CopyPropertiesFrom( groupLocationState ); } group.Name = tbName.Text; group.Description = tbDescription.Text; group.CampusId = ddlCampus.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( ddlCampus.SelectedValue ); group.GroupTypeId = int.Parse( ddlGroupType.SelectedValue ); group.ParentGroupId = gpParentGroup.SelectedValue.Equals( None.IdValue ) ? (int?)null : int.Parse( gpParentGroup.SelectedValue ); group.IsSecurityRole = cbIsSecurityRole.Checked; group.IsActive = cbIsActive.Checked; if ( group.ParentGroupId == group.Id ) { gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." ); return; } group.LoadAttributes(); Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group ); if ( !Page.IsValid ) { return; } if ( !group.IsValid ) { // Controls will render the error messages return; } // use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges() RockTransactionScope.WrapTransaction( () => { if ( group.Id.Equals( 0 ) ) { groupService.Add( group ); } rockContext.SaveChanges(); group.SaveAttributeValues( rockContext ); /* Take care of Group Member Attributes */ var entityTypeId = EntityTypeCache.Read( typeof( GroupMember ) ).Id; string qualifierColumn = "GroupId"; string qualifierValue = group.Id.ToString(); // Get the existing attributes for this entity type and qualifier value var attributes = attributeService.Get( entityTypeId, qualifierColumn, qualifierValue ); // Delete any of those attributes that were removed in the UI var selectedAttributeGuids = GroupMemberAttributesState.Select( a => a.Guid ); foreach ( var attr in attributes.Where( a => !selectedAttributeGuids.Contains( a.Guid ) ) ) { Rock.Web.Cache.AttributeCache.Flush( attr.Id ); attributeService.Delete( attr ); } // Update the Attributes that were assigned in the UI foreach ( var attributeState in GroupMemberAttributesState ) { Rock.Attribute.Helper.SaveAttributeEdits( attributeState, entityTypeId, qualifierColumn, qualifierValue, rockContext ); } rockContext.SaveChanges(); } ); if ( group != null && wasSecurityRole ) { if ( !group.IsSecurityRole ) { // if this group was a SecurityRole, but no longer is, flush Rock.Security.Role.Flush( group.Id ); Rock.Security.Authorization.Flush(); } } else { if ( group.IsSecurityRole ) { // new security role, flush Rock.Security.Authorization.Flush(); } } var qryParams = new Dictionary<string, string>(); qryParams["GroupId"] = group.Id.ToString(); NavigateToPage( RockPage.Guid, qryParams ); }
/// <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 ); } } } ); } }
/// <summary> /// Handles the SelectItem event of the gp control. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param> protected void gp_SelectItem( object sender, EventArgs e ) { int groupId = gp.SelectedValueAsId() ?? 0; var groupService = new GroupService(); var group = groupService.Get( groupId ); if ( group != null ) { var groupTypeRoleService = new GroupTypeRoleService(); var list = groupTypeRoleService.Queryable().Where( a => a.GroupTypeId == group.GroupTypeId ).OrderBy( a => a.Order ).ToList(); cblRole.Items.Clear(); foreach ( var item in list ) { cblRole.Items.Add( new ListItem( item.Name, item.Id.ToString() ) ); } cblRole.Visible = list.Count > 0; } else { cblRole.Visible = false; } }