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