/// <summary>
/// Formats the selection.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override string FormatSelection( Type entityType, string selection )
{
string result = "Group Member";
string[] selectionValues = selection.Split( '|' );
if ( selectionValues.Length >= 2 )
{
var groupType = Rock.Web.Cache.GroupTypeCache.Read( selectionValues[0].AsGuid() );
var groupTypeRoleGuidList = selectionValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( a => a.AsGuid() ).ToList();
var groupTypeRoles = new GroupTypeRoleService( new RockContext() ).Queryable().Where( a => groupTypeRoleGuidList.Contains( a.Guid ) ).ToList();
GroupMemberStatus? groupMemberStatus = null;
if ( selectionValues.Length >= 3 )
{
groupMemberStatus = selectionValues[2].ConvertToEnumOrNull<GroupMemberStatus>();
}
if ( groupType != null )
{
result = string.Format( "Not in group of group type: {0}", groupType.Name );
if ( groupTypeRoles.Count() > 0 )
{
result += string.Format( ", with role(s): {0}", groupTypeRoles.Select( a => a.Name ).ToList().AsDelimited( "," ) );
}
if ( groupMemberStatus.HasValue )
{
result += string.Format( ", with member status: {0}", groupMemberStatus.ConvertToString() );
}
}
}
return result;
}
/// <summary>
/// Formats the selection.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override string FormatSelection( Type entityType, string selection )
{
string result = "Group Member";
string[] selectionValues = selection.Split( '|' );
if ( selectionValues.Length >= 2 )
{
var rockContext = new RockContext();
var group = new GroupService( rockContext ).Get( selectionValues[0].AsGuid() );
var groupTypeRoleGuidList = selectionValues[1].Split( new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries ).Select( a => a.AsGuid() ).ToList();
var groupTypeRoles = new GroupTypeRoleService( rockContext ).Queryable().Where( a => groupTypeRoleGuidList.Contains( a.Guid ) ).ToList();
if ( group != null )
{
result = string.Format( "Not in group: {0}", group.Name );
if ( groupTypeRoles.Count() > 0 )
{
result += string.Format( ", with role(s): {0}", groupTypeRoles.Select( a => a.Name ).ToList().AsDelimited( "," ) );
}
}
}
return result;
}
/// <summary>
/// Returns the field's current value(s)
/// </summary>
/// <param name="parentControl">The parent control.</param>
/// <param name="value">Information about the value</param>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="condensed">Flag indicating if the value should be condensed (i.e. for use in a grid column)</param>
/// <returns></returns>
public override string FormatValue( Control parentControl, string value, Dictionary<string, ConfigurationValue> configurationValues, bool condensed )
{
string formattedValue = string.Empty;
Guid guid = Guid.Empty;
if ( Guid.TryParse( value, out guid ) )
{
var groupRole = new GroupTypeRoleService( new RockContext() ).Get( guid );
if ( groupRole != null )
{
formattedValue = groupRole.Name;
}
}
return base.FormatValue( parentControl, formattedValue, null, condensed );
}
/// <summary>
/// Adds the related person to the selected person's known relationships with a role of 'Can check in' which
/// is typically configured to allow check-in. If an inverse relationship is configured for 'Can check in'
/// (i.e. 'Allow check in by'), that relationship will also be created.
/// </summary>
/// <param name="personId">A <see cref="System.Int32"/> representing the Id of the Person.</param>
/// <param name="relatedPersonId">A <see cref="System.Int32"/> representing the Id of the related Person.</param>
/// <param name="currentPersonId">A <see cref="System.Int32"/> representing the Id of the Person who is logged in.</param>
public static void CreateCheckinRelationship(int personId, int relatedPersonId, int?currentPersonId)
{
using (new UnitOfWorkScope())
{
var groupMemberService = new GroupMemberService();
var knownRelationshipGroup = groupMemberService.Queryable()
.Where(m =>
m.PersonId == personId &&
m.GroupRole.Guid.Equals(new Guid(SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER)))
.Select(m => m.Group)
.FirstOrDefault();
if (knownRelationshipGroup != null)
{
int?canCheckInRoleId = new GroupTypeRoleService().Queryable()
.Where(r =>
r.Guid.Equals(new Guid(SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CAN_CHECK_IN)))
.Select(r => r.Id)
.FirstOrDefault();
if (canCheckInRoleId.HasValue)
{
var canCheckInMember = groupMemberService.Queryable()
.FirstOrDefault(m =>
m.GroupId == knownRelationshipGroup.Id &&
m.PersonId == relatedPersonId &&
m.GroupRoleId == canCheckInRoleId.Value);
if (canCheckInMember == null)
{
canCheckInMember = new GroupMember();
canCheckInMember.GroupId = knownRelationshipGroup.Id;
canCheckInMember.PersonId = relatedPersonId;
canCheckInMember.GroupRoleId = canCheckInRoleId.Value;
groupMemberService.Add(canCheckInMember, currentPersonId);
groupMemberService.Save(canCheckInMember, currentPersonId);
}
var inverseGroupMember = groupMemberService.GetInverseRelationship(canCheckInMember, true, currentPersonId);
if (inverseGroupMember != null)
{
groupMemberService.Save(inverseGroupMember, currentPersonId);
}
}
}
}
}
/// <summary>
/// Gets the value.
/// </summary>
/// <param name="groupTypeRole">The person alias.</param>
/// <param name="groupTypeRoleId">The person alias identifier.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="blankValue">The blank value.</param>
/// <returns></returns>
private static string GetGroupTypeRoleValue(GroupTypeRole groupTypeRole, int?groupTypeRoleId, RockContext rockContext, string blankValue)
{
if (groupTypeRole != null)
{
return(groupTypeRole.Name);
}
if (groupTypeRoleId.HasValue)
{
var role = new GroupTypeRoleService(rockContext).Get(groupTypeRoleId.Value);
if (role != null)
{
return(role.Name);
}
}
return(blankValue);
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Init" /> event.
/// </summary>
/// <param name="e">An <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnInit( EventArgs e )
{
base.OnInit( e );
var campusi = new CampusService().Queryable().OrderBy( a => a.Name ).ToList();
cpCampus.Campuses = campusi;
cpCampus.Visible = campusi.Any();
var childRole = new GroupTypeRoleService().Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) );
if ( childRole != null )
{
_childRoleId = childRole.Id;
}
bool.TryParse( GetAttributeValue( "Gender" ), out _requireGender );
bool.TryParse( GetAttributeValue( "Grade" ), out _requireGrade );
bool showNickName = false;
nfmMembers.ShowNickName = bool.TryParse( GetAttributeValue( "NickName" ), out showNickName ) && showNickName;
lTitle.Text = ("Add Family").FormatAsHtmlTitle();
}
protected void bindGrid()
{
if ( String.IsNullOrWhiteSpace( CheckinCode ) )
{
ShowPanel( 0 );
}
else
{
rlCheckinCode.Text = CheckinCode + " <a href='?'><i class='fa fa-times'></i></a>";
if ( !SelectedAttendanceGuid.IsEmpty() )
{
ShowPanel( 2 );
var SelectedAttendance = new AttendanceService( rockContext ).Get( SelectedAttendanceGuid );
SelectedAttendance.LoadAttributes();
var attSearch = SelectedAttendance.GetAttributeValue( "SearchValue" );
var hasSearch = !String.IsNullOrWhiteSpace( attSearch );
if ( hasSearch )
attSearch = attSearch.AsNumeric();
var SelectedPerson = SelectedAttendance.PersonAlias.Person;
rlSelectedPerson.Text = SelectedPerson.FullName + " <a href='?CheckinCode=" + CheckinCode + "'><i class='fa fa-times'></i></a>";
var groupRoleServ = new GroupTypeRoleService( rockContext );
var knownRelationship_GroupMemberships = new GroupMemberService( rockContext ).Queryable()
.Where( gm => gm.Group.GroupTypeId == 11 && gm.PersonId == SelectedPerson.Id );
var shownRelationships = GetAttributeValue( "IncludedRelationships" ).Split( ',' ).Select( g => g.AsGuid() );
gReleventPeople.DataSource = SelectedPerson.GetFamilyMembers( false, rockContext )
.Select( m => new
{
Person = m.Person,
Role = m.GroupRole,
Priority = 100
} )
.ToList()
.Union(
knownRelationship_GroupMemberships
.Where( gm => gm.GroupRole.Guid == GUID_OwnerRole )
.SelectMany( gm => gm.Group.Members.Where( gm2 => gm2.PersonId != SelectedPerson.Id ) )
.ToList()
.Select( gm => new
{
Person = gm.Person,
Role = GetInverseRole( gm.GroupRole, groupRoleServ ),
Priority = 50
} )
)
.Union(
knownRelationship_GroupMemberships
.Where( gm => gm.GroupRole.Guid != GUID_OwnerRole )
.Select( gm => new
{
Person = gm.Group.Members.Where( gm2 => gm2.GroupRole.Guid == GUID_OwnerRole ).FirstOrDefault().Person,
Role = gm.GroupRole,
Priority = 40
} ).ToList()
)
.Where( r => shownRelationships.Contains( r.Role.Guid ) )
.GroupBy( x => x.Person )
.Select( x => new PersonRelationship
{
PersonAliasGuid = x.Key.PrimaryAlias.Guid,
FullName = x.Key.FullName,
Roles = String.Join( " ,", x.Select( y => y.Role.Name ) ),
Priority = x.Select( y => y.Priority ).Max(),
HomePhone = GetFormatedNumber( x.Key, GUID_HomePhone ),
MobilePhone = GetFormatedNumber( x.Key, GUID_MobilePhone ),
Highlight = hasSearch && x.Key.PhoneNumbers.Any( y => y.Number.Contains( attSearch ) )
} )
.OrderByDescending( r => r.Priority + ( r.Highlight ? 100 : 0) );
gReleventPeople.DataKeyNames = new string[] { "PersonAliasGuid" };
gReleventPeople.DataBind();
}
else
{
ShowPanel( 1 );
int daysBacktoSearch = GetAttributeValue( "DaysBacktoSearch" ).AsInteger();
var searchDate = DateTime.Now.Date.AddDays( -daysBacktoSearch );
gSearchResults.SetLinqDataSource( new AttendanceCodeService( rockContext )
.Queryable()
.Where( c => c.Code == CheckinCode && c.IssueDateTime > searchDate )
.SelectMany( c => c.Attendances )
.OrderByDescending( "StartDateTime" ) );
gSearchResults.DataKeyNames = new string[] { "Guid" };
gSearchResults.DataBind();
}
}
}
protected GroupTypeRole GetInverseRole( GroupTypeRole role, GroupTypeRoleService groupRoleServ )
{
role.LoadAttributes();
return groupRoleServ.Get( role.GetAttributeValue( "InverseRelationship" ).AsGuid() );
}
/// <summary>
/// Raises the <see cref="E:System.Web.UI.Control.Load" /> event.
/// </summary>
/// <param name="e">The <see cref="T:System.EventArgs" /> object that contains the event data.</param>
protected override void OnLoad( EventArgs e )
{
base.OnLoad( e );
if ( !Page.IsPostBack )
{
RockContext rockContext = new RockContext();
Group group = null;
Guid personGuid = Guid.Empty;
GroupTypeRole groupMemberRole = null;
// get group id from url
if ( Request["GroupId"] != null )
{
int groupId = 0;
if ( Int32.TryParse( Request["GroupId"], out groupId ) )
{
group = new GroupService( rockContext ).Queryable("GroupType,GroupType.Roles").Where(g => g.Id == groupId ).FirstOrDefault();
}
}
else
{
Guid groupGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "DefaultGroup" ), out groupGuid ) ) {
group = new GroupService( rockContext ).Queryable( "GroupType,GroupType.Roles" ).Where( g => g.Guid == groupGuid ).FirstOrDefault(); ;
}
}
if ( group == null )
{
lAlerts.Text = "Could not determine the group to add to.";
return;
}
// get group role id from url
if ( Request["GroupMemberRoleId"] != null )
{
int groupMemberRoleId = 0;
if ( Int32.TryParse( Request["GroupMemberRoleId"], out groupMemberRoleId ) )
{
groupMemberRole = new GroupTypeRoleService( rockContext ).Get( groupMemberRoleId );
}
}
else
{
Guid groupMemberRoleGuid = Guid.Empty;
if ( Guid.TryParse( GetAttributeValue( "DefaultGroupMemberRole" ), out groupMemberRoleGuid ) )
{
groupMemberRole = new GroupTypeRoleService( rockContext ).Get( groupMemberRoleGuid );
}
}
if ( groupMemberRole == null )
{
lAlerts.Text += "Could not determine the group role to use for the add.";
return;
}
// get person
if ( Request["PersonGuid"] != null )
{
Guid.TryParse( Request["PersonGuid"], out personGuid );
}
if ( personGuid == Guid.Empty )
{
lAlerts.Text += "A valid person identifier was not found in the page address.";
return;
}
// ensure that the group type has this role
if ( ! group.GroupType.Roles.Contains( groupMemberRole ) )
{
lAlerts.Text += "The group you have provided does not have the group member role configured.";
return;
}
// get person
Person person = new PersonService( rockContext ).Get( personGuid );
if ( person == null )
{
lAlerts.Text += "A person could not be found for the identifier provided.";
return;
}
// hide alert
divAlert.Visible = false;
// get status
var groupMemberStatus = this.GetAttributeValue( "GroupMemberStatus" ).ConvertToEnum<GroupMemberStatus>( GroupMemberStatus.Active );
// load merge fields
var mergeFields = new Dictionary<string, object>();
mergeFields.Add( "GroupMemberStatus", groupMemberStatus.ToString() );
mergeFields.Add( "Group", group );
mergeFields.Add( "Person", person );
mergeFields.Add( "Role", groupMemberRole );
mergeFields.Add( "CurrentPerson", CurrentPerson );
// show debug info?
bool enableDebug = GetAttributeValue( "EnableDebug" ).AsBoolean();
if ( enableDebug && IsUserAuthorized( Authorization.EDIT ) )
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
// ensure that the person is not already in the group
if ( group.Members.Where( m => m.PersonId == person.Id && m.GroupRoleId == groupMemberRole.Id ).Count() != 0 )
{
string templateInGroup = GetAttributeValue( "AlreadyInGroupMessage" );
lContent.Text = templateInGroup.ResolveMergeFields( mergeFields );
return;
}
// add person to group
GroupMember groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.PersonId = person.Id;
groupMember.GroupRoleId = groupMemberRole.Id;
groupMember.GroupMemberStatus = groupMemberStatus;
group.Members.Add( groupMember );
try
{
rockContext.SaveChanges();
}
catch ( Exception ex )
{
divAlert.Visible = true;
lAlerts.Text = String.Format( "An error occurred adding {0} to the group {1}. Message: {2}.", person.FullName, group.Name, ex.Message );
}
string templateSuccess = GetAttributeValue( "SuccessMessage" );
lContent.Text = templateSuccess.ResolveMergeFields( mergeFields );
}
}
/// <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 ( Page.IsValid )
{
var rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
GroupMember groupMember;
int groupMemberId = int.Parse( hfGroupMemberId.Value );
GroupTypeRole role = new GroupTypeRoleService( rockContext ).Get( ddlGroupRole.SelectedValueAsInt() ?? 0 );
// check to see if the user selected a role
if ( role == null )
{
nbErrorMessage.Title = "Please select a Role";
return;
}
// if adding a new group member
if ( groupMemberId.Equals( 0 ) )
{
groupMember = new GroupMember { Id = 0 };
groupMember.GroupId = hfGroupId.ValueAsInt();
}
else
{
// load existing group member
groupMember = groupMemberService.Get( groupMemberId );
}
groupMember.PersonId = ppGroupMemberPerson.PersonId.Value;
groupMember.GroupRoleId = role.Id;
groupMember.GroupMemberStatus = rblStatus.SelectedValueAsEnum<GroupMemberStatus>();
groupMember.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, groupMember );
if ( !Page.IsValid )
{
return;
}
cvGroupMember.IsValid = groupMember.IsValid;
if ( !cvGroupMember.IsValid )
{
cvGroupMember.ErrorMessage = groupMember.ValidationResults.Select( a => a.ErrorMessage ).ToList().AsDelimited( "<br />" );
return;
}
// using WrapTransaction because there are two Saves
rockContext.WrapTransaction( () =>
{
if ( groupMember.Id.Equals( 0 ) )
{
groupMemberService.Add( groupMember );
}
rockContext.SaveChanges();
groupMember.SaveAttributeValues( rockContext );
} );
Group group = new GroupService( rockContext ).Get( groupMember.GroupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
Dictionary<string, string> qryString = new Dictionary<string, string>();
qryString["GroupId"] = hfGroupId.Value;
NavigateToParentPage( qryString );
}
/// <summary>
/// Binds the contact list grid.
/// </summary>
/// <param name="business">The business.</param>
private void BindContactListGrid( Person business )
{
// Load up that contact list.
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
int? businessContactRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT ) ) )
.Select( r => r.Id )
.FirstOrDefault();
// I want a list of people that are connected to this business/person by the business contact relationship
List<GroupMember> contactList = new List<GroupMember>();
if ( business.GivingGroup != null )
{
contactList = business.GivingGroup.Members.Where( g => g.GroupRoleId == businessContactRoleId ).ToList();
List<Person> personList = new List<Person>();
foreach ( var contact in contactList )
{
personList.Add( contact.Person );
}
gContactList.DataSource = personList;
gContactList.DataBind();
}
else
{
gContactList.Visible = false;
}
}
/// <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 inverse relationship.
/// Returns the <see cref="Rock.Model.GroupMember" /> who has an inverse relationship to the provided <see cref="Rock.Model.GroupMember" />.
/// </summary>
/// <param name="groupMember">A <see cref="Rock.Model.GroupMember" /> representing the person to find the inverse relationship for.</param>
/// <param name="createGroup">A <see cref="System.Boolean" /> flag indicating if a new <see cref="Rock.Model.Group" /> can be created
/// for the person with the inverse relationship.</param>
/// <returns>
/// A <see cref="Rock.Model.GroupMember" /> representing the <see cref="Rock.Model.Person" /> with the inverse relationship.
/// </returns>
/// <remarks>
/// In Rock, examples of inverse relationships include: Parent/Child, Can Check In/Check in By, Sibling/Sibling, Grandparent/Grandchild, etc.
/// </remarks>
public GroupMember GetInverseRelationship(GroupMember groupMember, bool createGroup)
{
var groupRole = groupMember.GroupRole;
if (groupRole == null)
{
groupRole = Queryable()
.Where(m => m.Id == groupMember.Id)
.Select(m => m.GroupRole)
.FirstOrDefault();
}
if (groupRole != null)
{
if (groupRole.Attributes == null)
{
groupRole.LoadAttributes();
}
if (groupRole.Attributes.ContainsKey("InverseRelationship"))
{
Guid ownerRoleGuid = new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER);
var memberInfo = Queryable(true)
.Where(m =>
m.GroupId == groupMember.GroupId &&
m.GroupRole.Guid.Equals(ownerRoleGuid))
.Select(m => new
{
PersonId = m.PersonId,
RoleId = m.GroupRoleId
})
.FirstOrDefault();
int?ownerPersonId = null;
int?ownerRoleId = null;
if (memberInfo != null)
{
ownerPersonId = memberInfo.PersonId;
ownerRoleId = memberInfo.RoleId;
}
if (ownerPersonId.HasValue && ownerRoleId.HasValue)
{
// Find related person's group
var inverseGroup = Queryable()
.Where(m =>
m.PersonId == groupMember.PersonId &&
m.Group.GroupTypeId == groupRole.GroupTypeId &&
m.GroupRole.Guid.Equals(ownerRoleGuid))
.Select(m => m.Group)
.FirstOrDefault();
if (inverseGroup == null && createGroup)
{
var ownerGroupMember = new GroupMember();
ownerGroupMember.PersonId = groupMember.PersonId;
ownerGroupMember.GroupRoleId = ownerRoleId.Value;
inverseGroup = new Group();
inverseGroup.Name = groupRole.GroupType.Name;
inverseGroup.GroupTypeId = groupRole.GroupTypeId.Value;
inverseGroup.Members.Add(ownerGroupMember);
}
if (inverseGroup != null)
{
Guid inverseRoleGuid = Guid.Empty;
if (Guid.TryParse(groupRole.GetAttributeValue("InverseRelationship"), out inverseRoleGuid))
{
var inverseGroupMember = Queryable()
.Where(m =>
m.PersonId == ownerPersonId &&
m.GroupId == inverseGroup.Id &&
m.GroupRole.Guid.Equals(inverseRoleGuid))
.FirstOrDefault();
if (inverseGroupMember == null)
{
var inverseRole = new GroupTypeRoleService((RockContext)Context).Get(inverseRoleGuid);
if (inverseRole != null)
{
inverseGroupMember = new GroupMember();
inverseGroupMember.PersonId = ownerPersonId.Value;
inverseGroupMember.Group = inverseGroup;
inverseGroupMember.GroupRoleId = inverseRole.Id;
Add(inverseGroupMember);
}
}
return(inverseGroupMember);
}
}
}
}
}
return(null);
}
/// <summary>
/// Loads the individual data.
/// </summary>
/// <param name="csvData">The CSV data.</param>
private int LoadIndividuals( CSVInstance csvData )
{
var lookupContext = new RockContext();
var groupTypeRoleService = new GroupTypeRoleService( lookupContext );
var groupMemberService = new GroupMemberService( lookupContext );
// Marital statuses: Married, Single, Separated, etc
var maritalStatusTypes = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_MARITAL_STATUS ), lookupContext ).DefinedValues;
// Connection statuses: Member, Visitor, Attendee, etc
var connectionStatusTypes = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_CONNECTION_STATUS ), lookupContext ).DefinedValues;
int memberConnectionStatusId = connectionStatusTypes.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_MEMBER ) ).Id;
int visitorConnectionStatusId = connectionStatusTypes.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_VISITOR ) ).Id;
int attendeeConnectionStatusId = connectionStatusTypes.FirstOrDefault( dv => dv.Guid == new Guid( Rock.SystemGuid.DefinedValue.PERSON_CONNECTION_STATUS_ATTENDEE ) ).Id;
// Suffix type: Dr., Jr., II, etc
var suffixTypes = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_SUFFIX ), lookupContext ).DefinedValues;
// Title type: Mr., Mrs. Dr., etc
var titleTypes = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_TITLE ), lookupContext ).DefinedValues;
// Record statuses: Active, Inactive, Pending
int? recordStatusActiveId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE ), lookupContext ).Id;
int? recordStatusInactiveId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ), lookupContext ).Id;
int? recordStatusPendingId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_PENDING ), lookupContext ).Id;
// Deceased record status reason (others available: No Activity, Moved, etc)
var recordStatusDeceasedId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_REASON_DECEASED ) ).Id;
// Record type: Person
int? personRecordTypeId = DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON ), lookupContext ).Id;
// Group roles: Owner, Adult, Child, others
GroupTypeRole ownerRole = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) );
int adultRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ).Id;
int childRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD ) ).Id;
// Phone types: Home, Work, Mobile
var numberTypeValues = DefinedTypeCache.Read( new Guid( Rock.SystemGuid.DefinedType.PERSON_PHONE_TYPE ), lookupContext ).DefinedValues;
// Personal note type id
var personalNoteTypeId = new NoteTypeService( lookupContext ).Get( new Guid( Rock.SystemGuid.NoteType.PERSON_TIMELINE_NOTE ) ).Id;
// School defined type
var schoolDefinedType = DefinedTypeCache.Read( new Guid( "576FF1E2-6225-4565-A16D-230E26167A3D" ) );
// Look up existing Person attributes
var personAttributes = new AttributeService( lookupContext ).GetByEntityTypeId( PersonEntityTypeId ).ToList();
var schoolAttribute = AttributeCache.Read( personAttributes.FirstOrDefault( a => a.Key == "School" ) );
// Text field type id
int textFieldTypeId = FieldTypeCache.Read( new Guid( Rock.SystemGuid.FieldType.TEXT ), lookupContext ).Id;
int dateFieldTypeId = FieldTypeCache.Read( new Guid( Rock.SystemGuid.FieldType.DATE ), lookupContext ).Id;
// Attribute entity type id
int attributeEntityTypeId = EntityTypeCache.Read( "Rock.Model.Attribute" ).Id;
// Visit info category
var visitInfoCategory = new CategoryService( lookupContext ).GetByEntityTypeId( attributeEntityTypeId )
.Where( c => c.Name == "Visit Information" ).FirstOrDefault();
// Look for custom attributes in the Individual file
var allFields = csvData.TableNodes.FirstOrDefault().Children.Select( ( node, index ) => new { node = node, index = index } ).ToList();
Dictionary<int, string> customAttributes = allFields
.Where( f => f.index > SecurityNote )
.ToDictionary( f => f.index, f => f.node.Name.RemoveWhitespace() );
// Add any attributes if they don't already exist
if ( customAttributes.Any() )
{
var newAttributes = new List<Rock.Model.Attribute>();
foreach ( var newAttributePair in customAttributes.Where( ca => !personAttributes.Any( a => a.Key == ca.Value ) ) )
{
var newAttribute = new Rock.Model.Attribute();
newAttribute.Name = newAttributePair.Value;
newAttribute.Key = newAttributePair.Value.RemoveWhitespace();
newAttribute.Description = newAttributePair.Value + " created by CSV import";
newAttribute.EntityTypeQualifierValue = string.Empty;
newAttribute.EntityTypeQualifierColumn = string.Empty;
newAttribute.EntityTypeId = PersonEntityTypeId;
newAttribute.FieldTypeId = textFieldTypeId;
newAttribute.DefaultValue = string.Empty;
newAttribute.IsMultiValue = false;
newAttribute.IsGridColumn = false;
newAttribute.IsRequired = false;
newAttribute.Order = 0;
newAttributes.Add( newAttribute );
}
lookupContext.Attributes.AddRange( newAttributes );
lookupContext.SaveChanges( DisableAuditing );
personAttributes.AddRange( newAttributes );
}
// Set the supported date formats
var dateFormats = new[] { "yyyy-MM-dd", "MM/dd/yyyy", "MM/dd/yy" };
var currentFamilyGroup = new Group();
var newFamilyList = new List<Group>();
var newVisitorList = new List<Group>();
var newNoteList = new List<Note>();
int completed = 0;
int newFamilies = 0;
int newPeople = 0;
ReportProgress( 0, string.Format( "Starting Individual import ({0:N0} already exist).", ImportedPeopleKeys.Count() ) );
string[] row;
row = csvData.Database.FirstOrDefault();
while ( row != null )
{
int groupRoleId = adultRoleId;
bool isFamilyRelationship = true;
string rowFamilyName = row[FamilyName];
string rowFamilyKey = row[FamilyId];
string rowPersonKey = row[PersonId];
int? rowFamilyId = rowFamilyKey.AsType<int?>();
int? rowPersonId = rowPersonKey.AsType<int?>();
// Check that this person isn't already in our data
var personExists = ImportedFamilies.Any( g => g.Members.Any( m => m.Person.ForeignKey == rowPersonKey ) );
if ( !personExists )
{
#region person create
var person = new Person();
person.ForeignKey = rowPersonKey;
person.ForeignId = rowPersonId;
person.SystemNote = string.Format( "Imported via Excavator on {0}", ImportDateTime );
person.RecordTypeValueId = personRecordTypeId;
person.CreatedByPersonAliasId = ImportPersonAliasId;
string firstName = row[FirstName].Left( 50 );
string nickName = row[NickName].Left( 50 );
person.FirstName = firstName;
person.NickName = string.IsNullOrWhiteSpace( nickName ) ? firstName : nickName;
person.MiddleName = row[MiddleName].Left( 50 );
person.LastName = row[LastName].Left( 50 );
DateTime createdDateValue;
if ( DateTime.TryParseExact( row[CreatedDate], dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out createdDateValue ) )
{
person.CreatedDateTime = createdDateValue;
person.ModifiedDateTime = ImportDateTime;
}
else
{
person.CreatedDateTime = ImportDateTime;
person.ModifiedDateTime = ImportDateTime;
}
DateTime birthDate;
if ( DateTime.TryParseExact( row[DateOfBirth], dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out birthDate ) )
{
person.BirthDay = birthDate.Day;
person.BirthMonth = birthDate.Month;
person.BirthYear = birthDate.Year;
}
DateTime graduationDate;
if ( DateTime.TryParseExact( row[GraduationDate], dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out graduationDate ) )
{
person.GraduationYear = graduationDate.Year;
}
DateTime anniversary;
if ( DateTime.TryParseExact( row[Anniversary], dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out anniversary ) )
{
person.AnniversaryDate = anniversary;
}
string gender = row[Gender];
if ( gender != null )
{
switch ( gender.Trim().ToLower() )
{
case "m":
case "male":
person.Gender = Rock.Model.Gender.Male;
break;
case "f":
case "female":
person.Gender = Rock.Model.Gender.Female;
break;
default:
person.Gender = Rock.Model.Gender.Unknown;
break;
}
}
string prefix = row[Prefix];
if ( !string.IsNullOrWhiteSpace( prefix ) )
{
prefix = prefix.RemoveSpecialCharacters().Trim();
person.TitleValueId = titleTypes.Where( s => prefix == s.Value.RemoveSpecialCharacters() )
.Select( s => (int?)s.Id ).FirstOrDefault();
}
string suffix = row[Suffix];
if ( !string.IsNullOrWhiteSpace( suffix ) )
{
suffix = suffix.RemoveSpecialCharacters().Trim();
person.SuffixValueId = suffixTypes.Where( s => suffix == s.Value.RemoveSpecialCharacters() )
.Select( s => (int?)s.Id ).FirstOrDefault();
}
string maritalStatus = row[MaritalStatus];
if ( !string.IsNullOrWhiteSpace( maritalStatus ) )
{
person.MaritalStatusValueId = maritalStatusTypes.Where( dv => dv.Value == maritalStatus )
.Select( dv => (int?)dv.Id ).FirstOrDefault();
}
else
{
person.MaritalStatusValueId = maritalStatusTypes.Where( dv => dv.Value == "Unknown" )
.Select( dv => ( int? )dv.Id ).FirstOrDefault();
}
string familyRole = row[FamilyRole];
if ( !string.IsNullOrWhiteSpace( familyRole ) )
{
if ( familyRole == "Visitor" )
{
isFamilyRelationship = false;
}
if ( familyRole == "Child" || person.Age < 18 )
{
groupRoleId = childRoleId;
}
}
string connectionStatus = row[ConnectionStatus];
if ( !string.IsNullOrWhiteSpace( connectionStatus ) )
{
if ( connectionStatus == "Member" )
{
person.ConnectionStatusValueId = memberConnectionStatusId;
}
else if ( connectionStatus == "Visitor" )
{
person.ConnectionStatusValueId = visitorConnectionStatusId;
}
else
{
// look for user-defined connection type or default to Attendee
var customConnectionType = connectionStatusTypes.Where( dv => dv.Value == connectionStatus )
.Select( dv => (int?)dv.Id ).FirstOrDefault();
person.ConnectionStatusValueId = customConnectionType ?? attendeeConnectionStatusId;
person.RecordStatusValueId = recordStatusActiveId;
}
}
string recordStatus = row[RecordStatus];
if ( !string.IsNullOrWhiteSpace( recordStatus ) )
{
switch ( recordStatus.Trim().ToLower() )
{
case "active":
person.RecordStatusValueId = recordStatusActiveId;
break;
case "inactive":
person.RecordStatusValueId = recordStatusInactiveId;
break;
default:
person.RecordStatusValueId = recordStatusPendingId;
break;
}
}
string isDeceasedValue = row[IsDeceased];
if ( !string.IsNullOrWhiteSpace( isDeceasedValue ) )
{
switch ( isDeceasedValue.Trim().ToLower() )
{
case "y":
case "yes":
person.IsDeceased = true;
person.RecordStatusReasonValueId = recordStatusDeceasedId;
person.RecordStatusValueId = recordStatusInactiveId;
break;
default:
person.IsDeceased = false;
break;
}
}
var personNumbers = new Dictionary<string, string>();
personNumbers.Add( "Home", row[HomePhone] );
personNumbers.Add( "Mobile", row[MobilePhone] );
personNumbers.Add( "Work", row[WorkPhone] );
string smsAllowed = row[AllowSMS];
foreach ( var numberPair in personNumbers.Where( n => !string.IsNullOrWhiteSpace( n.Value ) ) )
{
var extension = string.Empty;
var countryCode = Rock.Model.PhoneNumber.DefaultCountryCode();
var normalizedNumber = string.Empty;
var countryIndex = numberPair.Value.IndexOf( '+' );
int extensionIndex = numberPair.Value.LastIndexOf( 'x' ) > 0 ? numberPair.Value.LastIndexOf( 'x' ) : numberPair.Value.Length;
if ( countryIndex >= 0 )
{
countryCode = numberPair.Value.Substring( countryIndex, countryIndex + 3 ).AsNumeric();
normalizedNumber = numberPair.Value.Substring( countryIndex + 3, extensionIndex - 3 ).AsNumeric().TrimStart( new Char[] { '0' } );
extension = numberPair.Value.Substring( extensionIndex );
}
else if ( extensionIndex > 0 )
{
normalizedNumber = numberPair.Value.Substring( 0, extensionIndex ).AsNumeric();
extension = numberPair.Value.Substring( extensionIndex ).AsNumeric();
}
else
{
normalizedNumber = numberPair.Value.AsNumeric();
}
if ( !string.IsNullOrWhiteSpace( normalizedNumber ) )
{
var currentNumber = new PhoneNumber();
currentNumber.CountryCode = countryCode;
currentNumber.CreatedByPersonAliasId = ImportPersonAliasId;
currentNumber.Extension = extension.Left( 20 );
currentNumber.Number = normalizedNumber.TrimStart( new Char[] { '0' } ).Left( 20 );
currentNumber.NumberFormatted = PhoneNumber.FormattedNumber( currentNumber.CountryCode, currentNumber.Number );
currentNumber.NumberTypeValueId = numberTypeValues.Where( v => v.Value.Equals( numberPair.Key ) )
.Select( v => ( int? )v.Id ).FirstOrDefault();
if ( numberPair.Key == "Mobile" )
{
switch ( smsAllowed.Trim().ToLower() )
{
case "y":
case "yes":
case "active":
currentNumber.IsMessagingEnabled = true;
break;
default:
currentNumber.IsMessagingEnabled = false;
break;
}
}
person.PhoneNumbers.Add( currentNumber );
}
}
// Map Person attributes
person.Attributes = new Dictionary<string, AttributeCache>();
person.AttributeValues = new Dictionary<string, AttributeValueCache>();
bool isEmailActive;
switch ( row[IsEmailActive].Trim().ToLower() )
{
case "n":
case "no":
case "inactive":
isEmailActive = false;
break;
default:
isEmailActive = true;
break;
}
EmailPreference emailPreference;
switch ( row[AllowBulkEmail].Trim().ToLower() )
{
case "n":
case "no":
case "inactive":
emailPreference = EmailPreference.NoMassEmails;
break;
default:
emailPreference = EmailPreference.EmailAllowed;
break;
}
person.EmailPreference = emailPreference;
string primaryEmail = row[Email].Trim().Left( 75 );
if ( !string.IsNullOrWhiteSpace( primaryEmail ) )
{
if ( primaryEmail.IsEmail() )
{
person.Email = primaryEmail;
person.IsEmailActive = isEmailActive;
}
else
{
LogException( "InvalidPrimaryEmail", string.Format( "PersonId: {0} - Email: {1}", rowPersonKey, primaryEmail ) );
}
}
string schoolName = row[School];
if ( !string.IsNullOrWhiteSpace( schoolName ) )
{
// Add school if it doesn't exist
Guid schoolGuid;
var schoolExists = lookupContext.DefinedValues.Any( s => s.DefinedTypeId == schoolDefinedType.Id && s.Value.Equals( schoolName ) );
if ( !schoolExists )
{
var newSchool = new DefinedValue();
newSchool.DefinedTypeId = schoolDefinedType.Id;
newSchool.Value = schoolName;
newSchool.Order = 0;
lookupContext.DefinedValues.Add( newSchool );
lookupContext.SaveChanges();
schoolGuid = newSchool.Guid;
}
else
{
schoolGuid = lookupContext.DefinedValues.FirstOrDefault( s => s.Value.Equals( schoolName ) ).Guid;
}
AddPersonAttribute( schoolAttribute, person, schoolGuid.ToString().ToUpper() );
}
foreach ( var attributePair in customAttributes )
{
string newAttributeValue = row[attributePair.Key];
if ( !string.IsNullOrWhiteSpace( newAttributeValue ) )
{
// check if this attribute value is a date
DateTime valueAsDateTime;
if ( DateTime.TryParseExact( newAttributeValue, dateFormats, CultureInfo.InvariantCulture, DateTimeStyles.None, out valueAsDateTime ) )
{
newAttributeValue = valueAsDateTime.ToString( "yyyy-MM-dd" );
}
int? newAttributeId = personAttributes.Where( a => a.Key == attributePair.Value.RemoveWhitespace() )
.Select( a => (int?)a.Id ).FirstOrDefault();
if ( newAttributeId != null )
{
var newAttribute = AttributeCache.Read( (int)newAttributeId );
AddPersonAttribute( newAttribute, person, newAttributeValue );
}
}
}
// Add notes to timeline
var notePairs = new Dictionary<string, string>();
notePairs.Add( "General", row[GeneralNote] );
notePairs.Add( "Medical", row[MedicalNote] );
notePairs.Add( "Security", row[SecurityNote] );
foreach ( var notePair in notePairs.Where( n => !string.IsNullOrWhiteSpace( n.Value ) ) )
{
var newNote = new Note();
newNote.NoteTypeId = personalNoteTypeId;
newNote.CreatedByPersonAliasId = ImportPersonAliasId;
newNote.CreatedDateTime = ImportDateTime;
newNote.Text = notePair.Value;
newNote.ForeignKey = rowPersonKey;
newNote.ForeignId = rowPersonId;
newNote.Caption = string.Format( "{0} Note", notePair.Key );
if ( !notePair.Key.Equals( "General" ) )
{
newNote.IsAlert = true;
}
newNoteList.Add( newNote );
}
#endregion person create
var groupMember = new GroupMember();
groupMember.Person = person;
groupMember.GroupRoleId = groupRoleId;
groupMember.CreatedDateTime = ImportDateTime;
groupMember.ModifiedDateTime = ImportDateTime;
groupMember.CreatedByPersonAliasId = ImportPersonAliasId;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
if ( rowFamilyKey != currentFamilyGroup.ForeignKey )
{
// person not part of the previous family, see if that family exists or create a new one
currentFamilyGroup = ImportedFamilies.FirstOrDefault( g => g.ForeignKey == rowFamilyKey );
if ( currentFamilyGroup == null )
{
currentFamilyGroup = CreateFamilyGroup( row[FamilyName], rowFamilyKey );
newFamilyList.Add( currentFamilyGroup );
newFamilies++;
}
else
{
lookupContext.Groups.Attach( currentFamilyGroup );
lookupContext.Entry( currentFamilyGroup ).State = EntityState.Modified;
}
currentFamilyGroup.Members.Add( groupMember );
}
else
{
// person is part of this family group, check if they're a visitor
if ( isFamilyRelationship || currentFamilyGroup.Members.Count() < 1 )
{
currentFamilyGroup.Members.Add( groupMember );
}
else
{
var visitorFamily = CreateFamilyGroup( person.LastName + " Family", rowFamilyKey );
visitorFamily.Members.Add( groupMember );
newFamilyList.Add( visitorFamily );
newVisitorList.Add( visitorFamily );
newFamilies++;
}
}
// look ahead 1 row
string rowNextFamilyKey = "-1";
if ( (row = csvData.Database.FirstOrDefault()) != null )
{
rowNextFamilyKey = row[FamilyId];
}
newPeople++;
completed++;
if ( completed % (ReportingNumber * 10) < 1 )
{
ReportProgress( 0, string.Format( "{0:N0} people imported.", completed ) );
}
if ( newPeople >= ReportingNumber && rowNextFamilyKey != currentFamilyGroup.ForeignKey )
{
SaveIndividuals( newFamilyList, newVisitorList, newNoteList );
lookupContext.SaveChanges();
ReportPartialProgress();
// Clear out variables
currentFamilyGroup = new Group();
newFamilyList.Clear();
newVisitorList.Clear();
newNoteList.Clear();
newPeople = 0;
}
}
else
{
row = csvData.Database.FirstOrDefault();
}
}
// Save any changes to new families
if ( newFamilyList.Any() )
{
SaveIndividuals( newFamilyList, newVisitorList, newNoteList );
}
// Save any changes to existing families
lookupContext.SaveChanges();
DetachAllInContext( lookupContext );
lookupContext.Dispose();
ReportProgress( 0, string.Format( "Finished individual import: {0:N0} families and {1:N0} people added.", newFamilies, completed ) );
return completed;
}
/// <summary>
/// Handles the SelectItem event of the gp control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void gp_SelectItem( object sender, EventArgs e )
{
int groupId = gp.SelectedValueAsId() ?? 0;
var groupService = new GroupService();
var group = groupService.Get( groupId );
if ( group != null )
{
var groupTypeRoleService = new GroupTypeRoleService();
var list = groupTypeRoleService.Queryable().Where( a => a.GroupTypeId == group.GroupTypeId ).OrderBy( a => a.Order ).ToList();
cblRole.Items.Clear();
foreach ( var item in list )
{
cblRole.Items.Add( new ListItem( item.Name, item.Id.ToString() ) );
}
cblRole.Visible = list.Count > 0;
}
else
{
cblRole.Visible = false;
}
}
/// <summary>
/// Saves the individuals.
/// </summary>
/// <param name="newFamilyList">The family list.</param>
/// <param name="visitorList">The optional visitor list.</param>
private void SaveIndividuals( List<Group> newFamilyList, List<Group> visitorList = null, List<Note> newNoteList = null )
{
if ( newFamilyList.Any() )
{
var rockContext = new RockContext();
rockContext.WrapTransaction( ( ) =>
{
rockContext.Groups.AddRange( newFamilyList );
rockContext.SaveChanges( DisableAuditing );
ImportedFamilies.AddRange( newFamilyList );
foreach ( var familyGroups in newFamilyList.GroupBy<Group, string>( g => g.ForeignKey ) )
{
bool visitorsExist = visitorList.Any() && familyGroups.Any();
foreach ( var newFamilyGroup in familyGroups )
{
foreach ( var person in newFamilyGroup.Members.Select( m => m.Person ) )
{
// Set notes on this person
if ( newNoteList.Any( n => n.ForeignKey == person.ForeignKey ) )
{
newNoteList.Where( n => n.ForeignKey == person.ForeignKey ).ToList()
.ForEach( n => n.EntityId = person.Id );
}
// Set attributes on this person
foreach ( var attributeCache in person.Attributes.Select( a => a.Value ) )
{
var existingValue = rockContext.AttributeValues.FirstOrDefault( v => v.Attribute.Key == attributeCache.Key && v.EntityId == person.Id );
var newAttributeValue = person.AttributeValues[attributeCache.Key];
// set the new value and add it to the database
if ( existingValue == null )
{
existingValue = new AttributeValue();
existingValue.AttributeId = newAttributeValue.AttributeId;
existingValue.EntityId = person.Id;
existingValue.Value = newAttributeValue.Value;
rockContext.AttributeValues.Add( existingValue );
}
else
{
existingValue.Value = newAttributeValue.Value;
rockContext.Entry( existingValue ).State = EntityState.Modified;
}
}
// Set aliases on this person
if ( !person.Aliases.Any( a => a.PersonId == person.Id ) )
{
person.Aliases.Add( new PersonAlias
{
AliasPersonId = person.Id,
AliasPersonGuid = person.Guid,
ForeignKey = person.ForeignKey,
ForeignId = person.ForeignId,
PersonId = person.Id
} );
}
person.GivingGroupId = newFamilyGroup.Id;
if ( visitorsExist )
{
var groupTypeRoleService = new GroupTypeRoleService( rockContext );
var ownerRole = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) );
int inviteeRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED ) ).Id;
int invitedByRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_INVITED_BY ) ).Id;
int canCheckInRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_CAN_CHECK_IN ) ).Id;
int allowCheckInByRoleId = groupTypeRoleService.Get( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_ALLOW_CHECK_IN_BY ) ).Id;
// Retrieve or create the group this person is an owner of
var ownerGroup = new GroupMemberService( rockContext ).Queryable()
.Where( m => m.PersonId == person.Id && m.GroupRoleId == ownerRole.Id )
.Select( m => m.Group ).FirstOrDefault();
if ( ownerGroup == null )
{
var ownerGroupMember = new GroupMember();
ownerGroupMember.PersonId = person.Id;
ownerGroupMember.GroupRoleId = ownerRole.Id;
ownerGroup = new Group();
ownerGroup.Name = ownerRole.GroupType.Name;
ownerGroup.GroupTypeId = ownerRole.GroupTypeId.Value;
ownerGroup.Members.Add( ownerGroupMember );
rockContext.Groups.Add( ownerGroup );
}
// Visitor, add relationships to the family members
if ( visitorList.Where( v => v.ForeignKey == newFamilyGroup.ForeignKey )
.Any( v => v.Members.Any( m => m.Person.ForeignKey.Equals( person.ForeignKey ) ) ) )
{
var familyMembers = familyGroups.Except( visitorList ).SelectMany( g => g.Members );
foreach ( var familyMember in familyMembers )
{
// Add visitor invitedBy relationship
var invitedByMember = new GroupMember();
invitedByMember.PersonId = familyMember.Person.Id;
invitedByMember.GroupRoleId = invitedByRoleId;
ownerGroup.Members.Add( invitedByMember );
if ( person.Age < 18 && familyMember.Person.Age > 15 )
{
// Add visitor allowCheckInBy relationship
var allowCheckinMember = new GroupMember();
allowCheckinMember.PersonId = familyMember.Person.Id;
allowCheckinMember.GroupRoleId = allowCheckInByRoleId;
ownerGroup.Members.Add( allowCheckinMember );
}
}
}
else
{ // Family member, add relationships to the visitor(s)
var familyVisitors = visitorList.Where( v => v.ForeignKey == newFamilyGroup.ForeignKey ).SelectMany( g => g.Members ).ToList();
foreach ( var visitor in familyVisitors )
{
// Add invited visitor relationship
var inviteeMember = new GroupMember();
inviteeMember.PersonId = visitor.Person.Id;
inviteeMember.GroupRoleId = inviteeRoleId;
ownerGroup.Members.Add( inviteeMember );
if ( visitor.Person.Age < 18 && person.Age > 15 )
{
// Add canCheckIn visitor relationship
var canCheckInMember = new GroupMember();
canCheckInMember.PersonId = visitor.Person.Id;
canCheckInMember.GroupRoleId = canCheckInRoleId;
ownerGroup.Members.Add( canCheckInMember );
}
}
}
}
}
}
}
// Save notes and all changes
rockContext.Notes.AddRange( newNoteList );
rockContext.SaveChanges( DisableAuditing );
} );
}
}
/// <summary>
/// Sets the relationships between a business and it's owner.
/// </summary>
/// <param name="business">The business.</param>
private void SetRelationships( Person business )
{
var rockContext = new RockContext();
var personService = new PersonService( rockContext );
var groupMemberService = new GroupMemberService( rockContext );
int? businessRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS ) ) )
.Select( r => r.Id )
.FirstOrDefault();
int? principleRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_PRINCIPLE ) ) )
.Select( r => r.Id )
.FirstOrDefault();
// get the known relationship group from the owner
// add the business as a group member of that group using group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS
var owner = personService.Get( (int)ppOwner.PersonId );
var knownRelationshipGroup = groupMemberService.Queryable()
.Where( g =>
g.GroupRole.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER ) ) &&
g.PersonId == owner.Id )
.Select( g => g.Group ).FirstOrDefault();
var groupMember = new GroupMember();
groupMember.PersonId = int.Parse( hfBusinessId.Value );
groupMember.GroupRoleId = (int)businessRoleId;
knownRelationshipGroup.Members.Add( groupMember );
rockContext.SaveChanges();
// get the known relationship group from the business
// add the owner as a group member of that group using group role of GROUPROLE_KNOWN_RELATIONSHIPS_PRINCIPLE
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 = owner.Id;
businessGroupMember.GroupRoleId = (int)principleRoleId;
businessKnownRelationshipGroup.Members.Add( businessGroupMember );
rockContext.SaveChanges();
}
/// <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 business = personService.Get( int.Parse( hfBusinessId.Value ) );
var contactId = (int)ppContact.PersonId;
if ( contactId > 0 )
{
int? businessContactRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT ) ) )
.Select( r => r.Id )
.FirstOrDefault();
var groupMember = business.GivingGroup.Members.Where( role => role.GroupRoleId == businessContactRoleId ).FirstOrDefault();
if ( groupMember == null )
{
groupMember = new GroupMember();
business.GivingGroup.Members.Add( groupMember );
}
groupMember.Person = personService.Get( (int)ppContact.PersonId );
groupMember.GroupRoleId = (int)businessContactRoleId;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
rockContext.SaveChanges();
}
mdAddContact.Hide();
hfModalOpen.Value = string.Empty;
BindContactListGrid( business );
}
/// <summary>
/// Handles the Click event of the btnSaveGroupMember 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 btnSaveGroupMember_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
GroupTypeRole role = new GroupTypeRoleService( rockContext ).Get( ddlGroupRole.SelectedValueAsInt() ?? 0 );
var groupMember = groupMemberService.Get( this.CurrentGroupMemberId );
if ( this.CurrentGroupMemberId == 0 )
{
groupMember = new GroupMember { Id = 0 };
groupMember.GroupId = _groupId;
// check to see if the person is alread a member of the gorup/role
var existingGroupMember = groupMemberService.GetByGroupIdAndPersonIdAndGroupRoleId(
_groupId, ppGroupMemberPerson.SelectedValue ?? 0, ddlGroupRole.SelectedValueAsId() ?? 0 );
if ( existingGroupMember != null )
{
// if so, don't add and show error message
var person = new PersonService( rockContext ).Get( (int)ppGroupMemberPerson.PersonId );
nbGroupMemberErrorMessage.Title = "Person Already In Group";
nbGroupMemberErrorMessage.Text = string.Format(
"{0} already belongs to the {1} role for this {2}, and cannot be added again with the same role.",
person.FullName,
ddlGroupRole.SelectedItem.Text,
role.GroupType.GroupTerm,
RockPage.PageId,
existingGroupMember.Id );
return;
}
}
groupMember.PersonId = ppGroupMemberPerson.PersonId.Value;
groupMember.GroupRoleId = role.Id;
// set their status. If HideInactiveGroupMemberStatus is True, and they are already Inactive, keep their status as Inactive;
bool hideGroupMemberInactiveStatus = this.GetAttributeValue( "HideInactiveGroupMemberStatus" ).AsBooleanOrNull() ?? false;
var selectedStatus = rblStatus.SelectedValueAsEnumOrNull<GroupMemberStatus>();
if ( !selectedStatus.HasValue )
{
if ( hideGroupMemberInactiveStatus )
{
selectedStatus = GroupMemberStatus.Inactive;
}
else
{
selectedStatus = GroupMemberStatus.Active;
}
}
groupMember.GroupMemberStatus = selectedStatus.Value;
groupMember.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, groupMember );
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
cvEditGroupMember.IsValid = groupMember.IsValid;
if ( !cvEditGroupMember.IsValid )
{
cvEditGroupMember.ErrorMessage = groupMember.ValidationResults.Select( a => a.ErrorMessage ).ToList().AsDelimited( "<br />" );
return;
}
// using WrapTransaction because there are two Saves
rockContext.WrapTransaction( () =>
{
if ( groupMember.Id.Equals( 0 ) )
{
groupMemberService.Add( groupMember );
}
rockContext.SaveChanges();
groupMember.SaveAttributeValues( rockContext );
} );
Group group = new GroupService( rockContext ).Get( groupMember.GroupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
Rock.Security.Role.Flush( group.Id );
}
pnlEditGroupMember.Visible = false;
pnlGroupView.Visible = true;
DisplayViewGroup();
this.IsEditingGroupMember = false;
}
/// <summary>
/// Populates the group roles.
/// </summary>
/// <param name="checkboxList"></param>
/// <param name="groupTypeGuid"></param>
private void PopulateRelationshipTypesSelector( RockCheckBoxList checkboxList, Guid? groupTypeGuid )
{
bool showSelector = false;
checkboxList.Items.Clear();
var groupType = GroupTypeCache.Read( groupTypeGuid.GetValueOrDefault() );
if ( groupType != null )
{
var selectableRoles = new GroupTypeRoleService( new RockContext() ).GetByGroupTypeId( groupType.Id );
// Exclude the Owner Role from the list of selectable Roles because a Person cannot be related to themselves.
var ownerGuid = GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid();
selectableRoles = selectableRoles.Where( x => x.Guid != ownerGuid );
checkboxList.Items.Clear();
foreach ( var item in selectableRoles )
{
checkboxList.Items.Add( new ListItem( item.Name, item.Guid.ToString() ) );
}
showSelector = checkboxList.Items.Count > 0;
}
checkboxList.Visible = showSelector;
}
/// <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 ( Page.IsValid )
{
var rockContext = new RockContext();
GroupMemberService groupMemberService = new GroupMemberService( rockContext );
GroupMemberRequirementService groupMemberRequirementService = new GroupMemberRequirementService( rockContext );
GroupMember groupMember;
int groupMemberId = int.Parse( hfGroupMemberId.Value );
GroupTypeRole role = new GroupTypeRoleService( rockContext ).Get( ddlGroupRole.SelectedValueAsInt() ?? 0 );
// check to see if the user selected a role
if ( role == null )
{
nbErrorMessage.Title = "Please select a Role";
return;
}
// if adding a new group member
if ( groupMemberId.Equals( 0 ) )
{
groupMember = new GroupMember { Id = 0 };
groupMember.GroupId = hfGroupId.ValueAsInt();
}
else
{
// load existing group member
groupMember = groupMemberService.Get( groupMemberId );
}
groupMember.PersonId = ppGroupMemberPerson.PersonId.Value;
groupMember.GroupRoleId = role.Id;
groupMember.Note = tbNote.Text;
groupMember.GroupMemberStatus = rblStatus.SelectedValueAsEnum<GroupMemberStatus>();
if ( cbIsNotified.Visible )
{
groupMember.IsNotified = cbIsNotified.Checked;
}
if ( pnlRequirements.Visible )
{
foreach ( var checkboxItem in cblManualRequirements.Items.OfType<ListItem>() )
{
int groupRequirementId = checkboxItem.Value.AsInteger();
var groupMemberRequirement = groupMember.GroupMemberRequirements.FirstOrDefault( a => a.GroupRequirementId == groupRequirementId );
bool metRequirement = checkboxItem.Selected;
if ( metRequirement )
{
if ( groupMemberRequirement == null )
{
groupMemberRequirement = new GroupMemberRequirement();
groupMemberRequirement.GroupRequirementId = groupRequirementId;
groupMember.GroupMemberRequirements.Add( groupMemberRequirement );
}
// set the RequirementMetDateTime if it hasn't been set already
groupMemberRequirement.RequirementMetDateTime = groupMemberRequirement.RequirementMetDateTime ?? RockDateTime.Now;
groupMemberRequirement.LastRequirementCheckDateTime = RockDateTime.Now;
}
else
{
if ( groupMemberRequirement != null )
{
// doesn't meets the requirement
groupMemberRequirement.RequirementMetDateTime = null;
groupMemberRequirement.LastRequirementCheckDateTime = RockDateTime.Now;
}
}
}
}
groupMember.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phAttributes, groupMember );
if ( !Page.IsValid )
{
return;
}
// if the groupMember IsValue 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
cvGroupMember.IsValid = groupMember.IsValid;
if ( !cvGroupMember.IsValid )
{
cvGroupMember.ErrorMessage = groupMember.ValidationResults.Select( a => a.ErrorMessage ).ToList().AsDelimited( "<br />" );
return;
}
// using WrapTransaction because there are three Saves
rockContext.WrapTransaction( () =>
{
if ( groupMember.Id.Equals( 0 ) )
{
groupMemberService.Add( groupMember );
}
rockContext.SaveChanges();
groupMember.SaveAttributeValues( rockContext );
} );
groupMember.CalculateRequirements( rockContext, true );
Group group = new GroupService( rockContext ).Get( groupMember.GroupId );
if ( group.IsSecurityRole || group.GroupType.Guid.Equals( Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid() ) )
{
Rock.Security.Role.Flush( group.Id );
Rock.Security.Authorization.Flush();
}
}
Dictionary<string, string> qryString = new Dictionary<string, string>();
qryString["GroupId"] = hfGroupId.Value;
NavigateToParentPage( qryString );
}
private string GetGroupMemberAttributeValues()
{
var groupId = ddlPlacementGroup.SelectedValueAsInt();
var groupMemberRoleId = ddlPlacementGroupRole.SelectedValueAsInt();
var groupMemberStatus = ddlPlacementGroupStatus.SelectedValueAsEnumOrNull<GroupMemberStatus>();
var values = new Dictionary<string, string>();
if ( groupId.HasValue && groupMemberRoleId.HasValue && groupMemberStatus != null )
{
using ( var rockContext = new RockContext() )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
var role = new GroupTypeRoleService( rockContext ).Get( groupMemberRoleId.Value );
if ( group != null && role != null )
{
var groupMember = new GroupMember();
groupMember.Group = group;
groupMember.GroupId = group.Id;
groupMember.GroupRole = role;
groupMember.GroupRoleId = role.Id;
groupMember.GroupMemberStatus = groupMemberStatus.Value;
groupMember.LoadAttributes();
Rock.Attribute.Helper.GetEditValues( phGroupMemberAttributes, groupMember );
foreach( var attrValue in groupMember.AttributeValues )
{
values.Add( attrValue.Key, attrValue.Value.Value );
}
return JsonConvert.SerializeObject( values, Formatting.None );
}
}
}
return string.Empty;
}
/// <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>
/// Loads the group roles.
/// </summary>
/// <param name="groupTypeId">The group type unique identifier.</param>
private void LoadGroupRoles( int? groupTypeId )
{
int? currentGroupRoleId = ddlGroupRole.SelectedValue.AsIntegerOrNull();
ddlGroupRole.SelectedValue = null;
ddlGroupRole.Items.Clear();
if ( groupTypeId.HasValue )
{
var groupRoleService = new Rock.Model.GroupTypeRoleService( new RockContext() );
var groupRoles = groupRoleService.Queryable()
.Where( r =>
r.GroupTypeId == groupTypeId.Value )
.OrderBy( a => a.Name )
.ToList();
foreach ( var r in groupRoles )
{
var roleItem = new ListItem( r.Name, r.Id.ToString().ToUpper() );
roleItem.Selected = r.Id == currentGroupRoleId;
ddlGroupRole.Items.Add( roleItem );
}
}
}
/// <summary>
/// Reads new values entered by the user for the field ( as Guid )
/// </summary>
/// <param name="control">Parent control that controls were added to in the CreateEditControl() method</param>
/// <param name="configurationValues">The configuration values.</param>
/// <returns></returns>
public override string GetEditValue( System.Web.UI.Control control, Dictionary<string, ConfigurationValue> configurationValues )
{
GroupRolePicker groupRolePicker = control as GroupRolePicker;
if ( groupRolePicker != null )
{
if ( groupRolePicker.GroupRoleId.HasValue )
{
var groupRole = new GroupTypeRoleService( new RockContext() ).Get( groupRolePicker.GroupRoleId.Value );
if ( groupRole != null )
{
return groupRole.Guid.ToString();
}
}
}
return null;
}
/// <summary>
/// Handles the Click event of the lbSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void lbSave_Click( object sender, EventArgs e )
{
var rockContext = new RockContext();
Rock.Data.RockTransactionScope.WrapTransaction( () =>
{
var personService = new PersonService( rockContext );
var changes = new List<string>();
var business = new Person();
if ( int.Parse( hfBusinessId.Value ) != 0 )
{
business = personService.Get( int.Parse( hfBusinessId.Value ) );
}
// int? orphanedPhotoId = null;
// if ( business.PhotoId != imgPhoto.BinaryFileId )
// {
// orphanedPhotoId = business.PhotoId;
// business.PhotoId = imgPhoto.BinaryFileId;
// if ( orphanedPhotoId.HasValue )
// {
// if ( business.PhotoId.HasValue )
// {
// changes.Add( "Modified the photo." );
// }
// else
// {
// changes.Add( "Deleted the photo." );
// }
// }
// else if ( business.PhotoId.HasValue )
// {
// changes.Add( "Added a photo." );
// }
// }
// Business Name
History.EvaluateChange( changes, "First Name", business.FirstName, tbBusinessName.Text );
business.FirstName = tbBusinessName.Text;
// Phone Number
var phoneNumberTypeIds = new List<int>();
var homePhoneTypeId = new DefinedValueService( rockContext ).GetByGuid( new Guid( Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME ) ).Id;
if ( !string.IsNullOrWhiteSpace( PhoneNumber.CleanNumber( pnbPhone.Number ) ) )
{
var phoneNumber = business.PhoneNumbers.FirstOrDefault( n => n.NumberTypeValueId == homePhoneTypeId );
string oldPhoneNumber = string.Empty;
if ( phoneNumber == null )
{
phoneNumber = new PhoneNumber { NumberTypeValueId = homePhoneTypeId };
business.PhoneNumbers.Add( phoneNumber );
}
else
{
oldPhoneNumber = phoneNumber.NumberFormattedWithCountryCode;
}
phoneNumber.CountryCode = PhoneNumber.CleanNumber( pnbPhone.CountryCode );
phoneNumber.Number = PhoneNumber.CleanNumber( pnbPhone.Number );
phoneNumber.IsMessagingEnabled = cbSms.Checked;
phoneNumber.IsUnlisted = cbUnlisted.Checked;
phoneNumberTypeIds.Add( homePhoneTypeId );
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( homePhoneTypeId ) ),
oldPhoneNumber,
phoneNumber.NumberFormattedWithCountryCode );
}
// Remove any blank numbers
var phoneNumberService = new PhoneNumberService( rockContext );
foreach ( var phoneNumber in business.PhoneNumbers
.Where( n => n.NumberTypeValueId.HasValue && !phoneNumberTypeIds.Contains( n.NumberTypeValueId.Value ) )
.ToList() )
{
History.EvaluateChange(
changes,
string.Format( "{0} Phone", DefinedValueCache.GetName( phoneNumber.NumberTypeValueId ) ),
phoneNumber.NumberFormatted,
string.Empty );
business.PhoneNumbers.Remove( phoneNumber );
phoneNumberService.Delete( phoneNumber );
}
// Record Type - this is always "business". it will never change.
business.RecordTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid() ).Id;
// Record Status
int? newRecordStatusId = ddlRecordStatus.SelectedValueAsInt();
History.EvaluateChange( changes, "Record Status", DefinedValueCache.GetName( business.RecordStatusValueId ), DefinedValueCache.GetName( newRecordStatusId ) );
business.RecordStatusValueId = newRecordStatusId;
// Record Status Reason
int? newRecordStatusReasonId = null;
if ( business.RecordStatusValueId.HasValue && business.RecordStatusValueId.Value == DefinedValueCache.Read( new Guid( Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE ) ).Id )
{
newRecordStatusReasonId = ddlReason.SelectedValueAsInt();
}
History.EvaluateChange( changes, "Record Status Reason", DefinedValueCache.GetName( business.RecordStatusReasonValueId ), DefinedValueCache.GetName( newRecordStatusReasonId ) );
business.RecordStatusReasonValueId = newRecordStatusReasonId;
// Email
business.IsEmailActive = true;
History.EvaluateChange( changes, "Email", business.Email, tbEmail.Text );
business.Email = tbEmail.Text.Trim();
var newEmailPreference = rblEmailPreference.SelectedValue.ConvertToEnum<EmailPreference>();
History.EvaluateChange( changes, "EmailPreference", business.EmailPreference, newEmailPreference );
business.EmailPreference = newEmailPreference;
if ( business.IsValid )
{
if ( rockContext.SaveChanges() > 0 )
{
if ( changes.Any() )
{
HistoryService.SaveChanges(
rockContext,
typeof( Person ),
Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(),
business.Id,
changes );
}
// if ( orphanedPhotoId.HasValue )
// {
// BinaryFileService binaryFileService = new BinaryFileService( personService.RockContext );
// var binaryFile = binaryFileService.Get( orphanedPhotoId.Value );
// if ( binaryFile != null )
// {
// // marked the old images as IsTemporary so they will get cleaned up later
// binaryFile.IsTemporary = true;
// binaryFileService.Save( binaryFile, CurrentPersonAlias );
// }
// }
// Response.Redirect( string.Format( "~/Person/{0}", Person.Id ), false );
}
}
// Group
var familyGroupType = GroupTypeCache.GetFamilyGroupType();
var groupService = new GroupService( rockContext );
var businessGroup = new Group();
if ( business.GivingGroupId != null )
{
businessGroup = groupService.Get( (int)business.GivingGroupId );
}
businessGroup.GroupTypeId = familyGroupType.Id;
businessGroup.Name = tbBusinessName.Text + " Business";
businessGroup.CampusId = ddlCampus.SelectedValueAsInt();
var knownRelationshipGroup = new Group();
var impliedRelationshipGroup = new Group();
if ( business.GivingGroupId == null )
{
groupService.Add( businessGroup );
// If there isn't a Giving Group then there aren't any other groups.
// We also need to add the Known Relationship and Implied Relationship groups for this business.
var knownRelationshipGroupTypeId = new GroupTypeService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS ) ).Id;
knownRelationshipGroup.GroupTypeId = knownRelationshipGroupTypeId;
knownRelationshipGroup.Name = "Known Relationship";
groupService.Add( knownRelationshipGroup );
var impliedRelationshipGroupTypeId = new GroupTypeService( rockContext ).Get( new Guid( Rock.SystemGuid.GroupType.GROUPTYPE_IMPLIED_RELATIONSHIPS ) ).Id;
impliedRelationshipGroup.GroupTypeId = impliedRelationshipGroupTypeId;
impliedRelationshipGroup.Name = "Implied Relationship";
groupService.Add( impliedRelationshipGroup );
}
rockContext.SaveChanges();
// Giving Group
int? newGivingGroupId = ddlGivingGroup.SelectedValueAsId();
if ( business.GivingGroupId != newGivingGroupId )
{
string oldGivingGroupName = business.GivingGroup != null ? business.GivingGroup.Name : string.Empty;
string newGivingGroupName = newGivingGroupId.HasValue ? ddlGivingGroup.Items.FindByValue( newGivingGroupId.Value.ToString() ).Text : string.Empty;
History.EvaluateChange( changes, "Giving Group", oldGivingGroupName, newGivingGroupName );
}
business.GivingGroup = businessGroup;
// GroupMember
var groupMemberService = new GroupMemberService( rockContext );
int? adultRoleId = new GroupTypeRoleService( rockContext ).Queryable()
.Where( r =>
r.Guid.Equals( new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT ) ) )
.Select( r => r.Id )
.FirstOrDefault();
var groupMember = businessGroup.Members.Where( role => role.GroupRoleId == adultRoleId ).FirstOrDefault();
if ( groupMember == null )
{
groupMember = new GroupMember();
businessGroup.Members.Add( groupMember );
// If we're in here, then this is a new business.
// Add the known relationship and implied relationship GroupMember entries.
var knownRelationshipGroupMember = new GroupMember();
knownRelationshipGroupMember.Person = business;
knownRelationshipGroupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid() ).Id;
knownRelationshipGroupMember.GroupId = knownRelationshipGroup.Id;
knownRelationshipGroup.Members.Add( knownRelationshipGroupMember );
var impliedRelationshipGroupMember = new GroupMember();
impliedRelationshipGroupMember.Person = business;
impliedRelationshipGroupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_IMPLIED_RELATIONSHIPS_OWNER.AsGuid() ).Id;
impliedRelationshipGroupMember.GroupId = impliedRelationshipGroup.Id;
impliedRelationshipGroup.Members.Add( impliedRelationshipGroupMember );
}
groupMember.Person = business;
groupMember.GroupRoleId = new GroupTypeRoleService( rockContext ).Get( Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid() ).Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
// GroupLocation & Location
var groupLocationService = new GroupLocationService( rockContext );
var groupLocation = businessGroup.GroupLocations.FirstOrDefault();
if ( groupLocation == null )
{
groupLocation = new GroupLocation();
businessGroup.GroupLocations.Add( groupLocation );
}
groupLocation.GroupLocationTypeValueId = DefinedValueCache.Read( Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME ).Id;
var locationService = new LocationService( rockContext );
var location = groupLocation.Location;
if ( location == null )
{
location = new Location();
groupLocation.Location = location;
}
location.Street1 = tbStreet1.Text.Trim();
location.Street2 = tbStreet2.Text.Trim();
location.City = tbCity.Text.Trim();
location.State = ddlState.SelectedValue;
location.Zip = tbZipCode.Text.Trim();
rockContext.SaveChanges();
hfBusinessId.Value = business.Id.ToString();
// Set the Known Relationships between the Owner and the Business.
if ( ppOwner.PersonId != null )
{
SetOwner( business );
}
} );
NavigateToParentPage();
}
private void BuildGroupMemberAttributes( int? groupId, int? groupMemberRoleId, GroupMemberStatus? groupMemberStatus, bool setValues )
{
phGroupMemberAttributes.Controls.Clear();
phGroupMemberAttributesView.Controls.Clear();
if ( groupId.HasValue && groupMemberRoleId.HasValue && groupMemberStatus != null )
{
using ( var rockContext = new RockContext() )
{
var group = new GroupService( rockContext ).Get( groupId.Value );
var role = new GroupTypeRoleService( rockContext ).Get( groupMemberRoleId.Value );
if ( group != null && role != null )
{
var groupMember = new GroupMember();
groupMember.Group = group;
groupMember.GroupId = group.Id;
groupMember.GroupRole = role;
groupMember.GroupRoleId = role.Id;
groupMember.GroupMemberStatus = groupMemberStatus.Value;
groupMember.LoadAttributes();
if ( setValues && !string.IsNullOrWhiteSpace( hfGroupMemberAttributeValues.Value ) )
{
var savedValues = JsonConvert.DeserializeObject<Dictionary<string, string>>( hfGroupMemberAttributeValues.Value );
if ( savedValues != null )
{
foreach( var item in savedValues )
{
groupMember.SetAttributeValue( item.Key, item.Value );
}
}
}
Rock.Attribute.Helper.AddEditControls( groupMember, phGroupMemberAttributes, setValues, BlockValidationGroup, 2 );
Rock.Attribute.Helper.AddDisplayControls( groupMember, phGroupMemberAttributesView, null, false, false );
}
}
}
}
/// <summary>
/// Sets the value. ( as Guid )
/// </summary>
/// <param name="control">The control.</param>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="value">The value.</param>
public override void SetEditValue( System.Web.UI.Control control, Dictionary<string, ConfigurationValue> configurationValues, string value )
{
GroupRolePicker groupRolePicker = control as GroupRolePicker;
if ( groupRolePicker != null )
{
Guid guid = Guid.Empty;
if ( Guid.TryParse( value, out guid ) )
{
var groupRole = new GroupTypeRoleService( new RockContext() ).Get( guid );
if ( groupRole != null )
{
groupRolePicker.GroupRoleId = groupRole.Id;
return;
}
}
groupRolePicker.GroupRoleId = null;
}
}
/// <summary>
/// Shows the readonly details.
/// </summary>
/// <param name="connectionRequest">The connection request.</param>
private void ShowReadonlyDetails( ConnectionRequest connectionRequest )
{
pdAuditDetails.SetEntity( connectionRequest, ResolveRockUrl( "~" ) );
if ( connectionRequest.AssignedGroupId != null )
{
pnlRequirements.Visible = true;
ShowConnectionOpportunityRequirementsStatuses();
}
else
{
pnlRequirements.Visible = false;
lbConnect.Enabled = !connectionRequest.ConnectionOpportunity.ConnectionType.RequiresPlacementGroupToConnect;
}
if ( connectionRequest.ConnectionState == ConnectionState.Inactive || connectionRequest.ConnectionState == ConnectionState.Connected )
{
lbConnect.Visible = false;
lbTransfer.Visible = false;
}
lContactInfo.Text = string.Empty;
Person person = null;
if ( connectionRequest != null && connectionRequest.PersonAlias != null )
{
person = connectionRequest.PersonAlias.Person;
}
if ( person != null && ( person.PhoneNumbers.Any() || !String.IsNullOrWhiteSpace( person.Email ) ) )
{
List<String> contactList = new List<string>();
foreach ( PhoneNumber phoneNumber in person.PhoneNumbers )
{
contactList.Add( String.Format( "{0} <font color='#808080'>{1}</font>", phoneNumber.NumberFormatted, phoneNumber.NumberTypeValue ) );
}
string emailTag = person.GetEmailTag( ResolveRockUrl( "/" ) );
if ( !string.IsNullOrWhiteSpace( emailTag ) )
{
contactList.Add( emailTag );
}
lContactInfo.Text = contactList.AsDelimited( "</br>" );
}
else
{
lContactInfo.Text = "No contact Info";
}
if ( person != null && !string.IsNullOrWhiteSpace( GetAttributeValue( "PersonProfilePage" ) ) )
{
lbProfilePage.Visible = true;
Dictionary<string, string> queryParms = new Dictionary<string, string>();
queryParms.Add( "PersonId", person.Id.ToString() );
lbProfilePage.PostBackUrl = LinkedPageUrl( "PersonProfilePage", queryParms );
}
else
{
lbProfilePage.Visible = false;
}
if ( person != null )
{
string imgTag = Rock.Model.Person.GetPersonPhotoImageTag( person, 200, 200, className: "img-thumbnail" );
if ( person.PhotoId.HasValue )
{
lPortrait.Text = string.Format( "<a href='{0}'>{1}</a>", person.PhotoUrl, imgTag );
}
else
{
lPortrait.Text = imgTag;
}
}
else
{
lPortrait.Text = string.Empty; ;
}
lComments.Text = connectionRequest != null && connectionRequest.Comments != null ? connectionRequest.Comments.ScrubHtmlAndConvertCrLfToBr() : string.Empty;
lRequestDate.Text = connectionRequest != null && connectionRequest.CreatedDateTime.HasValue ? connectionRequest.CreatedDateTime.Value.ToShortDateString() : string.Empty;
if ( connectionRequest != null && connectionRequest.AssignedGroup != null )
{
var qryParams = new Dictionary<string, string>();
qryParams.Add( "GroupId", connectionRequest.AssignedGroup.Id.ToString() );
string url = LinkedPageUrl( "GroupDetailPage", qryParams );
string roleStatus = string.Empty;
string roleName = string.Empty;
if ( connectionRequest.AssignedGroupMemberRoleId.HasValue )
{
var role = new GroupTypeRoleService( new RockContext() ).Get( connectionRequest.AssignedGroupMemberRoleId.Value );
roleName = role != null ? role.Name : string.Empty;
}
string statusName = connectionRequest.AssignedGroupMemberStatus != null ? connectionRequest.AssignedGroupMemberStatus.ConvertToString() : string.Empty;
if ( !string.IsNullOrWhiteSpace( roleName ) || !string.IsNullOrWhiteSpace( statusName ) )
{
roleStatus = string.Format( " ({0}{1}{2})",
statusName,
!string.IsNullOrWhiteSpace( roleName ) && !string.IsNullOrWhiteSpace( statusName ) ? " " : "",
roleName );
}
lPlacementGroup.Text = !string.IsNullOrWhiteSpace( url ) ?
string.Format( "<a href='{0}'>{1}</a>{2}", url, connectionRequest.AssignedGroup.Name, roleStatus ) :
connectionRequest.AssignedGroup.Name;
hfGroupMemberAttributeValues.Value = connectionRequest.AssignedGroupMemberAttributeValues;
BuildGroupMemberAttributes( connectionRequest.AssignedGroupId, connectionRequest.AssignedGroupMemberRoleId, connectionRequest.AssignedGroupMemberStatus, true );
}
else
{
lPlacementGroup.Text = "No group assigned";
}
if ( connectionRequest != null &&
connectionRequest.ConnectorPersonAlias != null &&
connectionRequest.ConnectorPersonAlias.Person != null )
{
lConnector.Text = connectionRequest.ConnectorPersonAlias.Person.FullName;
}
else
{
lConnector.Text = "No connector assigned";
}
if ( connectionRequest != null )
{
hlState.Visible = true;
hlState.Text = connectionRequest.ConnectionState.ConvertToString();
hlState.LabelType = connectionRequest.ConnectionState == ConnectionState.Inactive ? LabelType.Danger :
( connectionRequest.ConnectionState == ConnectionState.FutureFollowUp ? LabelType.Info : LabelType.Success );
hlStatus.Visible = true;
hlStatus.Text = connectionRequest.ConnectionStatus.Name;
hlStatus.LabelType = connectionRequest.ConnectionStatus.IsCritical ? LabelType.Warning : LabelType.Type;
hlOpportunity.Text = connectionRequest.ConnectionOpportunity != null ? connectionRequest.ConnectionOpportunity.Name : string.Empty;
hlCampus.Text = connectionRequest.Campus != null ? connectionRequest.Campus.Name : string.Empty;
if ( connectionRequest.ConnectionOpportunity != null )
{
var connectionWorkflows = connectionRequest.ConnectionOpportunity.ConnectionWorkflows.Union( connectionRequest.ConnectionOpportunity.ConnectionType.ConnectionWorkflows );
var manualWorkflows = connectionWorkflows
.Where( w =>
w.TriggerType == ConnectionWorkflowTriggerType.Manual &&
w.WorkflowType != null )
.OrderBy( w => w.WorkflowType.Name )
.Distinct();
if ( manualWorkflows.Any() )
{
lblWorkflows.Visible = true;
rptRequestWorkflows.DataSource = manualWorkflows.ToList();
rptRequestWorkflows.DataBind();
}
else
{
lblWorkflows.Visible = false;
}
}
BindConnectionRequestActivitiesGrid( connectionRequest, new RockContext() );
BindConnectionRequestWorkflowsGrid();
}
else
{
hlState.Visible = false;
hlStatus.Visible = false;
hlOpportunity.Visible = false;
hlCampus.Visible = false;
lblWorkflows.Visible = false;
lbConnect.Enabled = false;
}
}
/// <summary>
/// Gets the edit value as the IEntity.Id
/// </summary>
/// <param name="control">The control.</param>
/// <param name="configurationValues">The configuration values.</param>
/// <returns></returns>
public int? GetEditValueAsEntityId( Control control, Dictionary<string, ConfigurationValue> configurationValues )
{
Guid guid = GetEditValue( control, configurationValues ).AsGuid();
var item = new GroupTypeRoleService( new RockContext() ).Get( guid );
return item != null ? item.Id : (int?)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 )
{
GroupType groupType;
var rockContext = new RockContext();
GroupTypeService groupTypeService = new GroupTypeService( rockContext );
GroupTypeRoleService groupTypeRoleService = new GroupTypeRoleService( rockContext );
AttributeService attributeService = new AttributeService( rockContext );
AttributeQualifierService qualifierService = new AttributeQualifierService( rockContext );
CategoryService categoryService = new CategoryService( rockContext );
GroupScheduleExclusionService scheduleExclusionService = new GroupScheduleExclusionService( rockContext );
int groupTypeId = int.Parse( hfGroupTypeId.Value );
if ( groupTypeId == 0 )
{
groupType = new GroupType();
groupTypeService.Add( groupType );
}
else
{
groupType = groupTypeService.Get( groupTypeId );
// selected roles
var selectedRoleGuids = GroupTypeRolesState.Select( r => r.Guid );
foreach ( var role in groupType.Roles.Where( r => !selectedRoleGuids.Contains( r.Guid ) ).ToList() )
{
groupType.Roles.Remove( role );
groupTypeRoleService.Delete( role );
}
}
foreach ( var roleState in GroupTypeRolesState )
{
GroupTypeRole role = groupType.Roles.Where( r => r.Guid == roleState.Guid ).FirstOrDefault();
if ( role == null )
{
role = new GroupTypeRole();
groupType.Roles.Add( role );
}
else
{
roleState.Id = role.Id;
roleState.Guid = role.Guid;
}
role.CopyPropertiesFrom( roleState );
}
ScheduleType allowedScheduleTypes = ScheduleType.None;
foreach( ListItem li in cblScheduleTypes.Items )
{
if ( li.Selected )
{
allowedScheduleTypes = allowedScheduleTypes | (ScheduleType)li.Value.AsInteger();
}
}
GroupLocationPickerMode locationSelectionMode = GroupLocationPickerMode.None;
foreach ( ListItem li in cblLocationSelectionModes.Items )
{
if ( li.Selected )
{
locationSelectionMode = locationSelectionMode | (GroupLocationPickerMode)li.Value.AsInteger();
}
}
groupType.Name = tbName.Text;
groupType.Description = tbDescription.Text;
groupType.GroupTerm = tbGroupTerm.Text;
groupType.GroupMemberTerm = tbGroupMemberTerm.Text;
groupType.ShowInGroupList = cbShowInGroupList.Checked;
groupType.ShowInNavigation = cbShowInNavigation.Checked;
groupType.IconCssClass = tbIconCssClass.Text;
groupType.TakesAttendance = cbTakesAttendance.Checked;
groupType.SendAttendanceReminder = cbSendAttendanceReminder.Checked;
groupType.AttendanceRule = ddlAttendanceRule.SelectedValueAsEnum<AttendanceRule>();
groupType.AttendancePrintTo = ddlPrintTo.SelectedValueAsEnum<PrintTo>();
groupType.AllowedScheduleTypes = allowedScheduleTypes;
groupType.LocationSelectionMode = locationSelectionMode;
groupType.GroupTypePurposeValueId = ddlGroupTypePurpose.SelectedValueAsInt();
groupType.AllowMultipleLocations = cbAllowMultipleLocations.Checked;
groupType.InheritedGroupTypeId = gtpInheritedGroupType.SelectedGroupTypeId;
groupType.EnableLocationSchedules = cbEnableLocationSchedules.Checked;
groupType.ChildGroupTypes = new List<GroupType>();
groupType.ChildGroupTypes.Clear();
foreach ( var item in ChildGroupTypesDictionary )
{
var childGroupType = groupTypeService.Get( item.Key );
if ( childGroupType != null )
{
groupType.ChildGroupTypes.Add( childGroupType );
}
}
// Delete any removed exclusions
foreach ( var exclusion in groupType.GroupScheduleExclusions.Where( s => !ScheduleExclusionDictionary.Keys.Contains( s.Guid ) ).ToList() )
{
groupType.GroupScheduleExclusions.Remove( exclusion );
scheduleExclusionService.Delete( exclusion );
}
// Update exclusions
foreach( var keyVal in ScheduleExclusionDictionary )
{
var scheduleExclusion = groupType.GroupScheduleExclusions
.FirstOrDefault( s => s.Guid.Equals( keyVal.Key));
if ( scheduleExclusion == null )
{
scheduleExclusion = new GroupScheduleExclusion();
groupType.GroupScheduleExclusions.Add( scheduleExclusion);
}
scheduleExclusion.StartDate = keyVal.Value.Start;
scheduleExclusion.EndDate = keyVal.Value.End;
}
DefinedValueService definedValueService = new DefinedValueService( rockContext );
groupType.LocationTypes = new List<GroupTypeLocationType>();
groupType.LocationTypes.Clear();
foreach ( var item in LocationTypesDictionary )
{
var locationType = definedValueService.Get( item.Key );
if ( locationType != null )
{
groupType.LocationTypes.Add( new GroupTypeLocationType { LocationTypeValueId = locationType.Id } );
}
}
if ( !groupType.IsValid )
{
// Controls will render the error messages
return;
}
// need WrapTransaction due to Attribute saves
rockContext.WrapTransaction( () =>
{
rockContext.SaveChanges();
/* Save Attributes */
string qualifierValue = groupType.Id.ToString();
SaveAttributes( new GroupType().TypeId, "Id", qualifierValue, GroupTypeAttributesState, rockContext );
SaveAttributes( new Group().TypeId, "GroupTypeId", qualifierValue, GroupAttributesState, rockContext );
SaveAttributes( new GroupMember().TypeId, "GroupTypeId", qualifierValue, GroupMemberAttributesState, rockContext );
// Reload to save default role
groupType = groupTypeService.Get( groupType.Id );
groupType.DefaultGroupRole = groupType.Roles.FirstOrDefault( r => r.Guid.Equals( DefaultRoleGuid ) );
if ( groupType.DefaultGroupRole == null )
{
groupType.DefaultGroupRole = groupType.Roles.FirstOrDefault();
}
rockContext.SaveChanges();
// Reload the roles and apply their attribute values
foreach ( var role in groupTypeRoleService.GetByGroupTypeId( groupType.Id ).ToList() )
{
role.LoadAttributes( rockContext );
var roleState = GroupTypeRolesState.Where( r => r.Guid.Equals( role.Guid ) ).FirstOrDefault();
if ( roleState != null && roleState.AttributeValues != null )
{
foreach ( var attributeValue in roleState.AttributeValues )
{
role.SetAttributeValue( attributeValue.Key, roleState.GetAttributeValue( attributeValue.Key ) );
}
role.SaveAttributeValues( rockContext );
}
}
} );
GroupTypeCache.Flush( groupType.Id );
NavigateToParentPage();
}
/// <summary>
/// Sets the edit value from IEntity.Id value
/// </summary>
/// <param name="control">The control.</param>
/// <param name="configurationValues">The configuration values.</param>
/// <param name="id">The identifier.</param>
public void SetEditValueFromEntityId( Control control, Dictionary<string, ConfigurationValue> configurationValues, int? id )
{
var item = new GroupTypeRoleService( new RockContext() ).Get( id ?? 0 );
string guidValue = item != null ? item.Guid.ToString() : string.Empty;
SetEditValue( control, configurationValues, guidValue );
}
/// <summary>
/// Gets the inverse relationship.
/// Returns the <see cref="Rock.Model.GroupMember" /> who has an inverse relationship to the provided <see cref="Rock.Model.GroupMember" />.
/// </summary>
/// <param name="groupMember">A <see cref="Rock.Model.GroupMember" /> representing the person to find the inverse relationship for.</param>
/// <param name="createGroup">A <see cref="System.Boolean" /> flag indicating if a new <see cref="Rock.Model.Group" /> can be created
/// for the person with the inverse relationship.</param>
/// <returns>
/// A <see cref="Rock.Model.GroupMember" /> representing the <see cref="Rock.Model.Person" /> with the inverse relationship.
/// </returns>
/// <remarks>
/// In Rock, examples of inverse relationships include: Parent/Child, Can Check In/Check in By, Sibling/Sibling, Grandparent/Grandchild, etc.
/// </remarks>
public GroupMember GetInverseRelationship(GroupMember groupMember, bool createGroup)
{
var groupRole = groupMember.GroupRole;
if (groupRole == null)
{
groupRole = Queryable(true)
.Where(m => m.Id == groupMember.Id)
.Select(m => m.GroupRole)
.FirstOrDefault();
}
if (groupRole != null)
{
if (groupRole.Attributes == null)
{
groupRole.LoadAttributes();
}
if (groupRole.Attributes.ContainsKey("InverseRelationship"))
{
Guid knownRelationShipOwnerRoleGuid = new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER);
// The 'owner' of the group is determined by built-in KnownRelationshipsOwner role or the role that is marked as IsLeader for the group
var ownerInfo = Queryable(true)
.Where(m =>
m.GroupId == groupMember.GroupId &&
(m.GroupRole.Guid.Equals(knownRelationShipOwnerRoleGuid) || m.GroupRole.IsLeader))
.Select(m => new
{
PersonId = m.PersonId,
RoleId = m.GroupRoleId
})
.FirstOrDefault();
int?ownerPersonId = null;
int?ownerRoleId = null;
if (ownerInfo != null)
{
ownerPersonId = ownerInfo.PersonId;
ownerRoleId = ownerInfo.RoleId;
}
if (ownerPersonId.HasValue && ownerRoleId.HasValue)
{
// Find related person's group where the person is the Owner
// NOTE: The 'owner' of the group is determined by built-in KnownRelationshipsOwner role or the role that is marked as IsLeader for the group
var inverseGroup = Queryable(true)
.Where(m =>
m.PersonId == groupMember.PersonId &&
m.Group.GroupTypeId == groupRole.GroupTypeId &&
(m.GroupRole.Guid.Equals(knownRelationShipOwnerRoleGuid) || m.GroupRole.IsLeader))
.Select(m => m.Group)
.FirstOrDefault();
if (inverseGroup == null && createGroup)
{
var ownerGroupMember = new GroupMember();
ownerGroupMember.PersonId = groupMember.PersonId;
ownerGroupMember.GroupRoleId = ownerRoleId.Value;
inverseGroup = new Group();
inverseGroup.Name = groupRole.GroupType.Name;
inverseGroup.GroupTypeId = groupRole.GroupTypeId.Value;
inverseGroup.Members.Add(ownerGroupMember);
}
if (inverseGroup != null)
{
Guid inverseRoleGuid = Guid.Empty;
if (Guid.TryParse(groupRole.GetAttributeValue("InverseRelationship"), out inverseRoleGuid))
{
var inverseGroupMember = Queryable(true)
.Where(m =>
m.PersonId == ownerPersonId &&
m.GroupId == inverseGroup.Id &&
m.GroupRole.Guid.Equals(inverseRoleGuid))
.FirstOrDefault();
if (inverseGroupMember == null)
{
var inverseRole = new GroupTypeRoleService((RockContext)Context).Get(inverseRoleGuid);
if (inverseRole != null)
{
inverseGroupMember = new GroupMember();
inverseGroupMember.PersonId = ownerPersonId.Value;
inverseGroupMember.Group = inverseGroup;
inverseGroupMember.GroupRoleId = inverseRole.Id;
Add(inverseGroupMember);
}
}
return(inverseGroupMember);
}
}
}
}
}
return(null);
}
/// <summary>
/// Gets the inverse relationship.
/// Returns the <see cref="Rock.Model.GroupMember" /> who has an inverse relationship to the provided <see cref="Rock.Model.GroupMember" />.
/// </summary>
/// <param name="groupMember">A <see cref="Rock.Model.GroupMember" /> representing the person to find the inverse relationship for.</param>
/// <param name="createGroup">A <see cref="System.Boolean" /> flag indicating if a new <see cref="Rock.Model.Group" /> can be created
/// for the person with the inverse relationship.</param>
/// <returns>
/// A <see cref="Rock.Model.GroupMember" /> representing the <see cref="Rock.Model.Person" /> with the inverse relationship.
/// </returns>
/// <remarks>
/// In Rock, examples of inverse relationships include: Parent/Child, Can Check In/Check in By, Sibling/Sibling, Grandparent/Grandchild, etc.
/// </remarks>
public GroupMember GetInverseRelationship( GroupMember groupMember, bool createGroup )
{
var groupRole = groupMember.GroupRole;
if ( groupRole == null )
{
groupRole = Queryable( true )
.Where( m => m.Id == groupMember.Id )
.Select( m => m.GroupRole )
.FirstOrDefault();
}
if ( groupRole != null )
{
if ( groupRole.Attributes == null )
{
groupRole.LoadAttributes();
}
if ( groupRole.Attributes.ContainsKey( "InverseRelationship" ) )
{
Guid ownerRoleGuid = new Guid( Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER );
var memberInfo = Queryable( true )
.Where( m =>
m.GroupId == groupMember.GroupId &&
m.GroupRole.Guid.Equals( ownerRoleGuid ) )
.Select( m => new
{
PersonId = m.PersonId,
RoleId = m.GroupRoleId
} )
.FirstOrDefault();
int? ownerPersonId = null;
int? ownerRoleId = null;
if ( memberInfo != null )
{
ownerPersonId = memberInfo.PersonId;
ownerRoleId = memberInfo.RoleId;
}
if ( ownerPersonId.HasValue && ownerRoleId.HasValue )
{
// Find related person's group
var inverseGroup = Queryable( true )
.Where( m =>
m.PersonId == groupMember.PersonId &&
m.Group.GroupTypeId == groupRole.GroupTypeId &&
m.GroupRole.Guid.Equals( ownerRoleGuid ) )
.Select( m => m.Group )
.FirstOrDefault();
if ( inverseGroup == null && createGroup )
{
var ownerGroupMember = new GroupMember();
ownerGroupMember.PersonId = groupMember.PersonId;
ownerGroupMember.GroupRoleId = ownerRoleId.Value;
inverseGroup = new Group();
inverseGroup.Name = groupRole.GroupType.Name;
inverseGroup.GroupTypeId = groupRole.GroupTypeId.Value;
inverseGroup.Members.Add( ownerGroupMember );
}
if ( inverseGroup != null )
{
Guid inverseRoleGuid = Guid.Empty;
if ( Guid.TryParse( groupRole.GetAttributeValue( "InverseRelationship" ), out inverseRoleGuid ) )
{
var inverseGroupMember = Queryable( true )
.Where( m =>
m.PersonId == ownerPersonId &&
m.GroupId == inverseGroup.Id &&
m.GroupRole.Guid.Equals( inverseRoleGuid ) )
.FirstOrDefault();
if ( inverseGroupMember == null )
{
var inverseRole = new GroupTypeRoleService( (RockContext)Context ).Get( inverseRoleGuid );
if ( inverseRole != null )
{
inverseGroupMember = new GroupMember();
inverseGroupMember.PersonId = ownerPersonId.Value;
inverseGroupMember.Group = inverseGroup;
inverseGroupMember.GroupRoleId = inverseRole.Id;
Add( inverseGroupMember );
}
}
return inverseGroupMember;
}
}
}
}
}
return null;
}
