/// <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>
/// Display Person Attribute on the Basis of Role
/// </summary>
/// <param name="selectedId">The id of the selected group identifier.</param>
private void DisplayPersonAttributeOnRoleType(int?selectedId)
{
GroupTypeRoleService groupTypeRoleService = new GroupTypeRoleService(new RockContext());
List <Guid> attributeGuidList = new List <Guid>();
var adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
var groupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
if (selectedId.HasValue)
{
if (groupTypeRoleService.Queryable().Where(gr =>
gr.GroupType.Guid == groupTypeGuid &&
gr.Guid == adultGuid &&
gr.Id == selectedId).Any())
{
attributeGuidList = GetAttributeValue("PersonAttributes(adults)").SplitDelimitedValues().AsGuidList();
ddlGradePicker.Visible = false;
tbEmail.Required = GetAttributeValue("RequireAdultEmailAddress").AsBoolean();
_IsEditRecordAdult = true;
BindPhoneNumbers();
}
else
{
attributeGuidList = GetAttributeValue("PersonAttributes(children)").SplitDelimitedValues().AsGuidList();
ddlGradePicker.Visible = true;
tbEmail.Required = false;
_IsEditRecordAdult = false;
BindPhoneNumbers();
}
}
}
/// <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>
/// 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;
}
}
private List <Group> LoadGroups(Guid?groupGuid)
{
var groupRole = new GroupTypeRoleService(_rockContext).Get(GetAttributeValue("GroupRole").AsGuid());
if (groupRole == null)
{
return(new List <Group>());
}
var groupService = new GroupService(_rockContext);
IQueryable <Group> groupQry = groupService.Queryable("GroupLocations.Location");
//Sort by group parent if option set
if (groupGuid != null)
{
var availableGroupIds = (List <int>)GetCacheItem(groupGuid.ToString());
if (availableGroupIds == null || !availableGroupIds.Any())
{
availableGroupIds = GetChildGroups(groupGuid ?? new Guid(), groupService).Select(g => g.Id).ToList();
AddCacheItem(groupGuid.ToString(), availableGroupIds);
}
groupQry = groupQry.Where(g => g.GroupTypeId == _groupType.Id && availableGroupIds.Contains(g.Id));
}
else
{
//else just get the available groups of type
groupQry = groupQry.Where(g => g.IsActive && g.GroupTypeId == _groupType.Id);
}
return(groupQry.Where(g => g.Members.Where(gm => gm.GroupRoleId == groupRole.Id && gm.PersonId == _person.Id).Any()).ToList());
}
protected void rblRole_SelectedIndexChanged(object sender, EventArgs e)
{
GroupTypeRoleService groupTypeRoleService = new GroupTypeRoleService(new RockContext());
List <Guid> attributeGuidList = new List <Guid>();
var adultGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT.AsGuid();
var groupTypeGuid = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var selectedId = rblRole.SelectedValueAsId();
if (selectedId.HasValue)
{
if (groupTypeRoleService.Queryable().Where(gr =>
gr.GroupType.Guid == groupTypeGuid &&
gr.Guid == adultGuid &&
gr.Id == selectedId).Any())
{
ddlGradePicker.Visible = false;
tbEmail.Required = true;
}
else
{
ddlGradePicker.Visible = true;
tbEmail.Required = false;
}
}
}
/// <summary>
/// Adds the person as group member.
/// </summary>
/// <param name="person">The person.</param>
/// <param name="rockContext">The rock context.</param>
private void AddPersonAsGroupMember(Person person, RockContext rockContext)
{
GroupMemberService groupMemberService = new GroupMemberService(rockContext);
GroupTypeRole role = new GroupTypeRoleService(rockContext).Get(_group.GroupType.DefaultGroupRoleId ?? 0);
var groupMember = new GroupMember {
Id = 0
};
groupMember.GroupId = _group.Id;
// check to see if the person is already a member of the group/role
var existingGroupMember = groupMemberService.GetByGroupIdAndPersonIdAndGroupRoleId(_group.Id, person.Id, _group.GroupType.DefaultGroupRoleId ?? 0);
if (existingGroupMember != null)
{
return;
}
groupMember.PersonId = person.Id;
groupMember.GroupRoleId = role.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
if (groupMember.Id.Equals(0))
{
groupMemberService.Add(groupMember);
}
rockContext.SaveChanges();
}
/// <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);
}
private Group CreateTestGroup(RockContext rockContext, ElevatedSecurityLevel elevatedSecurityLevel)
{
var groupGuid = Guid.NewGuid();
var groupTypeGuid = Guid.NewGuid();
var group = new Group
{
Name = $"Test Group {groupGuid}",
IsSecurityRole = true,
Guid = groupGuid,
ElevatedSecurityLevel = elevatedSecurityLevel,
GroupType = new GroupType
{
Name = $"Test Group Type {groupTypeGuid}",
Guid = groupTypeGuid,
},
};
var groupService = new GroupService(rockContext);
groupService.Add(group);
rockContext.SaveChanges();
var groupTypeRole = new GroupTypeRole
{
Name = "Test Role",
GroupTypeId = group.GroupTypeId
};
var groupTypeRoleService = new GroupTypeRoleService(rockContext);
groupTypeRoleService.Add(groupTypeRole);
rockContext.SaveChanges();
return(group);
}
/// <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>
/// 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>
/// 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();
}
/// <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);
// this event gets fired after block settings are updated. it's nice to repaint the screen if these settings would alter it
this.BlockUpdated += Block_BlockUpdated;
this.AddConfigurationUpdateTrigger(upnlContent);
canCheckInOnly = GetAttributeValue("CanCheckInOnly").AsBoolean();
ownerRoleGuid = GetAttributeValue("GroupType/RoleFilter").AsGuidOrNull() ?? Guid.Empty;
// The 'owner' of the group is determined by built-in KnownRelationshipsOwner role or the role that is marked as IsLeader for the group
var ownerRole = new GroupTypeRoleService(new RockContext()).Get(ownerRoleGuid);
if (ownerRole != null)
{
ownerRole.LoadAttributes();
IsInverseRelationshipsOwner = ownerRole.Attributes.ContainsKey("InverseRelationship") &&
(ownerRole.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid()) || ownerRole.IsLeader);
}
else
{
IsInverseRelationshipsOwner = false;
}
}
/// <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].AsInteger() ?? 0);
var groupTypeRoleIdList = selectionValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(a => a.AsInteger()).ToList();
var groupTypeRoles = new GroupTypeRoleService().Queryable().Where(a => groupTypeRoleIdList.Contains(a.Id)).ToList();
if (groupType != null)
{
result = string.Format("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(","));
}
}
}
return(result);
}
/// <summary>
/// Gets the people a person is related to
/// </summary>
/// <param name="context"></param>
/// <param name="input"></param>
/// <param name="relationshipTypeName">The relationship name you're search for</param>
/// <returns></returns>
public static List <Person> Relationship(DotLiquid.Context context, object input, string relationshipTypeName)
{
Person person = null;
var rockContext = new RockContext();
if (input is int)
{
person = new PersonService(rockContext).Get(( int )input);
}
else if (input is Person)
{
person = ( Person )input;
}
if (person != null)
{
var relationshipType = new GroupTypeRoleService(rockContext).GetByGroupTypeId(GroupTypeCache.Read(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid()).Id).FirstOrDefault(r => relationshipTypeName == r.Name);
if (relationshipType != null)
{
var relatedPersons = new GroupMemberService(rockContext).GetKnownRelationship(person.Id, relationshipType.Id);
return(relatedPersons.Select(p => p.Person).ToList());
}
}
return(new List <Person>());
}
/// <summary>
/// Gets the recipient person identifier expression.
/// </summary>
/// <param name="dbContext">The database context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public Expression GetRecipientPersonIdExpression(System.Data.Entity.DbContext dbContext, MemberExpression entityIdProperty, string selection)
{
var rockContext = dbContext as RockContext;
if (rockContext != null)
{
var qryGroupService = new GroupService(rockContext).Queryable();
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereGroupType = a => 1 == 1;
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereGroupRoles = a => 1 == 1;
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereStatus = a => 1 == 1;
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 3)
{
GroupMemberService groupMemberService = new GroupMemberService(rockContext);
int?groupTypeId = null;
Guid groupTypeGuid = selectionValues[1].AsGuid();
var groupType = GroupTypeCache.Get(groupTypeGuid);
if (groupType != null)
{
groupTypeId = groupType.Id;
}
if (groupTypeId.HasValue)
{
memberWhereGroupType = xx => xx.Group.GroupTypeId == groupTypeId;
}
var groupRoleGuids = selectionValues[2].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(n => n.AsGuid()).ToList();
List <int> groupRoleIds = null;
if (groupRoleGuids.Count() > 0)
{
groupRoleIds = new GroupTypeRoleService(rockContext).Queryable().Where(a => groupRoleGuids.Contains(a.Guid)).Select(a => a.Id).ToList();
memberWhereGroupRoles = xx => groupRoleIds.Contains(xx.GroupRoleId);
}
GroupMemberStatus?groupMemberStatus = selectionValues[3].ConvertToEnumOrNull <GroupMemberStatus>();
if (groupMemberStatus.HasValue)
{
memberWhereStatus = xx => xx.GroupMemberStatus == groupMemberStatus.Value;
}
}
var memberListQuery = qryGroupService.Select(p => p.Members.AsQueryable()
.Where(memberWhereGroupType)
.Where(memberWhereGroupRoles)
.Where(memberWhereStatus)
.Select(m => m.PersonId));
var selectChildrenExpression = SelectExpressionExtractor.Extract(memberListQuery, entityIdProperty, "p");
return(selectChildrenExpression);
}
return(null);
}
/// <summary>
/// Returns a person's consolidator if they have one
/// </summary>
/// <param name="followUp"></param>
/// <param name="rockContext"></param>
/// <returns></returns>
public static Person GetConsolidator(this Person followUp, RockContext rockContext)
{
var groupMemberService = new GroupMemberService(rockContext);
var consolidatedBy = new GroupTypeRoleService(rockContext).Get(SystemGuid.GroupTypeRole.CONSOLIDATED_BY.AsGuid());
return(groupMemberService.GetKnownRelationship(followUp.Id, consolidatedBy.Id).FirstOrDefault()?.Person);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="entityIdProperty">The entity identifier property.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(RockContext context, MemberExpression entityIdProperty, string selection)
{
var qryGroupService = new GroupService(context).Queryable();
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereGroupType = a => 1 == 1;
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereGroupRoles = a => 1 == 1;
Expression <Func <Rock.Model.GroupMember, bool> > memberWhereStatus = a => 1 == 1;
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 3)
{
GroupMemberService groupMemberService = new GroupMemberService(context);
int?groupTypeId = null;
Guid groupTypeGuid = selectionValues[1].AsGuid();
var groupType = GroupTypeCache.Get(groupTypeGuid);
if (groupType != null)
{
groupTypeId = groupType.Id;
}
if (groupTypeId.HasValue)
{
memberWhereGroupType = xx => xx.Group.GroupTypeId == groupTypeId;
}
var groupRoleGuids = selectionValues[2].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(n => n.AsGuid()).ToList();
List <int> groupRoleIds = null;
if (groupRoleGuids.Count() > 0)
{
groupRoleIds = new GroupTypeRoleService(context).Queryable().Where(a => groupRoleGuids.Contains(a.Guid)).Select(a => a.Id).ToList();
memberWhereGroupRoles = xx => groupRoleIds.Contains(xx.GroupRoleId);
}
GroupMemberStatus?groupMemberStatus = selectionValues[3].ConvertToEnumOrNull <GroupMemberStatus>();
if (groupMemberStatus.HasValue)
{
memberWhereStatus = xx => xx.GroupMemberStatus == groupMemberStatus.Value;
}
}
var memberListQuery = qryGroupService.Select(p => p.Members.AsQueryable()
.Where(memberWhereGroupType)
.Where(memberWhereGroupRoles)
.Where(memberWhereStatus)
.Select(m => new MemberInfo
{
NickName = m.Person.NickName,
LastName = m.Person.LastName,
SuffixValueId = m.Person.SuffixValueId,
PersonId = m.PersonId,
GroupMemberId = m.Id
}).OrderBy(a => a.LastName).ThenBy(a => a.NickName));
var selectChildrenExpression = SelectExpressionExtractor.Extract(memberListQuery, entityIdProperty, "p");
return(selectChildrenExpression);
}
public static bool HasConsolidator(this Person person)
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
var consolidatedBy = new GroupTypeRoleService(rockContext).Get(SystemGuid.GroupTypeRole.CONSOLIDATED_BY.AsGuid());
return(groupMemberService.GetKnownRelationship(person.Id, consolidatedBy.Id) != null);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
string[] selectionValues = selection.Split('|');
if (selectionValues.Length >= 2)
{
GroupMemberService groupMemberService = new GroupMemberService((RockContext)serviceInstance.Context);
int groupTypeId = 0;
Guid groupTypeGuid = selectionValues[0].AsGuid();
var groupType = GroupTypeCache.Get(groupTypeGuid);
if (groupType != null)
{
groupTypeId = groupType.Id;
}
var groupMemberServiceQry = groupMemberService.Queryable().Where(xx => xx.Group.GroupTypeId == groupTypeId && xx.Group.IsArchived != true);
bool?groupStatus = null;
if (selectionValues.Length >= 4)
{
groupStatus = selectionValues[3].AsBooleanOrNull();
}
if (groupStatus.HasValue)
{
groupMemberServiceQry = groupMemberServiceQry.Where(xx => xx.Group.IsActive == groupStatus.Value);
}
var groupRoleGuids = selectionValues[1].Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(n => n.AsGuid()).ToList();
if (groupRoleGuids.Count() > 0)
{
var groupRoleIds = new GroupTypeRoleService((RockContext)serviceInstance.Context).Queryable().Where(a => groupRoleGuids.Contains(a.Guid)).Select(a => a.Id).ToList();
groupMemberServiceQry = groupMemberServiceQry.Where(xx => groupRoleIds.Contains(xx.GroupRoleId));
}
GroupMemberStatus?groupMemberStatus = null;
if (selectionValues.Length >= 3)
{
groupMemberStatus = selectionValues[2].ConvertToEnumOrNull <GroupMemberStatus>();
}
if (groupMemberStatus.HasValue)
{
groupMemberServiceQry = groupMemberServiceQry.Where(xx => xx.GroupMemberStatus == groupMemberStatus.Value);
}
var qry = new PersonService((RockContext)serviceInstance.Context).Queryable()
.Where(p => groupMemberServiceQry.Any(xx => xx.PersonId == p.Id));
Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
return(null);
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var rockContext = new RockContext();
var recordTypeValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_BUSINESS.AsGuid()).Id;
var activeRecordStatusValueId = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid()).Id;
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();
var queryable = new PersonService(rockContext).Queryable()
.Where(q => q.RecordTypeValueId == recordTypeValueId && q.RecordStatusValueId == activeRecordStatusValueId);
// Business Name Filter
var businessName = gfBusinessFilter.GetUserPreference("Business Name");
if (!string.IsNullOrWhiteSpace(businessName))
{
queryable = queryable.Where(a => a.FirstName.Contains(businessName));
}
// Owner Filter
int ownerId = 0;
if (int.TryParse(gfBusinessFilter.GetUserPreference("Owner"), out ownerId) && ownerId != 0)
{
var members = queryable.SelectMany(a => a.Members).ToList();
foreach (var member in members)
{
if (member.GroupRoleId == businessRoleId)
{
var groupMemberService = new GroupMemberService(rockContext);
var owner = groupMemberService.GetInverseRelationship(member, false, CurrentPersonAlias);
if (owner.PersonId != ownerId)
{
queryable = queryable.Where(a => a.Id != member.PersonId);
}
}
}
}
SortProperty sortProperty = gBusinessList.SortProperty;
if (sortProperty != null)
{
gBusinessList.DataSource = queryable.Sort(sortProperty).ToList();
}
else
{
gBusinessList.DataSource = queryable.OrderBy(q => q.FirstName).ToList();
}
gBusinessList.DataBind();
}
/// <summary>
/// Gets a persons followups
/// </summary>
/// <param name="consolidator"></param>
/// <param name="rockContext"></param>
/// <returns></returns>
public static IQueryable <Person> GetFollowUps(this Person consolidator, RockContext rockContext)
{
var groupMemberService = new GroupMemberService(rockContext);
var consolidatedBy = new GroupTypeRoleService(rockContext).Get(SystemGuid.GroupTypeRole.CONSOLIDATOR.AsGuid());
if (consolidatedBy != null)
{
return(groupMemberService.GetKnownRelationship(consolidator.Id, consolidatedBy.Id).Select(gm => gm.Person));
}
return(null);
}
/// <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?groupTypeGuid = null;
Guid?groupGuid = null;
Guid?groupTypeRoleGuid = null;
string[] parts = (value ?? string.Empty).Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length > 0)
{
groupTypeGuid = parts[0].AsGuidOrNull();
if (parts.Length > 1)
{
groupGuid = parts[1].AsGuidOrNull();
}
if (parts.Length > 2)
{
groupTypeRoleGuid = parts[2].AsGuidOrNull();
}
}
using (var rockContext = new RockContext())
{
if (groupGuid.HasValue)
{
var group = new GroupService(rockContext).GetNoTracking(groupGuid.Value);
if (group != null)
{
formattedValue = "Group: " + group.Name;
}
}
else if (groupTypeGuid.HasValue)
{
var groupType = new GroupTypeService(rockContext).GetNoTracking(groupTypeGuid.Value);
if (groupType != null)
{
formattedValue = "Group type: " + groupType.Name;
}
}
if (groupTypeRoleGuid.HasValue)
{
var groupTypeRole = new GroupTypeRoleService(rockContext).GetNoTracking(groupTypeRoleGuid.Value);
if (groupTypeRole != null)
{
formattedValue += string.IsNullOrEmpty(formattedValue) ? string.Empty : ", " + "Role: " + groupTypeRole.Name;
}
}
}
return(base.FormatValue(parentControl, formattedValue, null, condensed));
}
public static void RemoveConsolidator(this Person person, Person newConsolidator)
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
if (!person.HasConsolidator())
{
throw new Exception(person.FullName + " doesn't have a consolidator");
}
var consolidatedBy = new GroupTypeRoleService(rockContext).Get(SystemGuid.GroupTypeRole.CONSOLIDATED_BY.AsGuid());
groupMemberService.DeleteKnownRelationship(person.Id, newConsolidator.Id, consolidatedBy.Id);
rockContext.SaveChanges();
}
/// <summary>
/// Gets the follow ups for the line below a leader or coordinator
/// </summary>
/// <param name="personService"></param>
/// <param name="currentPerson"></param>
/// <param name="rockContext"></param>
/// <param name="showAllIfStaff">If a staff member, should they see all people</param>
/// <returns></returns>
public static IQueryable <Person> GetPeopleInLineFollowUps(PersonService personService, Person currentPerson, RockContext rockContext, bool showAllIfStaff)
{
if (currentPerson == null)
{
return(new List <Person>().AsQueryable());
}
if (showAllIfStaff && CheckIsStaff(currentPerson, rockContext))
{
return(personService.Queryable());
}
var cellGroupsIdsInLine = GetCellGroupIdsInLine(currentPerson, rockContext);
var recordStatusIsActiveGuid = Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_ACTIVE.AsGuid();
var groupMemberService = new GroupMemberService(rockContext);
// Get person Ids from line
var linePersonIds =
groupMemberService.Queryable()
.Where(gm => cellGroupsIdsInLine.Contains(gm.GroupId) && gm.Person.RecordStatusValue.Guid == recordStatusIsActiveGuid)
.Select(gm => gm.PersonId).ToList();
// Get people's follow ups
int consolidatorGroupTypeRoleId = new GroupTypeRoleService(rockContext).Get(SystemGuid.GroupTypeRole.CONSOLIDATOR.AsGuid()).Id;
var followUpIds = new List <int>();
foreach (int personId in linePersonIds)
{
followUpIds.AddRange(groupMemberService.GetKnownRelationship(personId, consolidatorGroupTypeRoleId).Where(gm => gm.Person.RecordStatusValue.Guid == recordStatusIsActiveGuid).Select(gm => gm.PersonId));
}
//Remove people who are in a group as a coordinator or leader
var cellGroupType = GroupTypeCache.Read(SystemGuid.GroupType.CELL_GROUP.AsGuid());
var consolidatorCoordinatorGuid = SystemGuid.GroupTypeRole.CONSOLIDATION_COORDINATOR.AsGuid();
var idsToRemove =
groupMemberService.Queryable()
.Where(
gm =>
followUpIds.Any(fId => gm.PersonId == fId) &&
gm.Group.GroupTypeId == cellGroupType.Id &&
(gm.GroupRole.Guid == consolidatorCoordinatorGuid || gm.GroupRole.IsLeader))
.Select(gm => gm.PersonId)
.ToList();
foreach (int idToRemove in idsToRemove)
{
followUpIds.Remove(idToRemove);
}
return(personService.GetByIds(followUpIds).Distinct());
}
/// <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();
bool includeChildGroups = false;
if (selectionValues.Length >= 3)
{
includeChildGroups = selectionValues[2].AsBooleanOrNull() ?? false;
}
GroupMemberStatus?groupMemberStatus = GroupMemberStatus.Active;
if (selectionValues.Length >= 4)
{
groupMemberStatus = selectionValues[3].ConvertToEnumOrNull <GroupMemberStatus>();
}
if (group != null)
{
result = string.Format("In group: {0}", group.Name);
if (includeChildGroups)
{
result += " or child groups";
}
if (groupTypeRoles.Count() > 0)
{
result += string.Format(", with role(s): {0}", groupTypeRoles.Select(a => string.Format("{0} ({1})", a.Name, a.GroupType.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 groupType = GroupTypeCache.Get(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();
bool?groupStatus = null;
if (selectionValues.Length >= 4)
{
groupStatus = selectionValues[3].AsBooleanOrNull();
}
GroupMemberStatus?groupMemberStatus = null;
if (selectionValues.Length >= 3)
{
groupMemberStatus = selectionValues[2].ConvertToEnumOrNull <GroupMemberStatus>();
}
if (groupType != null)
{
result = string.Format("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 (groupStatus.HasValue)
{
result += string.Format(", with group status: {0}", groupStatus.Value ? "Active" : "Inactive");
}
if (groupMemberStatus.HasValue)
{
result += string.Format(", with member status: {0}", groupMemberStatus.ConvertToString());
}
}
}
return(result);
}
/// <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)
{
GroupAndRolePicker groupAndRolePicker = control as GroupAndRolePicker;
if (groupAndRolePicker != null)
{
var rockContext = new RockContext();
Guid?groupTypeGuid = null;
Guid?groupGuid = null;
Guid?groupTypeRoleGuid = null;
if (groupAndRolePicker.GroupTypeId.HasValue)
{
var groupType = new GroupTypeService(rockContext).GetNoTracking(groupAndRolePicker.GroupTypeId.Value);
if (groupType != null)
{
groupTypeGuid = groupType.Guid;
}
}
if (groupAndRolePicker.GroupId.HasValue)
{
var group = new GroupService(rockContext).Get(groupAndRolePicker.GroupId.Value);
if (group != null)
{
groupGuid = group.Guid;
}
}
if (groupAndRolePicker.GroupRoleId.HasValue)
{
var groupTypeRole = new GroupTypeRoleService(rockContext).Get(groupAndRolePicker.GroupRoleId.Value);
if (groupTypeRole != null)
{
groupTypeRoleGuid = groupTypeRole.Guid;
}
}
if (groupTypeGuid.HasValue || groupGuid.HasValue || groupTypeRoleGuid.HasValue)
{
return(string.Format("{0}|{1}|{2}", groupTypeGuid, groupGuid, groupTypeRoleGuid));
}
}
return(null);
}
/// <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>
/// 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();
}
