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