private void BindFamilies()
{
if ( Person != null && Person.Id > 0 )
{
Guid familyGroupGuid = new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
var memberService = new GroupMemberService();
var families = memberService.Queryable()
.Where( m =>
m.PersonId == Person.Id &&
m.Group.GroupType.Guid == familyGroupGuid
)
.Select( m => m.Group )
.ToList();
if ( !families.Any() )
{
var role = new GroupTypeRoleService().Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) );
if ( role != null && role.GroupTypeId.HasValue )
{
var groupMember = new GroupMember();
groupMember.PersonId = Person.Id;
groupMember.GroupRoleId = role.Id;
var family = new Group();
family.Name = Person.LastName;
family.GroupTypeId = role.GroupTypeId.Value;
family.Members.Add( groupMember );
var groupService = new GroupService();
groupService.Add( family, CurrentPersonId );
groupService.Save( family, CurrentPersonId );
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>
/// Executes this instance.
/// </summary>
public void Execute()
{
using ( var rockContext = new RockContext() )
{
var relationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid() );
if ( relationshipGroupType != null )
{
var ownerRole = relationshipGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ) )
.FirstOrDefault();
var friendRole = relationshipGroupType.Roles
.Where( r => r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_FACEBOOK_FRIEND.AsGuid() ) )
.FirstOrDefault();
if ( ownerRole != null && friendRole != null )
{
var userLoginService = new UserLoginService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
// Convert list of facebook ids into list of usernames
var friendUserNames = FacebookIds.Select( i => "FACEBOOK_" + i ).ToList();
// Get the list of person ids associated with friends usernames
var friendPersonIds = userLoginService.Queryable()
.Where( l =>
l.PersonId.HasValue &&
l.PersonId != PersonId &&
friendUserNames.Contains( l.UserName ) )
.Select( l => l.PersonId.Value )
.Distinct()
.ToList();
// Get the person's group id
var personGroup = groupMemberService.Queryable()
.Where( m =>
m.PersonId == PersonId &&
m.GroupRoleId == ownerRole.Id &&
m.Group.GroupTypeId == relationshipGroupType.Id )
.Select( m => m.Group )
.FirstOrDefault();
// Verify that a 'known relationships' type group existed for the person, if not create it
if ( personGroup == null )
{
var groupMember = new GroupMember();
groupMember.PersonId = PersonId;
groupMember.GroupRoleId = ownerRole.Id;
personGroup = new Group();
personGroup.Name = relationshipGroupType.Name;
personGroup.GroupTypeId = relationshipGroupType.Id;
personGroup.Members.Add( groupMember );
var groupService = new GroupService( rockContext );
groupService.Add( personGroup );
rockContext.SaveChanges();
}
// Get the person's relationship group id
var personGroupId = personGroup.Id;
// Get all of the friend's relationship group ids
var friendGroupIds = groupMemberService.Queryable()
.Where( m =>
m.Group.GroupTypeId == relationshipGroupType.Id &&
m.GroupRoleId == ownerRole.Id &&
friendPersonIds.Contains( m.PersonId ) )
.Select( m => m.GroupId )
.Distinct()
.ToList();
// Find all the existing friend relationships in Rock ( both directions )
var existingFriends = groupMemberService.Queryable()
.Where( m =>
m.Group.GroupTypeId == relationshipGroupType.Id && (
( friendPersonIds.Contains( m.PersonId ) && m.GroupId == personGroupId ) ||
( m.PersonId == PersonId && m.GroupId != personGroupId )
) )
.ToList();
// Create temp group members for current Facebook friends
var currentFriends = new List<GroupMember>();
// ( Person > Friend )
foreach ( int personId in friendPersonIds )
{
var groupMember = new GroupMember();
groupMember.GroupId = personGroupId;
groupMember.PersonId = personId;
groupMember.GroupRoleId = friendRole.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
currentFriends.Add( groupMember );
}
// ( Friend > Person )
foreach ( int familyId in friendGroupIds )
{
var groupMember = new GroupMember();
groupMember.GroupId = familyId;
groupMember.PersonId = PersonId;
groupMember.GroupRoleId = friendRole.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
currentFriends.Add( groupMember );
}
// Add any current friends that do not exist in Rock yet
foreach ( var groupMember in currentFriends
.Where( f => !existingFriends.Any( e => e.IsEqualTo( f ) ) ) )
{
groupMemberService.Add( groupMember );
}
// Delete any existing friends that are no longer facebook friends
foreach ( var groupMember in existingFriends
.Where( f => !currentFriends.Any( e => e.IsEqualTo( f ) ) ) )
{
groupMemberService.Delete( groupMember );
}
rockContext.SaveChanges();
}
}
}
}
private Person GetPersonOrBusiness( Person person )
{
if ( person != null && phGiveAsOption.Visible && !tglGiveAsOption.Checked )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
Group familyGroup = null;
Person business = null;
int? businessId = cblBusiness.SelectedValueAsInt();
if ( businessId.HasValue )
{
business = personService.Get( businessId.Value );
}
if ( business == null )
{
DefinedValueCache dvcConnectionStatus = DefinedValueCache.Read( GetAttributeValue( "ConnectionStatus" ).AsGuid() );
DefinedValueCache dvcRecordStatus = DefinedValueCache.Read( GetAttributeValue( "RecordStatus" ).AsGuid() );
// Create Person
business = new Person();
business.LastName = txtLastName.Text;
business.IsEmailActive = true;
business.EmailPreference = EmailPreference.EmailAllowed;
business.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid() ).Id;
if ( dvcConnectionStatus != null )
{
business.ConnectionStatusValueId = dvcConnectionStatus.Id;
}
if ( dvcRecordStatus != null )
{
business.RecordStatusValueId = dvcRecordStatus.Id;
}
// Create Person/Family
familyGroup = PersonService.SaveNewPerson( business, rockContext, null, false );
// Get the relationship roles to use
var knownRelationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid() );
int businessContactRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
int businessRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
int ownerRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
if ( ownerRoleId > 0 && businessContactRoleId > 0 && businessRoleId > 0 )
{
// get the known relationship group of the business contact
// add the business as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS
var contactKnownRelationshipGroup = groupMemberService.Queryable()
.Where( g =>
g.GroupRoleId == ownerRoleId &&
g.PersonId == person.Id )
.Select( g => g.Group )
.FirstOrDefault();
if ( contactKnownRelationshipGroup == null )
{
// In some cases person may not yet have a know relationship group type
contactKnownRelationshipGroup = new Group();
groupService.Add( contactKnownRelationshipGroup );
contactKnownRelationshipGroup.Name = "Known Relationship";
contactKnownRelationshipGroup.GroupTypeId = knownRelationshipGroupType.Id;
var ownerMember = new GroupMember();
ownerMember.PersonId = person.Id;
ownerMember.GroupRoleId = ownerRoleId;
contactKnownRelationshipGroup.Members.Add( ownerMember );
}
var groupMember = new GroupMember();
groupMember.PersonId = business.Id;
groupMember.GroupRoleId = businessRoleId;
contactKnownRelationshipGroup.Members.Add( groupMember );
// get the known relationship group of the business
// add the business contact as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT
var businessKnownRelationshipGroup = groupMemberService.Queryable()
.Where( g =>
g.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) ) &&
g.PersonId == business.Id )
.Select( g => g.Group )
.FirstOrDefault();
if ( businessKnownRelationshipGroup == null )
{
// In some cases business may not yet have a know relationship group type
businessKnownRelationshipGroup = new Group();
groupService.Add( businessKnownRelationshipGroup );
businessKnownRelationshipGroup.Name = "Known Relationship";
businessKnownRelationshipGroup.GroupTypeId = knownRelationshipGroupType.Id;
var ownerMember = new GroupMember();
ownerMember.PersonId = business.Id;
ownerMember.GroupRoleId = ownerRoleId;
businessKnownRelationshipGroup.Members.Add( ownerMember );
}
var businessGroupMember = new GroupMember();
businessGroupMember.PersonId = person.Id;
businessGroupMember.GroupRoleId = businessContactRoleId;
businessKnownRelationshipGroup.Members.Add( businessGroupMember );
rockContext.SaveChanges();
}
}
business.LastName = txtBusinessName.Text;
business.Email = txtEmail.Text;
if ( GetAttributeValue( "DisplayPhone" ).AsBooleanOrNull() ?? false )
{
var numberTypeId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_WORK ) ).Id;
var phone = business.PhoneNumbers.FirstOrDefault( p => p.NumberTypeValueId == numberTypeId );
if ( phone == null )
{
phone = new PhoneNumber();
business.PhoneNumbers.Add( phone );
phone.NumberTypeValueId = numberTypeId;
}
phone.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phone.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
}
if ( familyGroup == null )
{
var groupLocationService = new GroupLocationService( rockContext );
if ( GroupLocationId.HasValue )
{
familyGroup = groupLocationService.Queryable()
.Where( gl => gl.Id == GroupLocationId.Value )
.Select( gl => gl.Group )
.FirstOrDefault();
}
else
{
familyGroup = personService.GetFamilies( business.Id ).FirstOrDefault();
}
}
rockContext.SaveChanges();
if ( familyGroup != null )
{
GroupService.AddNewGroupAddress(
rockContext,
familyGroup,
Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_WORK,
acAddress.Street1, acAddress.Street2, acAddress.City, acAddress.State, acAddress.PostalCode, acAddress.Country,
false );
}
return business;
}
return person;
}
/// <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>
/// 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>
/// Gets the person.
/// </summary>
/// <param name="create">if set to <c>true</c> [create].</param>
/// <returns></returns>
private Person GetPerson( bool create )
{
Person person = null;
int personId = ViewState["PersonId"] as int? ?? 0;
if ( personId == 0 && TargetPerson != null )
{
person = TargetPerson;
}
else
{
using ( new UnitOfWorkScope() )
{
var personService = new PersonService();
if ( personId != 0 )
{
person = personService.Get( personId );
}
if ( person == null && create )
{
// Check to see if there's only one person with same email, first name, and last name
if ( !string.IsNullOrWhiteSpace( txtEmail.Text ) &&
!string.IsNullOrWhiteSpace( txtFirstName.Text ) &&
!string.IsNullOrWhiteSpace( txtLastName.Text ) )
{
var personMatches = personService.GetByEmail( txtEmail.Text ).Where( p =>
p.LastName.Equals( txtLastName.Text, StringComparison.OrdinalIgnoreCase ) &&
( p.FirstName.Equals( txtFirstName.Text, StringComparison.OrdinalIgnoreCase ) ||
p.NickName.Equals( txtFirstName.Text, StringComparison.OrdinalIgnoreCase ) ) );
if ( personMatches.Count() == 1 )
{
person = personMatches.FirstOrDefault();
}
}
if ( person == null )
{
// Create Person
person = new Person();
person.FirstName = txtFirstName.Text;
person.LastName = txtLastName.Text;
person.Email = txtEmail.Text;
bool displayPhone = false;
if ( bool.TryParse( GetAttributeValue( "DisplayPhone" ), out displayPhone ) && displayPhone )
{
var phone = new PhoneNumber();
phone.Number = txtPhone.Text.AsNumeric();
phone.NumberTypeValueId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id;
person.PhoneNumbers.Add( phone );
}
// Create Family Role
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRole = new GroupTypeRoleService().Get(new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) );
// Create Family
var group = new Group();
group.Members.Add( groupMember );
group.Name = person.LastName + " Family";
group.GroupTypeId = GroupTypeCache.GetFamilyGroupType().Id;
var groupLocation = new GroupLocation();
var location = new LocationService().Get(
txtStreet.Text, string.Empty, txtCity.Text, ddlState.SelectedValue, txtZip.Text );
if ( location != null )
{
Guid addressTypeGuid = Guid.Empty;
if ( !Guid.TryParse( GetAttributeValue( "AddressType" ), out addressTypeGuid ) )
{
addressTypeGuid = new Guid( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME );
}
groupLocation = new GroupLocation();
groupLocation.Location = location;
groupLocation.GroupLocationTypeValueId = DefinedValueCache.Read( addressTypeGuid ).Id;
group.GroupLocations.Add( groupLocation );
}
var groupService = new GroupService();
groupService.Add( group, CurrentPersonId );
groupService.Save( group, CurrentPersonId );
}
ViewState["PersonId"] = person != null ? person.Id : 0;
}
}
}
return person;
}
/// <summary>
/// Adds a person alias, known relationship group, implied relationship group, and optionally a family group for
/// a new person.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="campusId">The campus identifier.</param>
/// <param name="savePersonAttributes">if set to <c>true</c> [save person attributes].</param>
/// <returns>Family Group</returns>
public static Group SaveNewPerson ( Person person, RockContext rockContext, int? campusId = null, bool savePersonAttributes = false )
{
// Create/Save Known Relationship Group
var knownRelationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS );
if ( knownRelationshipGroupType != null )
{
var ownerRole = knownRelationshipGroupType.Roles
.FirstOrDefault( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ) );
if ( ownerRole != null )
{
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRoleId = ownerRole.Id;
var group = new Group();
group.Name = knownRelationshipGroupType.Name;
group.GroupTypeId = knownRelationshipGroupType.Id;
group.Members.Add( groupMember );
var groupService = new GroupService( rockContext );
groupService.Add( group );
}
}
// Create/Save Implied Relationship Group
var impliedRelationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_IMPLIED_RELATIONSHIPS );
if ( impliedRelationshipGroupType != null )
{
var ownerRole = impliedRelationshipGroupType.Roles
.FirstOrDefault( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_IMPLIED_RELATIONSHIPS_OWNER.AsGuid() ) );
if ( ownerRole != null )
{
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRoleId = ownerRole.Id;
var group = new Group();
group.Name = impliedRelationshipGroupType.Name;
group.GroupTypeId = impliedRelationshipGroupType.Id;
group.Members.Add( groupMember );
var groupService = new GroupService( rockContext );
groupService.Add( group );
}
}
// Create/Save family
var familyGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY );
if ( familyGroupType != null )
{
var adultRole = familyGroupType.Roles
.FirstOrDefault( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ) );
if ( adultRole != null )
{
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRoleId = adultRole.Id;
var groupMembers = new List<GroupMember>();
groupMembers.Add( groupMember );
return GroupService.SaveNewFamily( rockContext, groupMembers, campusId, savePersonAttributes );
}
}
return null;
}
private void CheckinGroupRow_AddGroupClick( object sender, EventArgs e )
{
var parentRow = sender as CheckinGroupRow;
parentRow.Expanded = true;
using ( var rockContext = new RockContext() )
{
var groupService = new GroupService( rockContext );
var parentGroup = groupService.Get( parentRow.GroupGuid );
if ( parentGroup != null )
{
Guid newGuid = Guid.NewGuid();
var checkinGroup = new Group();
checkinGroup.Guid = newGuid;
checkinGroup.GroupTypeId = parentGroup.GroupTypeId;
checkinGroup.Name = "New Group";
checkinGroup.IsActive = true;
checkinGroup.IsPublic = true;
checkinGroup.IsSystem = false;
checkinGroup.Order = parentGroup.Groups.Any() ? parentGroup.Groups.Max( t => t.Order ) + 1 : 0;
checkinGroup.ParentGroupId = parentGroup.Id;
groupService.Add( checkinGroup );
rockContext.SaveChanges();
Rock.CheckIn.KioskDevice.FlushAll();
SelectGroup( newGuid );
}
}
BuildRows();
}
/// <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;
bool triggersUpdated = false;
RockContext rockContext = new RockContext();
GroupService groupService = new GroupService( rockContext );
GroupLocationService groupLocationService = new GroupLocationService( rockContext );
GroupRequirementService groupRequirementService = new GroupRequirementService( rockContext );
GroupMemberWorkflowTriggerService groupMemberWorkflowTriggerService = new GroupMemberWorkflowTriggerService( rockContext );
ScheduleService scheduleService = new ScheduleService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService attributeQualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
var roleGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() );
int roleGroupTypeId = roleGroupType != null ? roleGroupType.Id : int.MinValue;
if ( CurrentGroupTypeId == 0 )
{
ddlGroupType.ShowErrorMessage( Rock.Constants.WarningMessage.CannotBeBlank( GroupType.FriendlyTypeName ) );
return;
}
int groupId = hfGroupId.Value.AsInteger();
if ( groupId == 0 )
{
group = new Group();
group.IsSystem = false;
group.Name = string.Empty;
}
else
{
group = groupService.Queryable( "Schedule,GroupLocations.Schedules" ).Where( g => g.Id == groupId ).FirstOrDefault();
wasSecurityRole = group.IsActive && ( group.IsSecurityRole || group.GroupTypeId == roleGroupTypeId );
// remove any locations that removed in the UI
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 );
}
// remove any group requirements that removed in the UI
var selectedGroupRequirements = GroupRequirementsState.Select( a => a.Guid );
foreach ( var groupRequirement in group.GroupRequirements.Where( a => !selectedGroupRequirements.Contains( a.Guid ) ).ToList() )
{
group.GroupRequirements.Remove( groupRequirement );
groupRequirementService.Delete( groupRequirement );
}
// Remove any triggers that were removed in the UI
var selectedTriggerGuids = MemberWorkflowTriggersState.Select( r => r.Guid );
foreach ( var trigger in group.GroupMemberWorkflowTriggers.Where( r => !selectedTriggerGuids.Contains( r.Guid ) ).ToList() )
{
group.GroupMemberWorkflowTriggers.Remove( trigger );
groupMemberWorkflowTriggerService.Delete( trigger );
triggersUpdated = true;
}
}
// add/update any group requirements that were added or changed in the UI (we already removed the ones that were removed above)
foreach ( var groupRequirementState in GroupRequirementsState )
{
GroupRequirement groupRequirement = group.GroupRequirements.Where( a => a.Guid == groupRequirementState.Guid ).FirstOrDefault();
if ( groupRequirement == null )
{
groupRequirement = new GroupRequirement();
group.GroupRequirements.Add( groupRequirement );
}
groupRequirement.CopyPropertiesFrom( groupRequirementState );
}
// add/update any group locations that were added or changed in the UI (we already removed the ones that were removed above)
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;
var selectedSchedules = groupLocationState.Schedules.Select( s => s.Guid ).ToList();
foreach ( var schedule in groupLocation.Schedules.Where( s => !selectedSchedules.Contains( s.Guid ) ).ToList() )
{
groupLocation.Schedules.Remove( schedule );
}
}
groupLocation.CopyPropertiesFrom( groupLocationState );
var existingSchedules = groupLocation.Schedules.Select( s => s.Guid ).ToList();
foreach ( var scheduleState in groupLocationState.Schedules.Where( s => !existingSchedules.Contains( s.Guid ) ).ToList() )
{
var schedule = scheduleService.Get( scheduleState.Guid );
if ( schedule != null )
{
groupLocation.Schedules.Add( schedule );
}
}
}
foreach ( var triggerState in MemberWorkflowTriggersState )
{
GroupMemberWorkflowTrigger trigger = group.GroupMemberWorkflowTriggers.Where( r => r.Guid == triggerState.Guid ).FirstOrDefault();
if ( trigger == null )
{
trigger = new GroupMemberWorkflowTrigger();
group.GroupMemberWorkflowTriggers.Add( trigger );
}
else
{
triggerState.Id = trigger.Id;
triggerState.Guid = trigger.Guid;
}
trigger.CopyPropertiesFrom( triggerState );
triggersUpdated = true;
}
group.Name = tbName.Text;
group.Description = tbDescription.Text;
group.CampusId = ddlCampus.SelectedValueAsInt();
group.GroupTypeId = CurrentGroupTypeId;
group.ParentGroupId = gpParentGroup.SelectedValueAsInt();
group.GroupCapacity = nbGroupCapacity.Text.AsIntegerOrNull();
group.RequiredSignatureDocumentTemplateId = ddlSignatureDocumentTemplate.SelectedValueAsInt();
group.IsSecurityRole = cbIsSecurityRole.Checked;
group.IsActive = cbIsActive.Checked;
group.IsPublic = cbIsPublic.Checked;
group.MustMeetRequirementsToAddMember = cbMembersMustMeetRequirementsOnAdd.Checked;
// save sync settings
group.SyncDataViewId = dvpSyncDataview.SelectedValue.AsIntegerOrNull();
group.WelcomeSystemEmailId = ddlWelcomeEmail.SelectedValue.AsIntegerOrNull();
group.ExitSystemEmailId = ddlExitEmail.SelectedValue.AsIntegerOrNull();
group.AddUserAccountsDuringSync = rbCreateLoginDuringSync.Checked;
string iCalendarContent = string.Empty;
// If unique schedule option was selected, but a schedule was not defined, set option to 'None'
var scheduleType = rblScheduleSelect.SelectedValueAsEnum<ScheduleType>( ScheduleType.None );
if ( scheduleType == ScheduleType.Custom )
{
iCalendarContent = sbSchedule.iCalendarContent;
var calEvent = ScheduleICalHelper.GetCalenderEvent( iCalendarContent );
if ( calEvent == null || calEvent.DTStart == null )
{
scheduleType = ScheduleType.None;
}
}
if ( scheduleType == ScheduleType.Weekly )
{
if ( !dowWeekly.SelectedDayOfWeek.HasValue )
{
scheduleType = ScheduleType.None;
}
}
int? oldScheduleId = hfUniqueScheduleId.Value.AsIntegerOrNull();
if ( scheduleType == ScheduleType.Custom || scheduleType == ScheduleType.Weekly )
{
if ( !oldScheduleId.HasValue || group.Schedule == null )
{
group.Schedule = new Schedule();
}
if ( scheduleType == ScheduleType.Custom )
{
group.Schedule.iCalendarContent = iCalendarContent;
group.Schedule.WeeklyDayOfWeek = null;
group.Schedule.WeeklyTimeOfDay = null;
}
else
{
group.Schedule.iCalendarContent = null;
group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek;
group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime;
}
}
else
{
// If group did have a unique schedule, delete that schedule
if ( oldScheduleId.HasValue )
{
var schedule = scheduleService.Get( oldScheduleId.Value );
if ( schedule != null && string.IsNullOrEmpty( schedule.Name ) )
{
// Make sure this is the only group trying to use this schedule.
if ( !groupService.Queryable().Where( g => g.ScheduleId == schedule.Id && g.Id != group.Id ).Any() )
{
scheduleService.Delete( schedule );
}
}
}
if ( scheduleType == ScheduleType.Named )
{
group.ScheduleId = spSchedule.SelectedValueAsId();
}
else
{
group.ScheduleId = null;
}
}
if ( group.ParentGroupId == group.Id )
{
gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." );
return;
}
group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group );
group.GroupType = new GroupTypeService( rockContext ).Get( group.GroupTypeId );
if ( group.ParentGroupId.HasValue )
{
group.ParentGroup = groupService.Get( group.ParentGroupId.Value );
}
// Check to see if group type is allowed as a child of new parent group.
if ( group.ParentGroup != null )
{
var allowedGroupTypeIds = GetAllowedGroupTypes( group.ParentGroup, rockContext ).Select( t => t.Id ).ToList();
if ( !allowedGroupTypeIds.Contains( group.GroupTypeId ) )
{
var groupType = CurrentGroupTypeCache;
nbInvalidParentGroup.Text = string.Format( "The '{0}' group does not allow child groups with a '{1}' group type.", group.ParentGroup.Name, groupType != null ? groupType.Name : string.Empty );
nbInvalidParentGroup.Visible = true;
return;
}
}
// Check to see if user is still allowed to edit with selected group type and parent group
if ( !group.IsAuthorized( Authorization.EDIT, CurrentPerson ) )
{
nbNotAllowedToEdit.Visible = true;
return;
}
if ( !Page.IsValid )
{
return;
}
// if the groupMember IsValid is false, and the UI controls didn't report any errors, it is probably because the custom rules of GroupMember didn't pass.
// So, make sure a message is displayed in the validation summary
cvGroup.IsValid = group.IsValid;
if ( !cvGroup.IsValid )
{
cvGroup.ErrorMessage = group.ValidationResults.Select( a => a.ErrorMessage ).ToList().AsDelimited( "<br />" );
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
var adding = group.Id.Equals( 0 );
if ( adding )
{
groupService.Add( group );
}
rockContext.SaveChanges();
if ( adding )
{
// add ADMINISTRATE to the person who added the group
Rock.Security.Authorization.AllowPerson( group, Authorization.ADMINISTRATE, this.CurrentPerson, rockContext );
}
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.IsActive == false && cbInactivateChildGroups.Checked )
{
var allActiveChildGroupsId = groupService.GetAllDescendents( group.Id ).Where( a => a.IsActive ).Select( a => a.Id ).ToList();
var allActiveChildGroups = groupService.GetByIds( allActiveChildGroupsId );
foreach ( var childGroup in allActiveChildGroups )
{
if ( childGroup.IsActive )
{
childGroup.IsActive = false;
}
}
rockContext.SaveChanges();
}
} );
bool isNowSecurityRole = group.IsActive && ( group.IsSecurityRole || group.GroupTypeId == roleGroupTypeId );
if ( group != null && wasSecurityRole )
{
if ( !isNowSecurityRole )
{
// if this group was a SecurityRole, but no longer is, flush
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
else
{
if ( isNowSecurityRole )
{
// new security role, flush
Rock.Security.Authorization.Flush();
}
}
AttributeCache.FlushEntityAttributes();
if ( triggersUpdated )
{
GroupMemberWorkflowTriggerService.FlushCachedTriggers();
}
var qryParams = new Dictionary<string, string>();
qryParams["GroupId"] = group.Id.ToString();
qryParams["ExpandedIds"] = PageParameter( "ExpandedIds" );
NavigateToPage( RockPage.Guid, qryParams );
}
/// <summary>
/// Binds the groups.
/// </summary>
private void BindGroups()
{
if ( Person != null && Person.Id > 0 )
{
using ( _bindGroupsRockContext = new RockContext() )
{
var memberService = new GroupMemberService( _bindGroupsRockContext );
var groups = memberService.Queryable( true )
.Where( m =>
m.PersonId == Person.Id &&
m.Group.GroupTypeId == _groupType.Id )
.Select( m => m.Group )
.ToList();
if ( !groups.Any() && GetAttributeValue("AutoCreateGroup").AsBoolean(true) )
{
// ensure that the person is in a group
var groupService = new GroupService( _bindGroupsRockContext );
var group = new Group();
group.Name = Person.LastName;
group.GroupTypeId = _groupType.Id;
groupService.Add( group );
_bindGroupsRockContext.SaveChanges();
var groupMember = new GroupMember();
groupMember.PersonId = Person.Id;
groupMember.GroupRoleId = _groupType.DefaultGroupRoleId.Value;
groupMember.GroupId = group.Id;
group.Members.Add( groupMember );
_bindGroupsRockContext.SaveChanges();
groups.Add( groupService.Get( group.Id ) );
}
rptrGroups.DataSource = groups;
rptrGroups.DataBind();
}
}
}
/// <summary>
/// Creates the family.
/// </summary>
/// <param name="FamilyName">Name of the family.</param>
/// <returns></returns>
protected Group CreateFamily( string FamilyName )
{
var familyGroup = new Group();
familyGroup.Name = FamilyName + " Family";
familyGroup.GroupTypeId = GroupTypeCache.GetFamilyGroupType().Id;
familyGroup.IsSecurityRole = false;
familyGroup.IsSystem = false;
familyGroup.IsActive = true;
Rock.Data.RockTransactionScope.WrapTransaction( () =>
{
var gs = new GroupService();
gs.Add( familyGroup, CurrentPersonId );
gs.Save( familyGroup, CurrentPersonId );
} );
return familyGroup;
}
protected void btnNext_Click( object sender, EventArgs e )
{
if ( Page.IsValid )
{
if ( CurrentCategoryIndex < attributeControls.Count )
{
CurrentCategoryIndex++;
ShowAttributeCategory( CurrentCategoryIndex );
}
else
{
var familyMembers = GetControlData();
if ( familyMembers.Any() )
{
RockTransactionScope.WrapTransaction( () =>
{
using ( new UnitOfWorkScope() )
{
var familyGroupType = GroupTypeCache.GetFamilyGroupType();
var familyChanges = new List<string>();
var familyMemberChanges = new Dictionary<Guid, List<string>>();
var familyDemographicChanges = new Dictionary<Guid, List<string>>();
if ( familyGroupType != null )
{
var groupService = new GroupService();
var groupTypeRoleService = new GroupTypeRoleService();
var familyGroup = new Group();
familyGroup.GroupTypeId = familyGroupType.Id;
familyChanges.Add("Created");
familyGroup.Name = familyMembers.FirstOrDefault().Person.LastName + " Family";
History.EvaluateChange( familyChanges, "Name", string.Empty, familyGroup.Name );
int? campusId = cpCampus.SelectedValueAsInt();
if (campusId.HasValue)
{
History.EvaluateChange( familyChanges, "Campus", string.Empty, CampusCache.Read( campusId.Value ).Name );
}
familyGroup.CampusId = campusId;
foreach(var familyMember in familyMembers)
{
var person = familyMember.Person;
if ( person != null )
{
familyGroup.Members.Add( familyMember );
var demographicChanges = new List<string>();
demographicChanges.Add( "Created" );
History.EvaluateChange( demographicChanges, "Record Status", string.Empty,
person.RecordStatusReasonValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusReasonValueId.Value ) : string.Empty );
History.EvaluateChange( demographicChanges, "Title", string.Empty,
person.TitleValueId.HasValue ? DefinedValueCache.GetName( person.TitleValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName);
History.EvaluateChange( demographicChanges, "Nick Name", string.Empty, person.NickName );
History.EvaluateChange( demographicChanges, "Middle Name", string.Empty, person.MiddleName );
History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );
History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );
History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );
History.EvaluateChange( demographicChanges, "Connection Status", string.Empty,
person.ConnectionStatusValueId.HasValue ? DefinedValueCache.GetName( person.ConnectionStatusValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "Graduation Date", null, person.GraduationDate );
familyDemographicChanges.Add( person.Guid, demographicChanges );
var memberChanges = new List<string>();
string roleName = familyGroupType.Roles[familyMember.GroupRoleId] ?? string.Empty;
History.EvaluateChange( memberChanges, "Role", string.Empty, roleName );
familyMemberChanges.Add( person.Guid, memberChanges );
}
}
if ( !String.IsNullOrWhiteSpace( tbStreet1.Text ) ||
!String.IsNullOrWhiteSpace( tbStreet2.Text ) ||
!String.IsNullOrWhiteSpace( tbCity.Text ) ||
!String.IsNullOrWhiteSpace( tbZip.Text ) )
{
string addressChangeField = "Address";
var groupLocation = new GroupLocation();
var location = new LocationService().Get(
tbStreet1.Text, tbStreet2.Text, tbCity.Text, ddlState.SelectedValue, tbZip.Text );
groupLocation.Location = location;
Guid locationTypeGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "LocationType" ), out locationTypeGuid ) )
{
var locationType = Rock.Web.Cache.DefinedValueCache.Read( locationTypeGuid );
if ( locationType != null )
{
addressChangeField = string.Format("{0} Address", locationType.Name);
groupLocation.GroupLocationTypeValueId = locationType.Id;
}
}
familyGroup.GroupLocations.Add( groupLocation );
History.EvaluateChange( familyChanges, addressChangeField, string.Empty, groupLocation.Location.ToString() );
}
groupService.Add( familyGroup, CurrentPersonId );
groupService.Save( familyGroup, CurrentPersonId );
var historyService = new HistoryService();
historyService.SaveChanges( typeof( Group ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
familyGroup.Id, familyChanges, CurrentPersonId );
var personService = new PersonService();
foreach ( var groupMember in familyMembers )
{
var person = personService.Get( groupMember.PersonId );
if ( person != null )
{
var changes = familyDemographicChanges[person.Guid];
if ( groupMember.GroupRoleId != _childRoleId )
{
person.GivingGroupId = familyGroup.Id;
personService.Save( person, CurrentPersonId );
History.EvaluateChange( changes, "Giving Group", string.Empty, familyGroup.Name );
}
foreach ( var attributeControl in attributeControls )
{
foreach ( var attribute in attributeControl.AttributeList )
{
string attributeValue = person.GetAttributeValue( attribute.Key );
if ( !string.IsNullOrWhiteSpace( attributeValue ) )
{
Rock.Attribute.Helper.SaveAttributeValue( person, attribute, attributeValue, CurrentPersonId );
attributeValue = attribute.FieldType.Field.FormatValue( null, attributeValue, attribute.QualifierValues, false );
History.EvaluateChange( changes, attribute.Name, string.Empty, attributeValue );
}
}
}
historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id, changes, CurrentPersonId );
historyService.SaveChanges( typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
person.Id, familyMemberChanges[person.Guid], familyGroup.Name, typeof( Group), familyGroup.Id, CurrentPersonId );
}
}
}
}
} );
Response.Redirect( string.Format( "~/Person/{0}", familyMembers[0].Person.Id ), false );
}
}
}
}
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>
/// 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 );
// 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()
};
// 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() );
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.GroupMemberPersonId = _peopleDictionary[elemGroup.Attribute( "meetsAtHomeOfPerson" ).Value.AsGuid()];
}
group.GroupLocations.Add( groupLocation );
}
group.LoadAttributes( rockContext );
// Set the study topic
if ( elemGroup.Attribute( "studyTopic" ) != null )
{
group.SetAttributeValue( "StudyTopic", elemGroup.Attribute( "studyTopic" ).Value );
}
// Set the meeting time
if ( elemGroup.Attribute( "meetingTime" ) != null )
{
group.SetAttributeValue( "MeetingTime", elemGroup.Attribute( "meetingTime" ).Value );
}
// 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;
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 );
// 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;
_sb.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 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();
}
/// <summary>
/// Creates the family.
/// </summary>
/// <param name="FamilyName">Name of the family.</param>
/// <returns></returns>
protected Group CreateFamily( string FamilyName )
{
var familyGroup = new Group();
familyGroup.Name = FamilyName + " Family";
familyGroup.GroupTypeId = GroupTypeCache.GetFamilyGroupType().Id;
familyGroup.IsSecurityRole = false;
familyGroup.IsSystem = false;
familyGroup.IsActive = true;
var rockContext = new RockContext();
var gs = new GroupService(rockContext);
gs.Add( familyGroup );
rockContext.SaveChanges();
return familyGroup;
}
/// <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>
/// Adds the visitor group member roles.
/// </summary>
/// <param name="family">The family.</param>
/// <param name="personId">The person id.</param>
protected void AddVisitorGroupMemberRoles( CheckInFamily family, int personId )
{
var rockContext = new RockContext();
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var groupRoleService = new GroupTypeRoleService( rockContext );
int ownerRoleId = groupRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) ).Id;
int canCheckInId = groupRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CAN_CHECK_IN ) ).Id;
foreach ( var familyMember in family.People )
{
var group = groupMemberService.Queryable()
.Where( m =>
m.PersonId == familyMember.Person.Id &&
m.GroupRoleId == ownerRoleId )
.Select( m => m.Group )
.FirstOrDefault();
if ( group == null )
{
var role = new GroupTypeRoleService( rockContext ).Get( ownerRoleId );
if ( role != null && role.GroupTypeId.HasValue )
{
var groupMember = new GroupMember();
groupMember.PersonId = familyMember.Person.Id;
groupMember.GroupRoleId = role.Id;
group = new Group();
group.Name = role.GroupType.Name;
group.GroupTypeId = role.GroupTypeId.Value;
group.Members.Add( groupMember );
groupService.Add( group );
}
}
// add the visitor to this group with CanCheckIn
Person.CreateCheckinRelationship( familyMember.Person.Id, personId, CurrentPersonAlias );
}
rockContext.SaveChanges();
}
/// <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 btnSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
protected void btnSave_Click( object sender, EventArgs e )
{
// if a Location is getting edited, validate and save it
if ( gLocations.EditIndex >= 0 )
{
var row = gLocations.Rows[gLocations.EditIndex];
AddressControl acAddress = row.FindControl( "acAddress" ) as AddressControl;
if ( acAddress.IsValid )
{
gLocations_RowUpdating( sender, new GridViewUpdateEventArgs( gLocations.EditIndex ) );
}
else
{
// acAddress will render an error message
return;
}
}
if ( !IsUserAuthorized( Rock.Security.Authorization.EDIT ) )
{
return;
}
// confirmation was disabled by btnSave on client-side. So if returning without a redirect,
// it should be enabled. If returning with a redirect, the control won't be updated to reflect
// confirmation being enabled, so it's ok to enable it here
confirmExit.Enabled = true;
if ( Page.IsValid )
{
confirmExit.Enabled = true;
var rockContext = new RockContext();
rockContext.WrapTransaction( () =>
{
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var personService = new PersonService( rockContext );
var historyService = new HistoryService( rockContext );
var groupChanges = new List<string>();
// SAVE GROUP
_group = groupService.Get( _group.Id );
History.EvaluateChange( groupChanges, "Group Name", _group.Name, tbGroupName.Text );
_group.Name = tbGroupName.Text;
int? campusId = cpCampus.SelectedValueAsInt();
if ( _group.CampusId != campusId )
{
History.EvaluateChange(
groupChanges,
"Campus",
_group.CampusId.HasValue ? CampusCache.Read( _group.CampusId.Value ).Name : string.Empty,
campusId.HasValue ? CampusCache.Read( campusId.Value ).Name : string.Empty );
_group.CampusId = campusId;
}
rockContext.SaveChanges();
// SAVE GROUP MEMBERS
int? recordStatusValueID = ddlRecordStatus.SelectedValueAsInt();
int? reasonValueId = ddlReason.SelectedValueAsInt();
var newGroups = new List<Group>();
foreach ( var groupMemberInfo in GroupMembers )
{
var memberChanges = new List<string>();
var demographicChanges = new List<string>();
var role = _groupType.Roles.Where( r => r.Guid.Equals( groupMemberInfo.RoleGuid ) ).FirstOrDefault();
if ( role == null )
{
role = _groupType.Roles.FirstOrDefault();
}
bool isAdult = role != null && role.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT );
// People added to group (new or from other group )
if ( !groupMemberInfo.ExistingGroupMember )
{
Person person = null;
if ( groupMemberInfo.Id == -1 )
{
// added new person
demographicChanges.Add( "Created" );
person = new Person();
person.TitleValueId = groupMemberInfo.TitleValueId;
person.FirstName = groupMemberInfo.FirstName;
person.NickName = groupMemberInfo.NickName;
person.LastName = groupMemberInfo.LastName;
person.SuffixValueId = groupMemberInfo.SuffixValueId;
person.Gender = groupMemberInfo.Gender;
DateTime? birthdate = groupMemberInfo.BirthDate;
if ( birthdate.HasValue )
{
// If setting a future birthdate, subtract a century until birthdate is not greater than today.
var today = RockDateTime.Today;
while ( birthdate.Value.CompareTo( today ) > 0 )
{
birthdate = birthdate.Value.AddYears( -100 );
}
}
person.SetBirthDate( birthdate );
person.MaritalStatusValueId = groupMemberInfo.MaritalStatusValueId;
person.GradeOffset = groupMemberInfo.GradeOffset;
person.ConnectionStatusValueId = groupMemberInfo.ConnectionStatusValueId;
if ( isAdult )
{
person.GivingGroupId = _group.Id;
}
person.IsEmailActive = true;
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid() ).Id;
}
else
{
person = personService.Get( groupMemberInfo.Id );
}
if ( person == null )
{
// shouldn't happen
return;
}
if ( _isFamilyGroupType )
{
if ( person.RecordStatusValueId != recordStatusValueID )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
person.RecordStatusValueId = recordStatusValueID;
}
if ( person.RecordStatusValueId != recordStatusValueID )
{
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
person.RecordStatusReasonValueId = reasonValueId;
}
}
PersonService.AddPersonToGroup( person, person.Id == 0, _group.Id, role.Id, rockContext );
}
else
{
// existing group members
var groupMember = groupMemberService.Queryable( "Person", true ).Where( m =>
m.PersonId == groupMemberInfo.Id &&
m.Group.GroupTypeId == _groupType.Id &&
m.GroupId == _group.Id ).FirstOrDefault();
if ( groupMember != null )
{
if ( groupMemberInfo.Removed )
{
if ( !groupMemberInfo.IsInOtherGroups )
{
var newFamilyChanges = new List<string>();
// Family member was removed and should be created in their own new family
var newGroup = new Group();
newGroup.Name = groupMemberInfo.LastName + " " + _groupType.Name;
History.EvaluateChange( newFamilyChanges, "Family", string.Empty, newGroup.Name );
newGroup.GroupTypeId = _groupType.Id;
if ( _group.CampusId.HasValue )
{
History.EvaluateChange( newFamilyChanges, "Campus", string.Empty, CampusCache.Read( _group.CampusId.Value ).Name );
}
newGroup.CampusId = _group.CampusId;
groupService.Add( newGroup );
rockContext.SaveChanges();
// If person's previous giving group was this family, set it to their new family id
if ( _isFamilyGroupType && groupMember.Person.GivingGroup != null && groupMember.Person.GivingGroupId == _group.Id )
{
History.EvaluateChange( demographicChanges, "Giving Group", groupMember.Person.GivingGroup.Name, _group.Name );
groupMember.Person.GivingGroupId = newGroup.Id;
}
groupMember.Group = newGroup;
rockContext.SaveChanges();
var newMemberChanges = new List<string>();
if ( _isFamilyGroupType )
{
History.EvaluateChange( newMemberChanges, "Role", string.Empty, groupMember.GroupRole.Name );
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
groupMember.Person.Id,
newFamilyChanges,
newGroup.Name,
typeof( Group ),
newGroup.Id );
}
newGroups.Add( newGroup );
History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole.Name, string.Empty );
}
else
{
History.EvaluateChange( groupChanges, "Family", groupMember.Group.Name, string.Empty );
groupMemberService.Delete( groupMember );
rockContext.SaveChanges();
}
}
else
{
// Existing member was not remvoved
if ( role != null )
{
History.EvaluateChange( memberChanges, "Role", groupMember.GroupRole != null ? groupMember.GroupRole.Name : string.Empty, role.Name );
groupMember.GroupRoleId = role.Id;
if ( _isFamilyGroupType )
{
if ( recordStatusValueID > 0 )
{
History.EvaluateChange( demographicChanges, "Record Status", DefinedValueCache.GetName( groupMember.Person.RecordStatusValueId ), DefinedValueCache.GetName( recordStatusValueID ) );
groupMember.Person.RecordStatusValueId = recordStatusValueID;
History.EvaluateChange( demographicChanges, "Record Status Reason", DefinedValueCache.GetName( groupMember.Person.RecordStatusReasonValueId ), DefinedValueCache.GetName( reasonValueId ) );
groupMember.Person.RecordStatusReasonValueId = reasonValueId;
}
}
rockContext.SaveChanges();
}
}
}
}
// Remove anyone that was moved from another family
if ( groupMemberInfo.RemoveFromOtherGroups )
{
PersonService.RemovePersonFromOtherFamilies( _group.Id, groupMemberInfo.Id, rockContext );
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), groupMemberInfo.Id, demographicChanges );
if ( _isFamilyGroupType )
{
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(), groupMemberInfo.Id, memberChanges, _group.Name, typeof( Group ), _group.Id );
}
}
// SAVE LOCATIONS
var groupLocationService = new GroupLocationService( rockContext );
// delete any group locations that were removed
var remainingLocationIds = GroupAddresses.Where( a => a.Id > 0 ).Select( a => a.Id ).ToList();
foreach ( var removedLocation in groupLocationService.Queryable( "GroupLocationTypeValue,Location" )
.Where( l => l.GroupId == _group.Id &&
!remainingLocationIds.Contains( l.Id ) ) )
{
History.EvaluateChange( groupChanges,
( removedLocation.GroupLocationTypeValue != null ? removedLocation.GroupLocationTypeValue.Value : "Unknown" ) + " Location",
removedLocation.Location.ToString(), string.Empty );
groupLocationService.Delete( removedLocation );
}
rockContext.SaveChanges();
foreach ( var groupAddressInfo in GroupAddresses.Where( a => a.Id >= 0 ) )
{
Location updatedAddress = null;
if ( groupAddressInfo.LocationIsDirty )
{
updatedAddress = new LocationService( rockContext ).Get( groupAddressInfo.Street1, groupAddressInfo.Street2, groupAddressInfo.City, groupAddressInfo.State, groupAddressInfo.PostalCode, groupAddressInfo.Country );
}
GroupLocation groupLocation = null;
if ( groupAddressInfo.Id > 0 )
{
groupLocation = groupLocationService.Get( groupAddressInfo.Id );
}
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
groupLocation.GroupId = _group.Id;
groupLocationService.Add( groupLocation );
}
History.EvaluateChange(
groupChanges,
"Location Type",
groupLocation.GroupLocationTypeValueId.HasValue ? DefinedValueCache.Read( groupLocation.GroupLocationTypeValueId.Value ).Value : string.Empty,
groupAddressInfo.LocationTypeName );
groupLocation.GroupLocationTypeValueId = groupAddressInfo.LocationTypeId;
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Is Mailing",
groupLocation.IsMailingLocation.ToString(),
groupAddressInfo.IsMailing.ToString() );
groupLocation.IsMailingLocation = groupAddressInfo.IsMailing;
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Is Map Location",
groupLocation.IsMappedLocation.ToString(),
groupAddressInfo.IsLocation.ToString() );
groupLocation.IsMappedLocation = groupAddressInfo.IsLocation;
if ( updatedAddress != null )
{
History.EvaluateChange(
groupChanges,
groupAddressInfo.LocationTypeName + " Location",
groupLocation.Location != null ? groupLocation.Location.ToString() : string.Empty,
updatedAddress.ToString() );
groupLocation.Location = updatedAddress;
}
rockContext.SaveChanges();
// Add the same locations to any new families created by removing an existing family member
if ( newGroups.Any() )
{
// reload grouplocation for access to child properties
groupLocation = groupLocationService.Get( groupLocation.Id );
foreach ( var newGroup in newGroups )
{
var newGroupLocation = new GroupLocation();
newGroupLocation.GroupId = newGroup.Id;
newGroupLocation.LocationId = groupLocation.LocationId;
newGroupLocation.GroupLocationTypeValueId = groupLocation.GroupLocationTypeValueId;
newGroupLocation.IsMailingLocation = groupLocation.IsMailingLocation;
newGroupLocation.IsMappedLocation = groupLocation.IsMappedLocation;
groupLocationService.Add( newGroupLocation );
}
rockContext.SaveChanges();
}
}
_group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, _group );
_group.SaveAttributeValues( rockContext );
if ( _isFamilyGroupType )
{
foreach ( var fm in _group.Members )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
fm.PersonId,
groupChanges,
_group.Name,
typeof( Group ),
_group.Id );
}
}
Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
} );
}
}
/// <summary>
/// Handles the SaveClick event of the mdAddContact control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void mdAddContact_SaveClick( object sender, EventArgs e )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var groupService = new GroupService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
var business = personService.Get( int.Parse( hfBusinessId.Value ) );
int? contactId = ppContact.PersonId;
if ( contactId.HasValue && contactId.Value > 0 )
{
// Get the relationship roles to use
var knownRelationshipGroupType = GroupTypeCache.Read( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid() );
int businessContactRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
int businessRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
int ownerRoleId = knownRelationshipGroupType.Roles
.Where( r =>
r.Guid.Equals( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ) )
.Select( r => r.Id )
.FirstOrDefault();
if ( ownerRoleId > 0 && businessContactRoleId > 0 && businessRoleId > 0 )
{
// get the known relationship group of the business contact
// add the business as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS
var contactKnownRelationshipGroup = groupMemberService.Queryable()
.Where( g =>
g.GroupRoleId == ownerRoleId &&
g.PersonId == contactId.Value )
.Select( g => g.Group )
.FirstOrDefault();
if (contactKnownRelationshipGroup == null)
{
// In some cases person may not yet have a know relationship group type
contactKnownRelationshipGroup = new Group();
groupService.Add( contactKnownRelationshipGroup );
contactKnownRelationshipGroup.Name = "Known Relationship";
contactKnownRelationshipGroup.GroupTypeId = knownRelationshipGroupType.Id;
var ownerMember = new GroupMember();
ownerMember.PersonId = contactId.Value;
ownerMember.GroupRoleId = ownerRoleId;
contactKnownRelationshipGroup.Members.Add( ownerMember );
}
var groupMember = new GroupMember();
groupMember.PersonId = int.Parse( hfBusinessId.Value );
groupMember.GroupRoleId = businessRoleId;
contactKnownRelationshipGroup.Members.Add( groupMember );
// get the known relationship group of the business
// add the business contact as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT
var businessKnownRelationshipGroup = groupMemberService.Queryable()
.Where( g =>
g.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) ) &&
g.PersonId == business.Id )
.Select( g => g.Group ).FirstOrDefault();
var businessGroupMember = new GroupMember();
businessGroupMember.PersonId = contactId.Value;
businessGroupMember.GroupRoleId = businessContactRoleId;
businessKnownRelationshipGroup.Members.Add( businessGroupMember );
rockContext.SaveChanges();
}
}
mdAddContact.Hide();
hfModalOpen.Value = string.Empty;
BindContactListGrid( business );
}
/// <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 );
// 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()
};
// 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() );
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.GroupMemberPersonId = _peopleDictionary[elemGroup.Attribute( "meetsAtHomeOfPerson" ).Value.AsGuid()];
}
group.GroupLocations.Add( groupLocation );
}
group.LoadAttributes();
// Set the study topic
if ( elemGroup.Attribute( "studyTopic" ) != null )
{
group.SetAttributeValue( "StudyTopic", elemGroup.Attribute( "studyTopic" ).Value );
}
// Set the meeting time
if ( elemGroup.Attribute( "meetingTime" ) != null )
{
group.SetAttributeValue( "MeetingTime", elemGroup.Attribute( "meetingTime" ).Value );
}
// 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;
groupMember.GroupRoleId = roleId ?? -1;
groupMember.PersonId = _peopleDictionary[personGuid];
group.Members.Add( groupMember );
}
groupService.Add( group );
group.SaveAttributeValues( rockContext );
}
}
/// <summary>
/// Saves the new family.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="familyMembers">The family members.</param>
/// <param name="campusId">The campus identifier.</param>
/// <param name="savePersonAttributes">if set to <c>true</c> [save person attributes].</param>
/// <returns></returns>
public static Group SaveNewFamily( RockContext rockContext, List<GroupMember> familyMembers, int? campusId, bool savePersonAttributes )
{
var familyGroupType = GroupTypeCache.GetFamilyGroupType();
var familyChanges = new List<string>();
var familyMemberChanges = new Dictionary<Guid, List<string>>();
var familyDemographicChanges = new Dictionary<Guid, List<string>>();
if ( familyGroupType != null )
{
var groupService = new GroupService( rockContext );
var familyGroup = new Group();
familyGroup.GroupTypeId = familyGroupType.Id;
familyGroup.Name = familyMembers.FirstOrDefault().Person.LastName + " Family";
History.EvaluateChange( familyChanges, "Family", string.Empty, familyGroup.Name );
if ( campusId.HasValue )
{
History.EvaluateChange( familyChanges, "Campus", string.Empty, CampusCache.Read( campusId.Value ).Name );
}
familyGroup.CampusId = campusId;
int? childRoleId = null;
var childRole = new GroupTypeRoleService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) );
if ( childRole != null )
{
childRoleId = childRole.Id;
}
foreach ( var familyMember in familyMembers )
{
var person = familyMember.Person;
if ( person != null )
{
familyGroup.Members.Add( familyMember );
var demographicChanges = new List<string>();
demographicChanges.Add( "Created" );
History.EvaluateChange( demographicChanges, "Record Type", string.Empty, person.RecordTypeValueId.HasValue ? DefinedValueCache.GetName( person.RecordTypeValueId.Value ) : string.Empty );
History.EvaluateChange( demographicChanges, "Record Status", string.Empty, person.RecordStatusValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusValueId.Value ) : string.Empty );
History.EvaluateChange( demographicChanges, "Record Status Reason", string.Empty, person.RecordStatusReasonValueId.HasValue ? DefinedValueCache.GetName( person.RecordStatusReasonValueId.Value ) : string.Empty );
History.EvaluateChange( demographicChanges, "Connection Status", string.Empty, person.ConnectionStatusValueId.HasValue ? DefinedValueCache.GetName( person.ConnectionStatusValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "Deceased", false.ToString(), ( person.IsDeceased ?? false ).ToString() );
History.EvaluateChange( demographicChanges, "Title", string.Empty, person.TitleValueId.HasValue ? DefinedValueCache.GetName( person.TitleValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "First Name", string.Empty, person.FirstName );
History.EvaluateChange( demographicChanges, "Nick Name", string.Empty, person.NickName );
History.EvaluateChange( demographicChanges, "Middle Name", string.Empty, person.MiddleName );
History.EvaluateChange( demographicChanges, "Last Name", string.Empty, person.LastName );
History.EvaluateChange( demographicChanges, "Suffix", string.Empty, person.SuffixValueId.HasValue ? DefinedValueCache.GetName( person.SuffixValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "Birth Date", null, person.BirthDate );
History.EvaluateChange( demographicChanges, "Gender", null, person.Gender );
History.EvaluateChange( demographicChanges, "Marital Status", string.Empty, person.MaritalStatusValueId.HasValue ? DefinedValueCache.GetName( person.MaritalStatusValueId ) : string.Empty );
History.EvaluateChange( demographicChanges, "Anniversary Date", null, person.AnniversaryDate );
History.EvaluateChange( demographicChanges, "Graduation Year", null, person.GraduationYear );
History.EvaluateChange( demographicChanges, "Email", string.Empty, person.Email );
History.EvaluateChange( demographicChanges, "Email Active", false.ToString(), ( person.IsEmailActive ?? false ).ToString() );
History.EvaluateChange( demographicChanges, "Email Note", string.Empty, person.EmailNote );
History.EvaluateChange( demographicChanges, "Email Preference", null, person.EmailPreference );
History.EvaluateChange( demographicChanges, "Inactive Reason Note", string.Empty, person.InactiveReasonNote );
History.EvaluateChange( demographicChanges, "System Note", string.Empty, person.SystemNote );
familyDemographicChanges.Add( person.Guid, demographicChanges );
var memberChanges = new List<string>();
string roleName = familyGroupType.Roles
.Where( r => r.Id == familyMember.GroupRoleId )
.Select( r => r.Name )
.FirstOrDefault();
History.EvaluateChange( memberChanges, "Role", string.Empty, roleName );
familyMemberChanges.Add( person.Guid, memberChanges );
}
}
groupService.Add( familyGroup );
rockContext.SaveChanges();
var personService = new PersonService( rockContext );
foreach ( var groupMember in familyMembers )
{
var person = groupMember.Person;
if ( savePersonAttributes )
{
var newValues = person.AttributeValues;
person.LoadAttributes();
foreach ( var attributeCache in person.Attributes.Select( a => a.Value ) )
{
string oldValue = person.GetAttributeValue( attributeCache.Key ) ?? string.Empty;
string newValue = string.Empty;
if ( newValues != null &&
newValues.ContainsKey( attributeCache.Key ) &&
newValues[attributeCache.Key] != null )
{
newValue = newValues[attributeCache.Key].Value ?? string.Empty;
}
if ( !oldValue.Equals( newValue ) )
{
History.EvaluateChange( familyDemographicChanges[person.Guid], attributeCache.Name,
attributeCache.FieldType.Field.FormatValue( null, oldValue, attributeCache.QualifierValues, false ),
attributeCache.FieldType.Field.FormatValue( null, newValue, attributeCache.QualifierValues, false ) );
Rock.Attribute.Helper.SaveAttributeValue( person, attributeCache, newValue );
}
}
}
person = personService.Get( groupMember.PersonId );
if ( person != null )
{
bool updateRequired = false;
if ( !person.Aliases.Any( a => a.AliasPersonId == person.Id ) )
{
person.Aliases.Add( new PersonAlias { AliasPersonId = person.Id, AliasPersonGuid = person.Guid } );
updateRequired = true;
}
var changes = familyDemographicChanges[person.Guid];
if ( groupMember.GroupRoleId != childRoleId )
{
person.GivingGroupId = familyGroup.Id;
updateRequired = true;
History.EvaluateChange( changes, "Giving Group", string.Empty, familyGroup.Name );
}
if ( updateRequired )
{
rockContext.SaveChanges();
}
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
person.Id, changes );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
person.Id, familyMemberChanges[person.Guid], familyGroup.Name, typeof( Group ), familyGroup.Id );
HistoryService.SaveChanges( rockContext, typeof( Person ), Rock.SystemGuid.Category.HISTORY_PERSON_FAMILY_CHANGES.AsGuid(),
person.Id, familyChanges, familyGroup.Name, typeof( Group ), familyGroup.Id );
}
}
return familyGroup;
}
return null;
}
/// <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 );
ScheduleService scheduleService = new ScheduleService( 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.Queryable( "Schedule,GroupLocations.Schedules" ).Where( g => g.Id == groupId ).FirstOrDefault();
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;
var selectedSchedules = groupLocationState.Schedules.Select( s => s.Guid ).ToList();
foreach( var schedule in groupLocation.Schedules.Where( s => !selectedSchedules.Contains( s.Guid)).ToList())
{
groupLocation.Schedules.Remove( schedule );
}
}
groupLocation.CopyPropertiesFrom( groupLocationState );
var existingSchedules = groupLocation.Schedules.Select( s => s.Guid ).ToList();
foreach ( var scheduleState in groupLocationState.Schedules.Where( s => !existingSchedules.Contains( s.Guid )).ToList())
{
var schedule = scheduleService.Get( scheduleState.Guid );
if ( schedule != null )
{
groupLocation.Schedules.Add( schedule );
}
}
}
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;
string iCalendarContent = string.Empty;
// If unique schedule option was selected, but a schedule was not defined, set option to 'None'
var scheduleType = rblScheduleSelect.SelectedValueAsEnum<ScheduleType>( ScheduleType.None );
if ( scheduleType == ScheduleType.Custom )
{
iCalendarContent = sbSchedule.iCalendarContent;
var calEvent = ScheduleICalHelper.GetCalenderEvent( iCalendarContent );
if ( calEvent == null || calEvent.DTStart == null )
{
scheduleType = ScheduleType.None;
}
}
if ( scheduleType == ScheduleType.Weekly )
{
if ( !dowWeekly.SelectedDayOfWeek.HasValue )
{
scheduleType = ScheduleType.None;
}
}
int? oldScheduleId = hfUniqueScheduleId.Value.AsIntegerOrNull();
if ( scheduleType == ScheduleType.Custom || scheduleType == ScheduleType.Weekly )
{
if ( !oldScheduleId.HasValue || group.Schedule == null )
{
group.Schedule = new Schedule();
}
if ( scheduleType == ScheduleType.Custom )
{
group.Schedule.iCalendarContent = iCalendarContent;
group.Schedule.WeeklyDayOfWeek = null;
group.Schedule.WeeklyTimeOfDay = null;
}
else
{
group.Schedule.iCalendarContent = null;
group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek;
group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime;
}
}
else
{
// If group did have a unique schedule, delete that schedule
if ( oldScheduleId.HasValue )
{
var schedule = scheduleService.Get( oldScheduleId.Value );
if ( schedule != null && string.IsNullOrEmpty(schedule.Name) )
{
scheduleService.Delete(schedule);
}
}
if ( scheduleType == ScheduleType.Named )
{
group.ScheduleId = spSchedule.SelectedValueAsId();
}
else
{
group.ScheduleId = null;
}
}
if ( group.ParentGroupId == group.Id )
{
gpParentGroup.ShowErrorMessage( "Group cannot be a Parent Group of itself." );
return;
}
group.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupAttributes, group );
group.GroupType = new GroupTypeService( rockContext ).Get( group.GroupTypeId );
if ( group.ParentGroupId.HasValue )
{
group.ParentGroup = groupService.Get( group.ParentGroupId.Value );
}
// Check to see if user is still allowed to edit with selected group type and parent group
if ( !group.IsAuthorized( Authorization.EDIT, CurrentPerson ))
{
nbNotAllowedToEdit.Visible = true;
return;
}
if ( !Page.IsValid )
{
return;
}
if ( !group.IsValid )
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction( () =>
{
var adding = group.Id.Equals( 0 );
if ( adding )
{
groupService.Add( group );
}
rockContext.SaveChanges();
if (adding)
{
// add ADMINISTRATE to the person who added the group
Rock.Security.Authorization.AllowPerson( group, Authorization.ADMINISTRATE, this.CurrentPerson, rockContext );
}
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();
qryParams["ExpandedIds"] = PageParameter( "ExpandedIds" );
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 );
}
}
} );
}
}
private Person GetPerson()
{
using ( new UnitOfWorkScope() )
{
var personService = new PersonService();
var personMatches = personService.GetByEmail( txtEmail.Text ).Where( p =>
p.LastName.Equals( txtLastName.Text, StringComparison.OrdinalIgnoreCase ) &&
( ( p.FirstName != null && p.FirstName.Equals( txtFirstName.Text, StringComparison.OrdinalIgnoreCase ) ) ||
( p.NickName != null && p.NickName.Equals( txtFirstName.Text, StringComparison.OrdinalIgnoreCase ) ) ) );
if ( personMatches.Count() == 1 )
{
return personMatches.FirstOrDefault();
}
else
{
Person person = new Person();
person.FirstName = txtFirstName.Text;
person.LastName = txtLastName.Text;
person.Email = txtEmail.Text;
// Create Family Role
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRole = new GroupTypeRoleService().Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) );
// Create Family
var group = new Group();
group.Members.Add( groupMember );
group.Name = person.LastName + " Family";
group.GroupTypeId = GroupTypeCache.GetFamilyGroupType().Id;
// Save person/family
var groupService = new GroupService();
groupService.Add( group, CurrentPersonId );
groupService.Save( group, CurrentPersonId );
return personService.Get( person.Id );
}
}
}
