/// <summary>
/// Executes the specified context.
/// </summary>
/// <param name="context">The context.</param>
public void Execute(IJobExecutionContext context)
{
var errors = new List <string>();
var rockContext = new RockContext();
JobDataMap dataMap = context.JobDetail.JobDataMap;
Guid? systemEmailGuid = dataMap.GetString("NotificationEmailTemplate").AsGuidOrNull();
if (systemEmailGuid.HasValue)
{
var selectedGroupTypes = new List <Guid>();
if (!string.IsNullOrWhiteSpace(dataMap.GetString("GroupTypes")))
{
selectedGroupTypes = dataMap.GetString("GroupTypes").Split(',').Select(Guid.Parse).ToList();
}
var notificationOption = dataMap.GetString("NotifyParentLeaders").ConvertToEnum <NotificationOption>(NotificationOption.None);
var accountAbilityGroupGuid = dataMap.GetString("AccountabilityGroup").AsGuid();
var groupRequirementsQry = new GroupRequirementService(rockContext).Queryable();
// get groups matching of the types provided
GroupService groupService = new GroupService(rockContext);
var groups = groupService.Queryable().AsNoTracking()
.Where(g => selectedGroupTypes.Contains(g.GroupType.Guid) &&
g.IsActive == true &&
groupRequirementsQry.Any(a => (a.GroupId.HasValue && a.GroupId == g.Id) || (a.GroupTypeId.HasValue && a.GroupTypeId == g.GroupTypeId)));
foreach (var group in groups)
{
// check for members that don't meet requirements
var groupMembersWithIssues = groupService.GroupMembersNotMeetingRequirements(group, true);
if (groupMembersWithIssues.Count > 0)
{
// add issues to issue list
GroupsMissingRequirements groupMissingRequirements = new GroupsMissingRequirements();
groupMissingRequirements.Id = group.Id;
groupMissingRequirements.Name = group.Name;
if (group.GroupType != null)
{
groupMissingRequirements.GroupTypeId = group.GroupTypeId;
groupMissingRequirements.GroupTypeName = group.GroupType.Name;
}
groupMissingRequirements.AncestorPathName = groupService.GroupAncestorPathName(group.Id);
// get list of the group leaders
groupMissingRequirements.Leaders = group.Members
.Where(m => m.GroupRole.ReceiveRequirementsNotifications)
.Select(m => new GroupMemberResult
{
Id = m.Id,
PersonId = m.PersonId,
FullName = m.Person.FullName
})
.ToList();
List <GroupMembersMissingRequirements> groupMembers = new List <GroupMembersMissingRequirements>();
foreach (var groupMemberIssue in groupMembersWithIssues)
{
GroupMembersMissingRequirements groupMember = new GroupMembersMissingRequirements();
groupMember.FullName = groupMemberIssue.Key.Person.FullName;
groupMember.Id = groupMemberIssue.Key.Id;
groupMember.PersonId = groupMemberIssue.Key.PersonId;
groupMember.GroupMemberRole = groupMemberIssue.Key.GroupRole.Name;
List <MissingRequirement> missingRequirements = new List <MissingRequirement>();
// Now find exactly which ISSUE corresponds to the group member based on their role
foreach (var issue in groupMemberIssue.Value)
{
// If the issue is tied to a role, does it match the person's role?
// If it does not, skip it.
if (issue.Key.GroupRequirement.GroupRoleId != null && issue.Key.GroupRequirement.GroupRoleId != groupMemberIssue.Key.GroupRoleId)
{
continue;
}
MissingRequirement missingRequirement = new MissingRequirement();
missingRequirement.Id = issue.Key.GroupRequirement.GroupRequirementType.Id;
missingRequirement.Name = issue.Key.GroupRequirement.GroupRequirementType.Name;
missingRequirement.Status = issue.Key.MeetsGroupRequirement;
missingRequirement.OccurrenceDate = issue.Value;
switch (issue.Key.MeetsGroupRequirement)
{
case MeetsGroupRequirement.Meets:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.PositiveLabel;
break;
case MeetsGroupRequirement.MeetsWithWarning:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.WarningLabel;
break;
case MeetsGroupRequirement.NotMet:
missingRequirement.Message = issue.Key.GroupRequirement.GroupRequirementType.NegativeLabel;
break;
}
missingRequirements.Add(missingRequirement);
}
groupMember.MissingRequirements = missingRequirements;
groupMembers.Add(groupMember);
}
groupMissingRequirements.GroupMembersMissingRequirements = groupMembers;
_groupsMissingRequriements.Add(groupMissingRequirements);
// add leaders as people to notify
foreach (var leader in group.Members.Where(m => m.GroupRole.ReceiveRequirementsNotifications))
{
NotificationItem notification = new NotificationItem();
notification.GroupId = group.Id;
notification.Person = leader.Person;
_notificationList.Add(notification);
}
// notify parents
if (notificationOption != NotificationOption.None)
{
var parentLeaders = new GroupMemberService(rockContext).Queryable("Person").AsNoTracking()
.Where(m => m.GroupRole.ReceiveRequirementsNotifications);
if (notificationOption == NotificationOption.DirectParent)
{
// just the parent group
parentLeaders = parentLeaders.Where(m => m.GroupId == group.ParentGroupId);
}
else
{
// all parents in the hierarchy
var parentIds = groupService.GetAllAncestorIds(group.Id);
parentLeaders = parentLeaders.Where(m => parentIds.Contains(m.GroupId));
}
foreach (var parentLeader in parentLeaders.ToList())
{
NotificationItem parentNotification = new NotificationItem();
parentNotification.Person = parentLeader.Person;
parentNotification.GroupId = group.Id;
_notificationList.Add(parentNotification);
}
}
}
}
// send out notifications
int recipients = 0;
var notificationRecipients = _notificationList.GroupBy(p => p.Person.Id).ToList();
foreach (var recipientId in notificationRecipients)
{
var recipient = _notificationList.Where(n => n.Person.Id == recipientId.Key).Select(n => n.Person).FirstOrDefault();
if (!recipient.IsEmailActive || recipient.Email.IsNullOrWhiteSpace() || recipient.EmailPreference == EmailPreference.DoNotEmail)
{
continue;
}
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Person", recipient);
var notificationGroupIds = _notificationList
.Where(n => n.Person.Id == recipient.Id)
.Select(n => n.GroupId)
.ToList();
var missingRequirements = _groupsMissingRequriements.Where(g => notificationGroupIds.Contains(g.Id)).ToList();
mergeFields.Add("GroupsMissingRequirements", missingRequirements);
var emailMessage = new RockEmailMessage(systemEmailGuid.Value);
emailMessage.AddRecipient(new RockEmailMessageRecipient(recipient, mergeFields));
var emailErrors = new List <string>();
emailMessage.Send(out emailErrors);
errors.AddRange(emailErrors);
recipients++;
}
// add accountability group members
if (!accountAbilityGroupGuid.IsEmpty())
{
var accountabilityGroupMembers = new GroupMemberService(rockContext).Queryable().AsNoTracking()
.Where(m => m.Group.Guid == accountAbilityGroupGuid)
.Select(m => m.Person);
var emailMessage = new RockEmailMessage(systemEmailGuid.Value);
foreach (var person in accountabilityGroupMembers)
{
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
mergeFields.Add("Person", person);
mergeFields.Add("GroupsMissingRequirements", _groupsMissingRequriements);
emailMessage.AddRecipient(new RockEmailMessageRecipient(person, mergeFields));
recipients++;
}
var emailErrors = new List <string>();
emailMessage.Send(out emailErrors);
errors.AddRange(emailErrors);
}
context.Result = string.Format("{0} requirement notification {1} sent", recipients, "email".PluralizeIf(recipients != 1));
if (errors.Any())
{
StringBuilder sb = new StringBuilder();
sb.AppendLine();
sb.Append(string.Format("{0} Errors: ", errors.Count()));
errors.ForEach(e => { sb.AppendLine(); sb.Append(e); });
string errorMessage = sb.ToString();
context.Result += errorMessage;
var exception = new Exception(errorMessage);
HttpContext context2 = HttpContext.Current;
ExceptionLogService.LogException(exception, context2);
throw exception;
}
}
else
{
context.Result = "Warning: No NotificationEmailTemplate found";
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
var mergeFields = GetMergeFields(action);
int? fromId = null;
Guid?fromGuid = GetAttributeValue(action, "From").AsGuidOrNull();
if (fromGuid.HasValue)
{
var fromValue = DefinedValueCache.Read(fromGuid.Value, rockContext);
if (fromValue != null)
{
fromId = fromValue.Id;
}
}
var recipients = new List <RecipientData>();
string toValue = GetAttributeValue(action, "To");
Guid guid = toValue.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Read(guid, rockContext);
if (attribute != null)
{
string toAttributeValue = action.GetWorklowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(toAttributeValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.TextFieldType":
{
recipients.Add(new RecipientData(toAttributeValue));
break;
}
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var phoneNumber = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.SelectMany(a => a.Person.PhoneNumbers)
.Where(p => p.IsMessagingEnabled)
.FirstOrDefault();
if (phoneNumber == null)
{
action.AddLogEntry("Invalid Recipient: Person or valid SMS phone number not found", true);
}
else
{
string smsNumber = phoneNumber.Number;
if (!string.IsNullOrWhiteSpace(phoneNumber.CountryCode))
{
smsNumber = "+" + phoneNumber.CountryCode + phoneNumber.Number;
}
var recipient = new RecipientData(smsNumber);
recipients.Add(recipient);
var person = new PersonAliasService(rockContext).GetPerson(personAliasGuid);
if (person != null)
{
recipient.MergeFields.Add("Person", person);
}
}
}
break;
}
case "Rock.Field.Types.GroupFieldType":
case "Rock.Field.Types.SecurityRoleFieldType":
{
int? groupId = toAttributeValue.AsIntegerOrNull();
Guid?groupGuid = toAttributeValue.AsGuidOrNull();
IQueryable <GroupMember> qry = null;
// Handle situations where the attribute value is the ID
if (groupId.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value);
}
// Handle situations where the attribute value stored is the Guid
else if (groupGuid.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value);
}
else
{
action.AddLogEntry("Invalid Recipient: No valid group id or Guid", true);
}
if (qry != null)
{
foreach (var person in qry
.Where(m => m.GroupMemberStatus == GroupMemberStatus.Active)
.Select(m => m.Person))
{
var phoneNumber = person.PhoneNumbers
.Where(p => p.IsMessagingEnabled)
.FirstOrDefault();
if (phoneNumber != null)
{
string smsNumber = phoneNumber.Number;
if (!string.IsNullOrWhiteSpace(phoneNumber.CountryCode))
{
smsNumber = "+" + phoneNumber.CountryCode + phoneNumber.Number;
}
var recipient = new RecipientData(smsNumber);
recipients.Add(recipient);
recipient.MergeFields.Add("Person", person);
}
}
}
break;
}
}
}
}
}
else
{
if (!string.IsNullOrWhiteSpace(toValue))
{
recipients.Add(new RecipientData(toValue.ResolveMergeFields(mergeFields)));
}
}
string message = GetAttributeValue(action, "Message");
Guid messageGuid = message.AsGuid();
if (!messageGuid.IsEmpty())
{
var attribute = AttributeCache.Read(messageGuid, rockContext);
if (attribute != null)
{
string messageAttributeValue = action.GetWorklowAttributeValue(messageGuid);
if (!string.IsNullOrWhiteSpace(messageAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
message = messageAttributeValue;
}
}
}
}
if (recipients.Any() && !string.IsNullOrWhiteSpace(message))
{
var mediumEntity = EntityTypeCache.Read(Rock.SystemGuid.EntityType.COMMUNICATION_MEDIUM_SMS.AsGuid(), rockContext);
if (mediumEntity != null)
{
var medium = MediumContainer.GetComponent(mediumEntity.Name);
if (medium != null && medium.IsActive)
{
var transport = medium.Transport;
if (transport != null && transport.IsActive)
{
var appRoot = GlobalAttributesCache.Read(rockContext).GetValue("InternalApplicationRoot");
foreach (var recipient in recipients)
{
var recipientMergeFields = new Dictionary <string, object>(mergeFields);
foreach (var mergeField in recipient.MergeFields)
{
recipientMergeFields.Add(mergeField.Key, mergeField.Value);
}
var mediumData = new Dictionary <string, string>();
mediumData.Add("FromValue", fromId.Value.ToString());
mediumData.Add("Message", message.ResolveMergeFields(recipientMergeFields));
var number = new List <string> {
recipient.To
};
transport.Send(mediumData, number, appRoot, string.Empty);
}
}
}
}
}
return(true);
}
/// <summary>
/// Loads the entity drop downs.
/// </summary>
private void LoadEntityDropDowns()
{
if (_financialTransactionDetailList == null)
{
return;
}
int?entityTypeQualifierValue = this.GetAttributeValue("EntityTypeQualifierValue").AsIntegerOrNull();
var rockContext = new RockContext();
Dictionary <int, int?> entityLookup = _financialTransactionDetailList.Where(a => a.EntityId.HasValue).ToDictionary(k => k.Id, v => v.EntityId);
if (_transactionEntityType != null)
{
if (_transactionEntityType.Id == EntityTypeCache.GetId <GroupMember>())
{
int?groupTypeId = entityTypeQualifierValue;
var groupsWithMembersList = new GroupService(new RockContext()).Queryable().Where(a => a.GroupTypeId == groupTypeId.Value && a.Members.Any() && a.IsActive).OrderBy(a => a.Order).ThenBy(a => a.Name).AsNoTracking()
.Select(a => new
{
a.Id,
a.Name
})
.ToList();
foreach (var ddlGroup in phTableRows.ControlsOfTypeRecursive <RockDropDownList>().Where(a => a.ID.StartsWith("ddlGroup_")))
{
ddlGroup.Items.Clear();
ddlGroup.Items.Add(new ListItem());
foreach (var group in groupsWithMembersList)
{
ddlGroup.Items.Add(new ListItem(group.Name, group.Id.ToString()));
}
var financialTransactionDetailId = ddlGroup.ID.Replace("ddlGroup_", string.Empty).AsInteger();
var ddlGroupMember = phTableRows.ControlsOfTypeRecursive <RockDropDownList>().Where(a => a.ID == "ddlGroupMember_" + financialTransactionDetailId.ToString()).FirstOrDefault() as RockDropDownList;
var groupMemberId = entityLookup.GetValueOrNull(financialTransactionDetailId);
GroupMember groupMember = null;
if (groupMemberId.HasValue)
{
groupMember = new GroupMemberService(rockContext).Get(groupMemberId.Value);
}
if (groupMember != null)
{
ddlGroup.SetValue(groupMember.GroupId.ToString());
LoadGroupMembersDropDown(ddlGroup);
ddlGroupMember.SetValue(groupMember.Id);
}
else
{
// if there is no groupMember, make sure the controls don't have anything selected
ddlGroup.SetValue((int?)null);
ddlGroupMember.Items.Clear();
ddlGroupMember.SetValue(( int? )null);
}
ddlGroupMember.Visible = ddlGroup.SelectedValue.AsIntegerOrNull().HasValue;
}
}
else if (_transactionEntityType.Id == EntityTypeCache.GetId <Group>())
{
int? groupTypeId = entityTypeQualifierValue;
bool limitToActiveGroups = this.GetAttributeValue("LimitToActiveGroups").AsBoolean();
var groupQry = new GroupService(new RockContext()).Queryable().Where(a => a.GroupTypeId == groupTypeId.Value && a.IsActive);
if (limitToActiveGroups)
{
groupQry = groupQry.Where(a => a.IsActive == true);
}
;
var groupList = groupQry.OrderBy(a => a.Order).ThenBy(a => a.Name).AsNoTracking().Select(a =>
new
{
a.Id,
a.Name
})
.ToList();
foreach (var ddlGroup in phTableRows.ControlsOfTypeRecursive <RockDropDownList>().Where(a => a.ID.StartsWith("ddlGroup_")))
{
ddlGroup.Items.Clear();
ddlGroup.Items.Add(new ListItem());
foreach (var group in groupList)
{
ddlGroup.Items.Add(new ListItem(group.Name, group.Id.ToString()));
}
var financialTransactionDetailId = ddlGroup.ID.Replace("ddlGroup_", string.Empty).AsInteger();
var groupId = entityLookup.GetValueOrNull(financialTransactionDetailId);
if (groupId.HasValue)
{
ddlGroup.SetValue(groupId);
}
else
{
// if there is no value, make sure the controls don't have anything selected
ddlGroup.SetValue(( int? )null);
}
}
}
else if (_transactionEntityType.Id == EntityTypeCache.GetId <DefinedValue>())
{
int?definedTypeId = entityTypeQualifierValue;
var definedValueList = DefinedTypeCache.Get(definedTypeId.Value).DefinedValues;
foreach (var ddlDefinedValue in phTableRows.ControlsOfTypeRecursive <DefinedValuePicker>().Where(a => a.ID.StartsWith("ddlDefinedValue_")))
{
ddlDefinedValue.DefinedTypeId = definedTypeId;
var financialTransactionDetailId = ddlDefinedValue.ID.Replace("ddlDefinedValue_", string.Empty).AsInteger();
var definedValueId = entityLookup.GetValueOrNull(financialTransactionDetailId);
if (definedValueId.HasValue)
{
ddlDefinedValue.SetValue(definedValueId);
}
else
{
// if there is no value, make sure the controls don't have anything selected
ddlDefinedValue.SetValue(( int? )null);
}
}
}
else if (_transactionEntityType.SingleValueFieldType != null && _transactionEntityType.SingleValueFieldType.Field is IEntityFieldType)
{
foreach (var entityPicker in phTableRows.ControlsOfTypeRecursive <Control>().Where(a => a.ID != null && a.ID.StartsWith("entityPicker_")))
{
var financialTransactionDetailId = entityPicker.ID.Replace("entityPicker_", string.Empty).AsInteger();
var entityId = entityLookup.GetValueOrNull(financialTransactionDetailId);
(_transactionEntityType.SingleValueFieldType.Field as IEntityFieldType).SetEditValueFromEntityId(entityPicker, new Dictionary <string, ConfigurationValue>(), entityId);
}
}
}
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
Guid? groupGuid = null;
Person person = null;
Group group = null;
string noteValue = string.Empty;
string captionValue = string.Empty;
bool isAlert = false;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if (!groupAttributeGuid.IsEmpty())
{
groupGuid = action.GetWorklowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
if (group == null)
{
errorMessages.Add("The group provided does not exist.");
}
}
else
{
errorMessages.Add("Invalid group provided.");
}
}
// get person alias guid
Guid personAliasGuid = Guid.Empty;
string personAttribute = GetAttributeValue(action, "Person");
Guid guid = personAttribute.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Read(guid, rockContext);
if (attribute != null)
{
string value = action.GetWorklowAttributeValue(guid);
personAliasGuid = value.AsGuid();
}
if (personAliasGuid != Guid.Empty)
{
person = new PersonAliasService(rockContext).Queryable()
.Where(p => p.Guid.Equals(personAliasGuid))
.Select(p => p.Person)
.FirstOrDefault();
}
else
{
errorMessages.Add("The person could not be found!");
}
}
// get caption
captionValue = GetAttributeValue(action, "Caption");
guid = captionValue.AsGuid();
if (guid.IsEmpty())
{
captionValue = captionValue.ResolveMergeFields(GetMergeFields(action));
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue(guid);
if (workflowAttributeValue != null)
{
captionValue = workflowAttributeValue;
}
}
// get group member note
noteValue = GetAttributeValue(action, "Note");
guid = noteValue.AsGuid();
if (guid.IsEmpty())
{
noteValue = noteValue.ResolveMergeFields(GetMergeFields(action));
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue(guid);
if (workflowAttributeValue != null)
{
noteValue = workflowAttributeValue;
}
}
// get alert type
string isAlertString = GetAttributeValue(action, "IsAlert");
guid = isAlertString.AsGuid();
if (guid.IsEmpty())
{
isAlert = isAlertString.AsBoolean();
}
else
{
var workflowAttributeValue = action.GetWorklowAttributeValue(guid);
if (workflowAttributeValue != null)
{
isAlert = workflowAttributeValue.AsBoolean();
}
}
// get note type
NoteTypeCache noteType = null;
Guid noteTypeGuid = GetAttributeValue(action, "NoteType").AsGuid();
if (!noteTypeGuid.IsEmpty())
{
noteType = NoteTypeCache.Read(noteTypeGuid, rockContext);
if (noteType == null)
{
errorMessages.Add("The note type provided does not exist.");
}
}
else
{
errorMessages.Add("Invalid note type provided.");
}
// set note
if (group != null && person != null && noteType != null)
{
var groupMembers = new GroupMemberService(rockContext).Queryable()
.Where(m => m.Group.Guid == groupGuid && m.PersonId == person.Id).ToList();
if (groupMembers.Count() > 0)
{
foreach (var groupMember in groupMembers)
{
NoteService noteservice = new NoteService(rockContext);
Note note = new Note();
noteservice.Add(note);
note.NoteTypeId = noteType.Id;
note.Text = noteValue;
note.IsAlert = isAlert;
note.Caption = captionValue;
note.EntityId = groupMember.Id;
rockContext.SaveChanges();
}
}
else
{
errorMessages.Add(string.Format("{0} is not a member of the group {1}.", person.FullName, group.Name));
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Binds the group members grid.
/// </summary>
protected void BindGroupMembersGrid()
{
if (_group != null)
{
pnlGroupMembers.Visible = true;
using (new UnitOfWorkScope())
{
lHeading.Text = string.Format("{0} {1}", _group.GroupType.GroupTerm, _group.GroupType.GroupMemberTerm.Pluralize());
if (_group.GroupType.Roles.Any())
{
nbRoleWarning.Visible = false;
rFilter.Visible = true;
gGroupMembers.Visible = true;
// Remove attribute columns
foreach (var column in gGroupMembers.Columns.OfType <AttributeField>().ToList())
{
gGroupMembers.Columns.Remove(column);
}
// Add attribute columns
int entityTypeId = new GroupMember().TypeId;
string groupQualifier = _group.Id.ToString();
string groupTypeQualifier = _group.GroupTypeId.ToString();
foreach (var attribute in new AttributeService().Queryable()
.Where(a =>
a.EntityTypeId == entityTypeId &&
a.IsGridColumn &&
(a.EntityTypeQualifierColumn.Equals("GroupId", StringComparison.OrdinalIgnoreCase) && a.EntityTypeQualifierValue.Equals(groupQualifier) ||
a.EntityTypeQualifierColumn.Equals("GroupTypeId", StringComparison.OrdinalIgnoreCase) && a.EntityTypeQualifierValue.Equals(groupTypeQualifier))
)
.OrderBy(a => a.Order)
.ThenBy(a => a.Name))
{
string dataFieldExpression = attribute.Key;
bool columnExists = gGroupMembers.Columns.OfType <AttributeField>().FirstOrDefault(a => a.DataField.Equals(dataFieldExpression)) != null;
if (!columnExists)
{
AttributeField boundField = new AttributeField();
boundField.DataField = dataFieldExpression;
boundField.HeaderText = attribute.Name;
boundField.SortExpression = string.Empty;
int insertPos = gGroupMembers.Columns.IndexOf(gGroupMembers.Columns.OfType <DeleteField>().First());
gGroupMembers.Columns.Insert(insertPos, boundField);
}
}
GroupMemberService groupMemberService = new GroupMemberService();
var qry = groupMemberService.Queryable("Person,GroupRole")
.Where(m => m.GroupId == _group.Id);
// Filter by First Name
string firstName = rFilter.GetUserPreference("First Name");
if (!string.IsNullOrWhiteSpace(firstName))
{
qry = qry.Where(m => m.Person.FirstName.StartsWith(firstName));
}
// Filter by Last Name
string lastName = rFilter.GetUserPreference("Last Name");
if (!string.IsNullOrWhiteSpace(lastName))
{
qry = qry.Where(m => m.Person.LastName.StartsWith(lastName));
}
// Filter by role
var roles = new List <int>();
foreach (string role in rFilter.GetUserPreference("Role").Split(';'))
{
if (!string.IsNullOrWhiteSpace(role))
{
int roleId = int.MinValue;
if (int.TryParse(role, out roleId))
{
roles.Add(roleId);
}
}
}
if (roles.Any())
{
qry = qry.Where(m => roles.Contains(m.GroupRoleId));
}
// Filter by Sttus
var statuses = new List <GroupMemberStatus>();
foreach (string status in rFilter.GetUserPreference("Status").Split(';'))
{
if (!string.IsNullOrWhiteSpace(status))
{
statuses.Add(status.ConvertToEnum <GroupMemberStatus>());
}
}
if (statuses.Any())
{
qry = qry.Where(m => statuses.Contains(m.GroupMemberStatus));
}
SortProperty sortProperty = gGroupMembers.SortProperty;
if (sortProperty != null)
{
gGroupMembers.DataSource = qry.Sort(sortProperty).ToList();
}
else
{
gGroupMembers.DataSource = qry.OrderBy(a => a.Person.LastName).ThenBy(a => a.Person.FirstName).ToList();
}
gGroupMembers.DataBind();
}
else
{
nbRoleWarning.Text = string.Format("{0} cannot be added to this {1} because the '{2}' group type does not have any roles defined.",
_group.GroupType.GroupMemberTerm.Pluralize(), _group.GroupType.GroupTerm, _group.GroupType.Name);
nbRoleWarning.Visible = true;
rFilter.Visible = false;
gGroupMembers.Visible = false;
}
}
}
else
{
pnlGroupMembers.Visible = false;
}
}
/// <summary>
/// Saves the changes.
/// </summary>
/// <param name="item">The item.</param>
protected void SaveChanges(RepeaterItem item)
{
var hfGroupId = item.FindControl("hfGroupId") as HiddenField;
var cbCommunicationListIsSubscribed = item.FindControl("cbCommunicationListIsSubscribed") as RockCheckBox;
var tglCommunicationPreference = item.FindControl("tglCommunicationPreference") as Toggle;
var nbGroupNotification = item.FindControl("nbGroupNotification") as NotificationBox;
nbGroupNotification.Visible = false;
using (var rockContext = new RockContext())
{
int groupId = hfGroupId.Value.AsInteger();
var groupMemberService = new GroupMemberService(rockContext);
var group = new GroupService(rockContext).Get(groupId);
var groupMemberRecordsForPerson = groupMemberService.Queryable().Where(a => a.GroupId == groupId && a.PersonId == this.CurrentPersonId).ToList();
if (groupMemberRecordsForPerson.Any())
{
// normally there would be at most 1 group member record for the person, but just in case, mark them all
foreach (var groupMember in groupMemberRecordsForPerson)
{
if (cbCommunicationListIsSubscribed.Checked)
{
if (groupMember.GroupMemberStatus == GroupMemberStatus.Inactive)
{
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
if (groupMember.Note == "Unsubscribed")
{
groupMember.Note = string.Empty;
}
}
}
else
{
if (groupMember.GroupMemberStatus == GroupMemberStatus.Active)
{
groupMember.GroupMemberStatus = GroupMemberStatus.Inactive;
if (groupMember.Note.IsNullOrWhiteSpace())
{
groupMember.Note = "Unsubscribed";
}
}
}
CommunicationType communicationType = tglCommunicationPreference.Checked ? CommunicationType.Email : CommunicationType.SMS;
groupMember.CommunicationPreference = communicationType;
}
}
else
{
// they are not currently in the Group
if (cbCommunicationListIsSubscribed.Checked)
{
var groupMember = new GroupMember();
groupMember.PersonId = this.CurrentPersonId.Value;
groupMember.GroupId = group.Id;
int?defaultGroupRoleId = GroupTypeCache.Get(group.GroupTypeId).DefaultGroupRoleId;
if (defaultGroupRoleId.HasValue)
{
groupMember.GroupRoleId = defaultGroupRoleId.Value;
}
else
{
nbGroupNotification.Text = "Unable to add to group.";
nbGroupNotification.Details = "Group has no default group role";
nbGroupNotification.NotificationBoxType = NotificationBoxType.Danger;
nbGroupNotification.Visible = true;
}
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
CommunicationType communicationType = tglCommunicationPreference.Checked ? CommunicationType.Email : CommunicationType.SMS;
groupMember.CommunicationPreference = communicationType;
if (groupMember.IsValidGroupMember(rockContext))
{
groupMemberService.Add(groupMember);
rockContext.SaveChanges();
}
else
{
// if the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages
nbGroupNotification.Text = "Unable to add to group.";
nbGroupNotification.Details = groupMember.ValidationResults.Select(a => a.ErrorMessage).ToList().AsDelimited("<br />");
nbGroupNotification.NotificationBoxType = NotificationBoxType.Danger;
nbGroupNotification.Visible = true;
}
}
}
rockContext.SaveChanges();
}
}
/// <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)
{
ClearErrorMessage();
if (Page.IsValid)
{
GroupMemberService groupMemberService = new GroupMemberService();
GroupMember groupMember;
int groupMemberId = int.Parse(hfGroupMemberId.Value);
GroupTypeRole role = new GroupTypeRoleService().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();
//check to see if the person is alread a member of the gorup/role
var existingGroupMember = groupMemberService.GetByGroupIdAndPersonIdAndGroupRoleId(
hfGroupId.ValueAsInt(), ppGroupMemberPerson.SelectedValue ?? 0, ddlGroupRole.SelectedValueAsId() ?? 0);
if (existingGroupMember != null)
{
//if so, don't add and show error message
var person = new PersonService().Get((int)ppGroupMemberPerson.PersonId);
nbErrorMessage.Title = "Person already added";
nbErrorMessage.Text = string.Format("{0} already belongs to the {1} role for this {2}, and cannot be added again with the same role. <a href=\"/page/{3}?groupMemberId={4}\">Click here</a> to view existing membership.",
person.FullName,
ddlGroupRole.SelectedItem.Text,
role.GroupType.GroupTerm,
RockPage.PageId,
existingGroupMember.Id
);
return;
}
}
else
{
//load existing group member
groupMember = groupMemberService.Get(groupMemberId);
}
int memberCountInRole = new GroupMemberService().Queryable()
.Where(m =>
m.GroupId == groupMember.GroupId &&
m.GroupRoleId == role.Id &&
m.GroupMemberStatus == GroupMemberStatus.Active)
.Count();
bool roleMembershipAboveMax = false;
//if adding new active group member
if (groupMemberId.Equals(0) && rblStatus.SelectedValueAsEnum <GroupMemberStatus>() == GroupMemberStatus.Active)
{
// verify that active count has not exceeded the max
if (role.MaxCount != null && (memberCountInRole + 1) > role.MaxCount)
{
roleMembershipAboveMax = true;
}
}
//if existing group member changing role or status
else if (groupMemberId > 0 && (groupMember.GroupRoleId != role.Id || groupMember.GroupMemberStatus != rblStatus.SelectedValueAsEnum <GroupMemberStatus>()) &&
rblStatus.SelectedValueAsEnum <GroupMemberStatus>() == GroupMemberStatus.Active)
{
// verify that active count has not exceeded the max
if (role.MaxCount != null && (memberCountInRole + 1) > role.MaxCount)
{
roleMembershipAboveMax = true;
}
}
//show error if above max.. do not proceed
if (roleMembershipAboveMax)
{
var person = new PersonService().Get((int)ppGroupMemberPerson.PersonId);
nbErrorMessage.Title = string.Format("Maximum {0} Exceeded", role.Name.Pluralize());
nbErrorMessage.Text = string.Format("<br />The number of {0} for this {1} is at or above its maximum allowed limit of {2:N0} active {3}.",
role.Name.Pluralize(), role.GroupType.GroupTerm, role.MaxCount,
role.MaxCount == 1 ? role.GroupType.GroupMemberTerm : role.GroupType.GroupMemberTerm.Pluralize());
return;
}
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;
}
if (!groupMember.IsValid)
{
return;
}
RockTransactionScope.WrapTransaction(() =>
{
if (groupMember.Id.Equals(0))
{
groupMemberService.Add(groupMember, CurrentPersonId);
}
groupMemberService.Save(groupMember, CurrentPersonId);
Rock.Attribute.Helper.SaveAttributeValues(groupMember, CurrentPersonId);
});
Group group = new GroupService().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>
/// Handles the ItemDataBound event of the rptrGroups control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Web.UI.WebControls.RepeaterItemEventArgs"/> instance containing the event data.</param>
protected void rptrGroups_ItemDataBound(object sender, System.Web.UI.WebControls.RepeaterItemEventArgs e)
{
if (e.Item.ItemType == ListItemType.Item || e.Item.ItemType == ListItemType.AlternatingItem)
{
var group = e.Item.DataItem as Group;
if (group != null)
{
HyperLink hlEditGroup = e.Item.FindControl("hlEditGroup") as HyperLink;
if (hlEditGroup != null)
{
hlEditGroup.Visible = _allowEdit;
var pageParams = new Dictionary <string, string>();
pageParams.Add("PersonId", Person.Id.ToString());
pageParams.Add("GroupId", group.Id.ToString());
hlEditGroup.NavigateUrl = LinkedPageUrl("GroupEditPage", pageParams);
}
var lReorderIcon = e.Item.FindControl("lReorderIcon") as Control;
lReorderIcon.Visible = _showReorderIcon;
Repeater rptrMembers = e.Item.FindControl("rptrMembers") as Repeater;
if (rptrMembers != null)
{
// use the _bindGroupsRockContext that is created/disposed in BindFamilies()
var members = new GroupMemberService(_bindGroupsRockContext).Queryable("GroupRole,Person", true)
.Where(m =>
m.GroupId == group.Id &&
m.PersonId != Person.Id)
.OrderBy(m => m.GroupRole.Order)
.ToList();
var groupHeaderLava = GetAttributeValue("GroupHeaderLava");
var groupFooterLava = GetAttributeValue("GroupFooterLava");
if (groupHeaderLava.IsNotNullOrWhiteSpace() || groupFooterLava.IsNotNullOrWhiteSpace())
{
// add header and footer information
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(this.RockPage, CurrentPerson, new Rock.Lava.CommonMergeFieldsOptions {
GetLegacyGlobalMergeFields = false
});
mergeFields.Add("Group", group);
mergeFields.Add("GroupMembers", members);
Literal lGroupHeader = e.Item.FindControl("lGroupHeader") as Literal;
Literal lGroupFooter = e.Item.FindControl("lGroupFooter") as Literal;
lGroupHeader.Text = groupHeaderLava.ResolveMergeFields(mergeFields);
lGroupFooter.Text = groupFooterLava.ResolveMergeFields(mergeFields);
}
var orderedMembers = new List <GroupMember>();
if (_IsFamilyGroupType)
{
// Add adult males
orderedMembers.AddRange(members
.Where(m => m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)) &&
m.Person.Gender == Gender.Male)
.OrderByDescending(m => m.Person.Age));
// Add adult females
orderedMembers.AddRange(members
.Where(m => m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)) &&
m.Person.Gender != Gender.Male)
.OrderByDescending(m => m.Person.Age));
// Add non-adults
orderedMembers.AddRange(members
.Where(m => !m.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_ADULT)))
.OrderByDescending(m => m.Person.Age));
}
else
{
orderedMembers = members
.OrderBy(m => m.GroupRole.Order)
.ThenBy(m => m.Person.LastName)
.ThenBy(m => m.Person.NickName)
.ToList();
}
rptrMembers.ItemDataBound += rptrMembers_ItemDataBound;
rptrMembers.DataSource = orderedMembers;
rptrMembers.DataBind();
}
Repeater rptrAddresses = e.Item.FindControl("rptrAddresses") as Repeater;
if (rptrAddresses != null)
{
rptrAddresses.ItemDataBound += rptrAddresses_ItemDataBound;
rptrAddresses.ItemCommand += rptrAddresses_ItemCommand;
rptrAddresses.DataSource = new GroupLocationService(_bindGroupsRockContext).Queryable("Location,GroupLocationTypeValue")
.Where(l => l.GroupId == group.Id)
.OrderBy(l => l.GroupLocationTypeValue.Order)
.ToList();
rptrAddresses.DataBind();
}
Panel pnlGroupAttributes = e.Item.FindControl("pnlGroupAttributes") as Panel;
HyperLink hlShowMoreAttributes = e.Item.FindControl("hlShowMoreAttributes") as HyperLink;
PlaceHolder phGroupAttributes = e.Item.FindControl("phGroupAttributes") as PlaceHolder;
PlaceHolder phMoreGroupAttributes = e.Item.FindControl("phMoreGroupAttributes") as PlaceHolder;
if (pnlGroupAttributes != null && hlShowMoreAttributes != null && phGroupAttributes != null && phMoreGroupAttributes != null)
{
hlShowMoreAttributes.Visible = false;
phGroupAttributes.Controls.Clear();
phMoreGroupAttributes.Controls.Clear();
group.LoadAttributes();
var attributes = group.GetAuthorizedAttributes(Authorization.VIEW, CurrentPerson)
.Select(a => a.Value)
.OrderBy(a => a.Order)
.ToList();
foreach (var attribute in attributes)
{
if (attribute.IsAuthorized(Authorization.VIEW, CurrentPerson))
{
string value = attribute.DefaultValue;
if (group.AttributeValues.ContainsKey(attribute.Key) && group.AttributeValues[attribute.Key] != null)
{
value = group.AttributeValues[attribute.Key].ValueFormatted;
}
if (!string.IsNullOrWhiteSpace(value))
{
var literalControl = new RockLiteral();
literalControl.ID = string.Format("familyAttribute_{0}", attribute.Id);
literalControl.Label = attribute.Name;
literalControl.Text = value;
var div = new HtmlGenericControl("div");
div.AddCssClass("col-md-3 col-sm-6");
div.Controls.Add(literalControl);
if (attribute.IsGridColumn)
{
phGroupAttributes.Controls.Add(div);
}
else
{
hlShowMoreAttributes.Visible = true;
phMoreGroupAttributes.Controls.Add(div);
}
}
}
}
pnlGroupAttributes.Visible = phGroupAttributes.Controls.Count > 0 || phMoreGroupAttributes.Controls.Count > 0;
}
}
}
}
/// <summary>
/// Binds the groups.
/// </summary>
private void BindGroups()
{
if (Person != null && Person.Id > 0)
{
// If this is a Family GroupType and they belong to multiple families,
// first make sure that the GroupMember.GroupOrder is set for this Person's Families.
// This will ensure that other spots that rely on the GroupOrder provide consistent results.
if (this._IsFamilyGroupType)
{
using (var rockContext = new RockContext())
{
var memberService = new GroupMemberService(rockContext);
var groupMemberGroups = memberService.Queryable(true)
.Where(m =>
m.PersonId == Person.Id &&
m.Group.GroupTypeId == _groupType.Id)
.OrderBy(m => m.GroupOrder ?? int.MaxValue).ThenBy(m => m.Id)
.ToList();
if (groupMemberGroups.Count > 1 && memberService.SetGroupMemberGroupOrder(groupMemberGroups))
{
rockContext.SaveChanges();
}
}
}
// Gind the Groups repeater which will show the Groups with a list of GroupMembers
using (_bindGroupsRockContext = new RockContext())
{
var memberService = new GroupMemberService(_bindGroupsRockContext);
var groups = memberService.Queryable(true)
.Where(m =>
m.PersonId == Person.Id &&
m.Group.GroupTypeId == _groupType.Id)
.OrderBy(m => m.GroupOrder ?? int.MaxValue).ThenBy(m => m.Id)
.Select(m => m.Group)
.AsNoTracking()
.ToList();
if (!groups.Any() && GetAttributeValue("AutoCreateGroup").AsBoolean(true))
{
// ensure that the person is in a group
var groupService = new GroupService(_bindGroupsRockContext);
var group = new Group();
group.Name = Person.LastName;
group.GroupTypeId = _groupType.Id;
groupService.Add(group);
_bindGroupsRockContext.SaveChanges();
var groupMember = new GroupMember();
groupMember.PersonId = Person.Id;
groupMember.GroupRoleId = _groupType.DefaultGroupRoleId.Value;
groupMember.GroupId = group.Id;
group.Members.Add(groupMember);
_bindGroupsRockContext.SaveChanges();
groups.Add(groupService.Get(group.Id));
}
rptrGroups.DataSource = groups;
_showReorderIcon = groups.Count > 1;
rptrGroups.DataBind();
}
}
}
/// <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);
ImportedPeople.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.AliasPersonId == person.Id))
{
person.Aliases.Add(new PersonAlias
{
AliasPersonId = person.Id,
AliasPersonGuid = person.Guid,
ForeignKey = person.ForeignKey,
ForeignId = person.ForeignId
});
}
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>
/// 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(CurrentGroupMemberId);
if (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 = 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();
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()))
{
Role.Flush(group.Id);
}
pnlEditGroupMember.Visible = false;
pnlGroupView.Visible = true;
DisplayViewGroup();
IsEditingGroupMember = false;
}
/// <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;
ReportProgress(0, string.Format("Starting Individual import ({0:N0} already exist).", ImportedPeople.Count(p => p.Members.Any(m => m.Person.ForeignKey != null))));
string[] row;
// Uses a look-ahead enumerator: this call will move to the next record immediately
while ((row = csvData.Database.FirstOrDefault()) != 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 = ImportedPeople.Any(p => p.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.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 = schoolDefinedType.DefinedValues.Any(s => 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 = schoolDefinedType.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 = ImportedPeople.FirstOrDefault(p => p.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++;
}
}
completed++;
if (completed % (ReportingNumber * 10) < 1)
{
ReportProgress(0, string.Format("{0:N0} people imported.", completed));
}
else if (completed % ReportingNumber < 1)
{
SaveIndividuals(newFamilyList, newVisitorList, newNoteList);
lookupContext.SaveChanges();
ReportPartialProgress();
// Clear out variables
currentFamilyGroup = new Group();
newFamilyList.Clear();
newVisitorList.Clear();
newNoteList.Clear();
}
}
}
// Save any changes to new families
if (newFamilyList.Any())
{
SaveIndividuals(newFamilyList, newVisitorList, newNoteList);
}
// Save any changes to existing families
lookupContext.SaveChanges();
lookupContext.Dispose();
ReportProgress(0, string.Format("Finished individual import: {0:N0} families and {1:N0} people added.", newFamilies, completed));
return(completed);
}
/// <summary>
/// Bind the grid to the donations that should be visible for the proper context.
/// </summary>
protected void BindGrid(bool isExporting = false)
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
var financialTransactionDetailService = new FinancialTransactionDetailService(rockContext);
var entityTypeIdGroupMember = EntityTypeCache.GetId <GroupMember>();
var hideGridColumns = GetAttributeValue("HideGridColumns").Split(',');
var hideGridActions = GetAttributeValue("HideGridActions").Split(',');
var mergeFields = LavaHelper.GetCommonMergeFields(RockPage, CurrentPerson);
Group group = null;
Dictionary <int, GroupMember> groupMembers;
//
// Get the donations for the entire opportunity group or for just the
// one individual being viewed.
//
if (ContextEntity <Group>() != null)
{
group = ContextEntity <Group>();
groupMembers = groupMemberService.Queryable()
.Where(m => m.GroupId == group.Id)
.ToDictionary(m => m.Id);
}
else
{
var groupMember = ContextEntity <GroupMember>();
group = groupMember.Group;
groupMembers = new Dictionary <int, GroupMember> {
{ groupMember.Id, groupMember }
};
}
//
// Get the list of donation entries for the grid that match the list of members.
//
var groupMemberIds = groupMembers.Keys.ToList();
var donations = financialTransactionDetailService.Queryable()
.Where(d => d.EntityTypeId == entityTypeIdGroupMember && groupMemberIds.Contains(d.EntityId.Value))
.ToList()
.Select(d => new
{
IsExporting = isExporting,
DonorId = d.Transaction.AuthorizedPersonAlias.PersonId,
Donor = d.Transaction.AuthorizedPersonAlias.Person,
Group = group,
Participant = groupMembers[d.EntityId.Value],
Amount = d.Amount,
Address = d.Transaction.AuthorizedPersonAlias.Person.GetHomeLocation(rockContext).ToStringSafe().ConvertCrLfToHtmlBr(),
Date = d.Transaction.TransactionDateTime
}).AsQueryable();
//
// Apply user sorting or default to donor name.
//
if (gDonations.SortProperty != null)
{
donations = donations.Sort(gDonations.SortProperty);
}
else
{
donations = donations.Sort(new SortProperty {
Property = "Donor.LastName, Donor.NickName"
});
}
gDonations.ObjectList = donations.Select(d => d.Donor)
.DistinctBy(p => p.Id)
.Cast <object>()
.ToDictionary(p => (( Person )p).Id.ToString());
//
// Hide any columns they don't want visible to the user.
//
gDonations.ColumnsOfType <CurrencyField>()
.First(c => c.DataField == "Amount")
.Visible = !hideGridColumns.Contains("Amount");
gDonations.ColumnsOfType <RockBoundField>()
.First(c => c.DataField == "Address")
.Visible = !hideGridColumns.Contains("Donor Address");
gDonations.ColumnsOfType <RockBoundField>()
.First(c => c.DataField == "Donor.Email")
.Visible = !hideGridColumns.Contains("Donor Email");
gDonations.ColumnsOfType <RockLiteralField>()
.First(c => c.HeaderText == "Participant")
.Visible = !hideGridColumns.Contains("Participant") && ContextEntity <GroupMember>() == null;
//
// Hide any grid actions they don't want visible to the user.
//
gDonations.Actions.ShowCommunicate = !hideGridActions.Contains("Communicate");
gDonations.Actions.ShowMergePerson = !hideGridActions.Contains("Merge Person");
gDonations.Actions.ShowBulkUpdate = !hideGridActions.Contains("Bulk Update");
gDonations.Actions.ShowExcelExport = !hideGridActions.Contains("Excel Export");
gDonations.Actions.ShowMergeTemplate = !hideGridActions.Contains("Merge Template");
//
// If all the grid actions are hidden, hide the select column too.
//
gDonations.ColumnsOfType <SelectField>().First().Visible = gDonations.Actions.ShowCommunicate || gDonations.Actions.ShowMergePerson || gDonations.Actions.ShowBulkUpdate || gDonations.Actions.ShowExcelExport || gDonations.Actions.ShowMergeTemplate;
gDonations.DataSource = donations.ToList();
gDonations.DataBind();
}
/// <summary>
/// Bind the grid to the donations that should be visible for the proper context.
/// </summary>
protected void BindGrid()
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
var financialTransactionDetailService = new FinancialTransactionDetailService(rockContext);
var entityTypeIdGroupMember = EntityTypeCache.GetId <GroupMember>();
Dictionary <int, GroupMember> groupMembers;
//
// Get the donations for the entire opportunity group or for just the
// one individual being viewed.
//
if (ContextEntity <Group>() != null)
{
var group = ContextEntity <Group>();
groupMembers = groupMemberService.Queryable()
.Where(m => m.GroupId == group.Id)
.ToDictionary(m => m.Id);
gDonations.Columns.OfType <RockTemplateField>().Where(c => c.HeaderText == "Participant").ToList().ForEach(c => c.Visible = true);
gDonations.Columns.OfType <DateField>().Where(c => c.HeaderText == "Date").ToList().ForEach(c => c.Visible = false);
}
else
{
var groupMember = ContextEntity <GroupMember>();
groupMembers = new Dictionary <int, GroupMember> {
{ groupMember.Id, groupMember }
};
gDonations.Columns.OfType <RockTemplateField>().Where(c => c.HeaderText == "Participant").ToList().ForEach(c => c.Visible = false);
gDonations.Columns.OfType <DateField>().Where(c => c.HeaderText == "Date").ToList().ForEach(c => c.Visible = true);
}
//
// Get the list of donation entries for the grid that match the list of members.
//
var groupMemberIds = groupMembers.Keys.ToList();
var donations = financialTransactionDetailService.Queryable()
.Where(d => d.EntityTypeId == entityTypeIdGroupMember && groupMemberIds.Contains(d.EntityId.Value))
.ToList()
.Select(d => new
{
DonorId = d.Transaction.AuthorizedPersonAlias.PersonId,
Donor = d.Transaction.AuthorizedPersonAlias.Person,
Participant = groupMembers[d.EntityId.Value],
Amount = d.Amount,
Address = d.Transaction.AuthorizedPersonAlias.Person.GetHomeLocation(rockContext).ToStringSafe().ConvertCrLfToHtmlBr(),
Date = d.Transaction.TransactionDateTime
}).AsQueryable();
//
// Apply user sorting or default to donor name.
//
if (gDonations.SortProperty != null)
{
donations = donations.Sort(gDonations.SortProperty);
}
else
{
donations = donations.Sort(new SortProperty {
Property = "Donor.LastName, Donor.NickName"
});
}
gDonations.ObjectList = donations.Select(d => d.Donor)
.DistinctBy(p => p.Id)
.Cast <object>()
.ToDictionary(p => (( Person )p).Id.ToString());
gDonations.DataSource = donations.ToList();
gDonations.DataBind();
}
/// <summary>
/// Handles the SaveClick event of the mdAddContact control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
private void mdAddContact_SaveClick(object sender, EventArgs e)
{
var rockContext = new RockContext();
var personService = new PersonService(rockContext);
var groupService = new GroupService(rockContext);
var groupMemberService = new GroupMemberService(rockContext);
var business = personService.Get(int.Parse(hfBusinessId.Value));
int?contactId = ppContact.PersonId;
if (contactId.HasValue && contactId.Value > 0)
{
// Get the relationship roles to use
var knownRelationshipGroupType = GroupTypeCache.Read(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS.AsGuid());
int businessContactRoleId = knownRelationshipGroupType.Roles
.Where(r =>
r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
int businessRoleId = knownRelationshipGroupType.Roles
.Where(r =>
r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
int ownerRoleId = knownRelationshipGroupType.Roles
.Where(r =>
r.Guid.Equals(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER.AsGuid()))
.Select(r => r.Id)
.FirstOrDefault();
if (ownerRoleId > 0 && businessContactRoleId > 0 && businessRoleId > 0)
{
// get the known relationship group of the business contact
// add the business as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS
var contactKnownRelationshipGroup = groupMemberService.Queryable()
.Where(g =>
g.GroupRoleId == ownerRoleId &&
g.PersonId == contactId.Value)
.Select(g => g.Group)
.FirstOrDefault();
if (contactKnownRelationshipGroup == null)
{
// In some cases person may not yet have a know relationship group type
contactKnownRelationshipGroup = new Group();
groupService.Add(contactKnownRelationshipGroup);
contactKnownRelationshipGroup.Name = "Known Relationship";
contactKnownRelationshipGroup.GroupTypeId = knownRelationshipGroupType.Id;
var ownerMember = new GroupMember();
ownerMember.PersonId = contactId.Value;
ownerMember.GroupRoleId = ownerRoleId;
contactKnownRelationshipGroup.Members.Add(ownerMember);
}
var groupMember = new GroupMember();
groupMember.PersonId = int.Parse(hfBusinessId.Value);
groupMember.GroupRoleId = businessRoleId;
contactKnownRelationshipGroup.Members.Add(groupMember);
// get the known relationship group of the business
// add the business contact as a group member of that group using the group role of GROUPROLE_KNOWN_RELATIONSHIPS_BUSINESS_CONTACT
var businessKnownRelationshipGroup = groupMemberService.Queryable()
.Where(g =>
g.GroupRole.Guid.Equals(new Guid(Rock.SystemGuid.GroupRole.GROUPROLE_KNOWN_RELATIONSHIPS_OWNER)) &&
g.PersonId == business.Id)
.Select(g => g.Group)
.FirstOrDefault();
if (businessKnownRelationshipGroup == null)
{
// In some cases business may not yet have a know relationship group type
businessKnownRelationshipGroup = new Group();
groupService.Add(businessKnownRelationshipGroup);
businessKnownRelationshipGroup.Name = "Known Relationship";
businessKnownRelationshipGroup.GroupTypeId = knownRelationshipGroupType.Id;
var ownerMember = new GroupMember();
ownerMember.PersonId = int.Parse(hfBusinessId.Value);
ownerMember.GroupRoleId = ownerRoleId;
businessKnownRelationshipGroup.Members.Add(ownerMember);
}
var businessGroupMember = new GroupMember();
businessGroupMember.PersonId = contactId.Value;
businessGroupMember.GroupRoleId = businessContactRoleId;
businessKnownRelationshipGroup.Members.Add(businessGroupMember);
rockContext.SaveChanges();
}
}
mdAddContact.Hide();
hfModalOpen.Value = string.Empty;
BindContactListGrid(business);
}
public DataSet GetContributionTransactions(int groupId, int?personId, [FromBody] ContributionStatementOptions options)
{
var qry = Get().Where(a => a.TransactionDateTime >= options.StartDate);
if (options.EndDate.HasValue)
{
qry = qry.Where(a => a.TransactionDateTime < options.EndDate.Value);
}
var transactionTypeContribution = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid());
if (transactionTypeContribution != null)
{
int transactionTypeContributionId = transactionTypeContribution.Id;
qry = qry.Where(a => a.TransactionTypeValueId == transactionTypeContributionId);
}
if (personId.HasValue)
{
// get transactions for a specific person
qry = qry.Where(a => a.AuthorizedPersonAlias.PersonId == personId.Value);
}
else
{
// get transactions for all the persons in the specified group that have specified that group as their GivingGroup
GroupMemberService groupMemberService = new GroupMemberService(( RockContext )Service.Context);
var personIdList = groupMemberService.GetByGroupId(groupId).Where(a => a.Person.GivingGroupId == groupId).Select(s => s.PersonId).ToList();
qry = qry.Where(a => personIdList.Contains(a.AuthorizedPersonAlias.PersonId));
}
if (options.AccountIds != null)
{
qry = qry.Where(a => a.TransactionDetails.Any(x => options.AccountIds.Contains(x.AccountId)));
}
var selectQry = qry.Select(a => new
{
a.TransactionDateTime,
CurrencyTypeValueName = a.FinancialPaymentDetail != null ? a.FinancialPaymentDetail.CurrencyTypeValue.Value : string.Empty,
a.Summary,
Details = a.TransactionDetails.Select(d => new
{
d.AccountId,
AccountName = d.Account.PublicName,
d.Summary,
d.Amount,
AccountOrder = d.Account.Order
}).OrderBy(x => x.AccountOrder),
}).OrderBy(a => a.TransactionDateTime);
DataTable dataTable = new DataTable("contribution_transactions");
dataTable.Columns.Add("TransactionDateTime", typeof(DateTime));
dataTable.Columns.Add("CurrencyTypeValueName");
dataTable.Columns.Add("Summary");
dataTable.Columns.Add("Amount", typeof(decimal));
dataTable.Columns.Add("Details", typeof(DataTable));
var list = selectQry.ToList();
dataTable.BeginLoadData();
foreach (var fieldItems in list)
{
DataTable detailTable = new DataTable("transaction_details");
detailTable.Columns.Add("AccountId", typeof(int));
detailTable.Columns.Add("AccountName");
detailTable.Columns.Add("Summary");
detailTable.Columns.Add("Amount", typeof(decimal));
var transactionDetails = fieldItems.Details.ToList();
// remove any Accounts that were not included (in case there was a mix of included and not included accounts in the transaction)
if (options.AccountIds != null)
{
transactionDetails = transactionDetails.Where(a => options.AccountIds.Contains(a.AccountId)).ToList();
}
foreach (var detail in transactionDetails)
{
var detailArray = new object[] {
detail.AccountId,
detail.AccountName,
detail.Summary,
detail.Amount
};
detailTable.Rows.Add(detailArray);
}
var itemArray = new object[] {
fieldItems.TransactionDateTime,
fieldItems.CurrencyTypeValueName,
fieldItems.Summary,
transactionDetails.Sum(a => a.Amount),
detailTable
};
dataTable.Rows.Add(itemArray);
}
dataTable.EndLoadData();
DataSet dataSet = new DataSet();
dataSet.Tables.Add(dataTable);
return(dataSet);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
var mergeFields = GetMergeFields(action);
var recipients = new List <RockPushMessageRecipient>();
string toValue = GetAttributeValue(action, "To");
Guid guid = toValue.AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
string toAttributeValue = action.GetWorklowAttributeValue(guid);
if (!string.IsNullOrWhiteSpace(toAttributeValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid);
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(a => a.PersonAliasId.HasValue && a.PersonAliasId == personAlias.Id && a.NotificationsEnabled)
.Select(a => a.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (devices.Count == 0)
{
action.AddLogEntry("Invalid Recipient: Person does not have devices that support notifications", true);
}
else
{
var person = new PersonAliasService(rockContext).GetPerson(personAliasGuid);
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
if (person != null)
{
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
case "Rock.Field.Types.GroupFieldType":
case "Rock.Field.Types.SecurityRoleFieldType":
{
int? groupId = toAttributeValue.AsIntegerOrNull();
Guid?groupGuid = toAttributeValue.AsGuidOrNull();
IQueryable <GroupMember> qry = null;
// Handle situations where the attribute value is the ID
if (groupId.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value);
}
// Handle situations where the attribute value stored is the Guid
else if (groupGuid.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value);
}
else
{
action.AddLogEntry("Invalid Recipient: No valid group id or Guid", true);
}
if (qry != null)
{
foreach (var person in qry
.Where(m => m.GroupMemberStatus == GroupMemberStatus.Active)
.Select(m => m.Person))
{
List <string> devices = new PersonalDeviceService(rockContext).Queryable()
.Where(p => p.PersonAliasId.HasValue && p.PersonAliasId == person.PrimaryAliasId && p.NotificationsEnabled)
.Select(p => p.DeviceRegistrationId)
.ToList();
string deviceIds = String.Join(",", devices);
if (deviceIds.AsBoolean())
{
var recipient = new RockPushMessageRecipient(person, deviceIds, mergeFields);
recipients.Add(recipient);
recipient.MergeFields.Add(recipient.PersonMergeFieldKey, person);
}
}
}
break;
}
}
}
}
}
else
{
if (!string.IsNullOrWhiteSpace(toValue))
{
recipients.Add(RockPushMessageRecipient.CreateAnonymous(toValue.ResolveMergeFields(mergeFields), mergeFields));
}
}
string message = GetAttributeValue(action, "Message");
Guid messageGuid = message.AsGuid();
if (!messageGuid.IsEmpty())
{
var attribute = AttributeCache.Get(messageGuid, rockContext);
if (attribute != null)
{
string messageAttributeValue = action.GetWorklowAttributeValue(messageGuid);
if (!string.IsNullOrWhiteSpace(messageAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
message = messageAttributeValue;
}
}
}
}
string title = GetAttributeValue(action, "Title");
Guid titleGuid = title.AsGuid();
if (!titleGuid.IsEmpty())
{
var attribute = AttributeCache.Get(titleGuid, rockContext);
if (attribute != null)
{
string titleAttributeValue = action.GetWorklowAttributeValue(titleGuid);
if (!string.IsNullOrWhiteSpace(titleAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.TextFieldType")
{
title = titleAttributeValue;
}
}
}
}
string sound = GetAttributeValue(action, "Sound");
Guid soundGuid = sound.AsGuid();
if (!soundGuid.IsEmpty())
{
var attribute = AttributeCache.Get(soundGuid, rockContext);
if (attribute != null)
{
string soundAttributeValue = action.GetWorklowAttributeValue(soundGuid);
if (!string.IsNullOrWhiteSpace(soundAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.BooleanFieldType")
{
sound = soundAttributeValue;
}
}
}
}
sound = sound.AsBoolean() ? "default" : "";
if (recipients.Any() && !string.IsNullOrWhiteSpace(message))
{
var pushMessage = new RockPushMessage();
pushMessage.SetRecipients(recipients);
pushMessage.Title = title;
pushMessage.Message = message;
pushMessage.Sound = sound;
pushMessage.Send();
}
return(true);
}
/// <summary>
/// Creates a Linq Expression that can be applied to an IQueryable to filter the result set.
/// </summary>
/// <param name="entityType">The type of entity in the result set.</param>
/// <param name="serviceInstance">A service instance that can be queried to obtain the result set.</param>
/// <param name="parameterExpression">The input parameter that will be injected into the filter expression.</param>
/// <param name="selection">A formatted string representing the filter settings.</param>
/// <returns>
/// A Linq Expression that can be used to filter an IQueryable.
/// </returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var settings = new SelectSettings(selection);
var context = (RockContext)serviceInstance.Context;
//
// Evaluate the Data View that defines the candidate Groups.
//
var dataView = DataComponentSettingsHelper.GetDataViewForFilterComponent(settings.DataViewGuid, context);
var groupService = new GroupService(context);
var groupQuery = groupService.Queryable();
if (dataView != null)
{
groupQuery = DataComponentSettingsHelper.FilterByDataView(groupQuery, dataView, groupService);
}
else
{
// Apply a default Group filter to only show Groups that would be visible in a Group List.
groupQuery = groupQuery.Where(x => x.GroupType.ShowInGroupList);
}
var groupKeys = groupQuery.Select(x => x.Id);
//
// Construct the Query to return the list of Group Members matching the filter conditions.
//
var groupMemberQuery = new GroupMemberService(context).Queryable();
// Filter By Group.
groupMemberQuery = groupMemberQuery.Where(x => groupKeys.Contains(x.GroupId));
// Filter By Group Role Type.
switch (settings.RoleType)
{
case RoleTypeSpecifier.Member:
groupMemberQuery = groupMemberQuery.Where(x => !x.GroupRole.IsLeader);
break;
case RoleTypeSpecifier.Leader:
groupMemberQuery = groupMemberQuery.Where(x => x.GroupRole.IsLeader);
break;
}
// Filter by Group Member Status.
if (settings.MemberStatus.HasValue)
{
groupMemberQuery = groupMemberQuery.Where(x => x.GroupMemberStatus == settings.MemberStatus.Value);
}
//
// Create a Select Expression to return the Person records referenced by the Group Members.
//
var personGroupsQuery = new PersonService(context).Queryable()
.Where(p => groupMemberQuery.Select(gm => gm.PersonId).Contains(p.Id));
var selectExpression = FilterExpressionExtractor.Extract <Model.Person>(personGroupsQuery, parameterExpression, "p");
return(selectExpression);
}
/// <summary>
/// Binds the repeater.
/// </summary>
protected void BindRepeater()
{
if (this.CurrentPersonId == null)
{
return;
}
int communicationListGroupTypeId = GroupTypeCache.Get(Rock.SystemGuid.GroupType.GROUPTYPE_COMMUNICATIONLIST.AsGuid()).Id;
int?communicationListGroupTypeDefaultRoleId = GroupTypeCache.Get(communicationListGroupTypeId).DefaultGroupRoleId;
var rockContext = new RockContext();
var memberOfList = new GroupMemberService(rockContext).GetByPersonId(CurrentPersonId.Value).AsNoTracking().Select(a => a.GroupId).ToList();
// Get a list of syncs for the communication list groups where the default role is sync'd AND the current person is NOT a member of
// This is used to filter out the list of communication lists.
var commGroupSyncsForDefaultRole = new GroupSyncService(rockContext)
.Queryable()
.Where(a => a.Group.GroupTypeId == communicationListGroupTypeId)
.Where(a => a.GroupTypeRoleId == communicationListGroupTypeDefaultRoleId)
.Where(a => !memberOfList.Contains(a.GroupId))
.Select(a => a.GroupId)
.ToList();
var communicationLists = new GroupService(rockContext)
.Queryable()
.Where(a => a.GroupTypeId == communicationListGroupTypeId && !commGroupSyncsForDefaultRole.Contains(a.Id))
.IsActive()
.ToList();
var categoryGuids = this.GetAttributeValue(AttributeKey.CommunicationListCategories).SplitDelimitedValues().AsGuidList();
var viewableCommunicationLists = new List <Group>();
foreach (var communicationList in communicationLists)
{
communicationList.LoadAttributes(rockContext);
if (!categoryGuids.Any())
{
// if no categories where specified, only show lists that the person has VIEW auth
if (communicationList.IsAuthorized(Rock.Security.Authorization.VIEW, this.CurrentPerson))
{
viewableCommunicationLists.Add(communicationList);
}
}
else
{
Guid?categoryGuid = communicationList.GetAttributeValue("Category").AsGuidOrNull();
if (categoryGuid.HasValue && categoryGuids.Contains(categoryGuid.Value))
{
viewableCommunicationLists.Add(communicationList);
}
}
}
viewableCommunicationLists = viewableCommunicationLists.OrderBy(a =>
{
var name = a.GetAttributeValue("PublicName");
if (name.IsNullOrWhiteSpace())
{
name = a.Name;
}
return(name);
}).ToList();
var groupIds = viewableCommunicationLists.Select(a => a.Id).ToList();
var personId = this.CurrentPersonId.Value;
showMediumPreference = this.GetAttributeValue(AttributeKey.ShowMediumPreference).AsBoolean();
personCommunicationListsMember = new GroupMemberService(rockContext)
.Queryable()
.AsNoTracking()
.Where(a => groupIds.Contains(a.GroupId) && a.PersonId == personId)
.GroupBy(a => a.GroupId)
.ToList()
.ToDictionary(k => k.Key, v => v.FirstOrDefault());
rptCommunicationLists.DataSource = viewableCommunicationLists;
rptCommunicationLists.DataBind();
nbNoCommunicationLists.Visible = !viewableCommunicationLists.Any();
pnlCommunicationPreferences.Visible = viewableCommunicationLists.Any();
}
/// <summary>
/// Binds the group members grid.
/// </summary>
protected void ShowDetails()
{
bool existingOccurrence = _occurrence != null;
if (!existingOccurrence && !_allowAdd)
{
nbNotice.Heading = "No Occurrences";
nbNotice.Text = "<p>There are currently not any active occurrences for selected group to take attendance for.</p>";
nbNotice.NotificationBoxType = NotificationBoxType.Warning;
nbNotice.Visible = true;
pnlDetails.Visible = false;
}
else
{
if (existingOccurrence)
{
lOccurrenceDate.Visible = _occurrence.ScheduleId.HasValue;
lOccurrenceDate.Text = _occurrence.Date.ToShortDateString();
dpOccurrenceDate.Visible = !_occurrence.ScheduleId.HasValue;
dpOccurrenceDate.SelectedDate = _occurrence.Date;
if (_occurrence.LocationId.HasValue)
{
lLocation.Visible = true;
lLocation.Text = new LocationService(_rockContext).GetPath(_occurrence.LocationId.Value);
}
else
{
lLocation.Visible = false;
}
ddlLocation.Visible = false;
lSchedule.Visible = !string.IsNullOrWhiteSpace(_occurrence.ScheduleName);
lSchedule.Text = _occurrence.ScheduleName;
ddlSchedule.Visible = false;
}
else
{
lOccurrenceDate.Visible = false;
dpOccurrenceDate.Visible = true;
dpOccurrenceDate.SelectedDate = RockDateTime.Today;
int?locationId = PageParameter("LocationId").AsIntegerOrNull();
if (locationId.HasValue)
{
lLocation.Visible = true;
lLocation.Text = new LocationService(_rockContext).GetPath(locationId.Value);
ddlLocation.Visible = false;
Schedule schedule = null;
int? scheduleId = PageParameter("ScheduleId").AsIntegerOrNull();
if (scheduleId.HasValue)
{
schedule = new ScheduleService(_rockContext).Get(scheduleId.Value);
}
if (schedule != null)
{
lSchedule.Visible = true;
lSchedule.Text = schedule.Name;
ddlSchedule.Visible = false;
}
else
{
BindSchedules(locationId.Value);
lSchedule.Visible = false;
ddlSchedule.Visible = ddlSchedule.Items.Count > 1;
}
}
else
{
lLocation.Visible = false;
ddlLocation.Visible = ddlLocation.Items.Count > 1;
lSchedule.Visible = false;
ddlSchedule.Visible = ddlSchedule.Items.Count > 1;
}
}
lMembers.Text = _group.GroupType.GroupMemberTerm.Pluralize();
lPendingMembers.Text = "Pending " + lMembers.Text;
List <int> attendedIds = new List <int>();
// Load the attendance for the selected occurrence
if (existingOccurrence)
{
cbDidNotMeet.Checked = _occurrence.DidNotOccur;
// Get the list of people who attended
attendedIds = new ScheduleService(_rockContext).GetAttendance(_group, _occurrence)
.Where(a => a.DidAttend.HasValue && a.DidAttend.Value)
.Select(a => a.PersonAlias.PersonId)
.Distinct()
.ToList();
}
ppAddPerson.Visible = GetAttributeValue("AllowAddingPerson").AsBoolean();
// Get the group members
var groupMemberService = new GroupMemberService(_rockContext);
// Add any existing active members not on that list
var unattendedIds = groupMemberService
.Queryable().AsNoTracking()
.Where(m =>
m.GroupId == _group.Id &&
m.GroupMemberStatus == GroupMemberStatus.Active &&
!attendedIds.Contains(m.PersonId))
.Select(m => m.PersonId)
.ToList();
string template = GetAttributeValue("LavaTemplate");
var mergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
// Bind the attendance roster
_attendees = new PersonService(_rockContext)
.Queryable().AsNoTracking()
.Where(p => attendedIds.Contains(p.Id) || unattendedIds.Contains(p.Id))
.ToList()
.Select(p => new GroupAttendanceAttendee()
{
PersonId = p.Id,
NickName = p.NickName,
LastName = p.LastName,
Attended = attendedIds.Contains(p.Id),
CampusIds = p.GetCampusIds(),
MergedTemplate = template.ResolveMergeFields(mergeFields.Union(new Dictionary <string, object>()
{
{ "Person", p }
}).ToDictionary(x => x.Key, x => x.Value))
})
.ToList();
BindAttendees();
// Bind the pending members
var pendingMembers = groupMemberService
.Queryable().AsNoTracking()
.Where(m =>
m.GroupId == _group.Id &&
m.GroupMemberStatus == GroupMemberStatus.Pending)
.OrderBy(m => m.Person.LastName)
.ThenBy(m => m.Person.NickName)
.Select(m => new
{
Id = m.PersonId,
FullName = m.Person.NickName + " " + m.Person.LastName
})
.ToList();
pnlPendingMembers.Visible = pendingMembers.Any();
lvPendingMembers.DataSource = pendingMembers;
lvPendingMembers.DataBind();
}
}
/// <summary>
/// Shows the detail.
/// </summary>
/// <param name="itemKey">The item key.</param>
/// <param name="itemKeyValue">The item key value.</param>
/// <param name="groupId">The group id.</param>
public void ShowDetail(string itemKey, int itemKeyValue, int?groupId)
{
if (!itemKey.Equals("groupMemberId"))
{
return;
}
GroupMember groupMember = null;
if (!itemKeyValue.Equals(0))
{
groupMember = new GroupMemberService().Get(itemKeyValue);
groupMember.LoadAttributes();
}
else
{
// only create a new one if parent was specified
if (groupId.HasValue)
{
groupMember = new GroupMember {
Id = 0
};
groupMember.GroupId = groupId.Value;
groupMember.Group = new GroupService().Get(groupMember.GroupId);
groupMember.GroupRoleId = groupMember.Group.GroupType.DefaultGroupRoleId ?? 0;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
}
}
if (groupMember == null)
{
return;
}
hfGroupId.Value = groupMember.GroupId.ToString();
hfGroupMemberId.Value = groupMember.Id.ToString();
// render UI based on Authorized and IsSystem
bool readOnly = false;
var group = groupMember.Group;
if (!string.IsNullOrWhiteSpace(group.GroupType.IconCssClass))
{
lGroupIconHtml.Text = string.Format("<i class='{0}' ></i>", group.GroupType.IconCssClass);
}
else
{
lGroupIconHtml.Text = string.Empty;
}
if (groupMember.Id.Equals(0))
{
lReadOnlyTitle.Text = ActionTitle.Add(groupMember.Group.GroupType.GroupTerm + " " + groupMember.Group.GroupType.GroupMemberTerm).FormatAsHtmlTitle();
}
else
{
lReadOnlyTitle.Text = groupMember.Person.FullName.FormatAsHtmlTitle();
}
nbEditModeMessage.Text = string.Empty;
if (!IsUserAuthorized("Edit"))
{
readOnly = true;
nbEditModeMessage.Text = EditModeMessage.ReadOnlyEditActionNotAllowed(Group.FriendlyTypeName);
}
if (groupMember.IsSystem)
{
readOnly = true;
nbEditModeMessage.Text = EditModeMessage.ReadOnlySystem(Group.FriendlyTypeName);
}
btnSave.Visible = !readOnly;
LoadDropDowns();
ppGroupMemberPerson.SetValue(groupMember.Person);
ppGroupMemberPerson.Enabled = !readOnly;
ddlGroupRole.SetValue(groupMember.GroupRoleId);
ddlGroupRole.Enabled = !readOnly;
rblStatus.SetValue((int)groupMember.GroupMemberStatus);
rblStatus.Enabled = !readOnly;
groupMember.LoadAttributes();
phAttributes.Controls.Clear();
Rock.Attribute.Helper.AddEditControls(groupMember, phAttributes, true);
if (readOnly)
{
Rock.Attribute.Helper.AddDisplayControls(groupMember, phAttributesReadOnly);
phAttributesReadOnly.Visible = true;
phAttributes.Visible = false;
}
else
{
phAttributesReadOnly.Visible = false;
phAttributes.Visible = true;
}
}
private void BindGrid()
{
string type = PageParameter("SearchType");
string term = PageParameter("SearchTerm");
if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(term))
{
term = term.Trim();
type = type.Trim();
var rockContext = new RockContext();
var personService = new PersonService(rockContext);
IQueryable <Person> people = null;
switch (type.ToLower())
{
case ("name"):
{
bool allowFirstNameOnly = false;
if (!bool.TryParse(PageParameter("AllowFirstNameOnly"), out allowFirstNameOnly))
{
allowFirstNameOnly = false;
}
people = personService.GetByFullName(term, allowFirstNameOnly, true);
break;
}
case ("phone"):
{
var phoneService = new PhoneNumberService(rockContext);
var phoneNumberPersonIds = phoneService.GetPersonIdsByNumber(term);
people = personService.Queryable(new PersonService.PersonQueryOptions {
IncludeNameless = true
}).Where(p => phoneNumberPersonIds.Contains(p.Id));
break;
}
case ("address"):
{
var groupMemberService = new GroupMemberService(rockContext);
var groupMemberPersonIds = groupMemberService.GetPersonIdsByHomeAddress(term);
people = personService.Queryable().Where(p => groupMemberPersonIds.Contains(p.Id));
break;
}
case ("email"):
{
var emailSearchTypeValueId = DefinedValueCache.GetId(Rock.SystemGuid.DefinedValue.PERSON_SEARCH_KEYS_EMAIL.AsGuid());
var searchKeyQry = new PersonSearchKeyService(rockContext).Queryable();
people = personService.Queryable()
.Where(p => (term != "" && p.Email.Contains(term)) ||
searchKeyQry.Any(a => emailSearchTypeValueId.HasValue &&
a.SearchTypeValueId == emailSearchTypeValueId.Value &&
a.PersonAlias.PersonId == p.Id &&
a.SearchValue.Contains(term)));
break;
}
case ("birthdate"):
{
DateTime?birthDate = Request.QueryString["birthdate"].AsDateTime();
int? personId = Request.QueryString["person-id"].AsIntegerOrNull();
if (birthDate == null)
{
birthDate = term.AsDateTime();
}
if (personId.HasValue)
{
people = personService.Queryable().Where(a => a.Id == personId.Value);
}
else
{
people = personService.Queryable().Where(p => p.BirthDate.HasValue && birthDate.HasValue && p.BirthDate == birthDate.Value);
}
break;
}
}
IEnumerable <int> personIdList = people.Select(p => p.Id);
// just leave the personIdList as a Queryable if it is over 10000 so that we don't throw a SQL exception due to the big list of ids
if (people.Count() < 10000)
{
personIdList = personIdList.ToList();
}
if (personIdList.Count() == 1)
{
// if there is exactly one result, just redirect to the person page
int personId = personIdList.First();
Response.Redirect(string.Format("~/Person/{0}", personId), false);
Context.ApplicationInstance.CompleteRequest();
return;
}
// since there is not exactly one person found, show the list of people in the grid
var familyGroupType = GroupTypeCache.GetFamilyGroupType();
int familyGroupTypeId = familyGroupType != null ? familyGroupType.Id : 0;
var groupLocationTypeHome = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME.AsGuid());
int homeAddressTypeId = groupLocationTypeHome != null ? groupLocationTypeHome.Id : 0;
var birthDateCol = gPeople.ColumnsOfType <DateField>().First(c => c.DataField == "BirthDate");
var ageCol = gPeople.ColumnsOfType <RockBoundField>().First(c => c.DataField == "Age");
var genderCol = gPeople.ColumnsOfType <RockBoundField>().First(c => c.DataField == "Gender");
var envelopeNumberField = gPeople.ColumnsOfType <RockLiteralField>().First(c => c.ID == "lEnvelopeNumber");
var spouseCol = gPeople.ColumnsOfType <RockTemplateField>().First(c => c.HeaderText == "Spouse");
var personGivingEnvelopeAttribute = AttributeCache.Get(Rock.SystemGuid.Attribute.PERSON_GIVING_ENVELOPE_NUMBER.AsGuid());
if (personGivingEnvelopeAttribute != null)
{
envelopeNumberField.Visible = GlobalAttributesCache.Get().EnableGivingEnvelopeNumber&& this.GetAttributeValue(AttributeKey.ShowEnvelopeNumber).AsBoolean();
}
else
{
envelopeNumberField.Visible = false;
}
birthDateCol.Visible = GetAttributeValue(AttributeKey.ShowBirthdate).AsBoolean();
ageCol.Visible = GetAttributeValue(AttributeKey.ShowAge).AsBoolean();
genderCol.Visible = GetAttributeValue(AttributeKey.ShowGender).AsBoolean();
spouseCol.Visible = _showSpouse;
people = personService.Queryable(true).Where(p => personIdList.Contains(p.Id));
SortProperty sortProperty = gPeople.SortProperty;
if (sortProperty != null)
{
people = people.Sort(sortProperty);
}
else
{
people = people.OrderBy(p => p.LastName).ThenBy(p => p.FirstName);
}
var personList = people.Select(p => new PersonSearchResult
{
Id = p.Id,
FirstName = p.FirstName,
NickName = p.NickName,
LastName = p.LastName,
BirthDate = p.BirthDate,
DeceasedDate = p.DeceasedDate,
BirthYear = p.BirthYear,
BirthMonth = p.BirthMonth,
BirthDay = p.BirthDay,
ConnectionStatusValueId = p.ConnectionStatusValueId,
RecordStatusValueId = p.RecordStatusValueId,
RecordTypeValueId = p.RecordTypeValueId,
AgeClassification = p.AgeClassification,
SuffixValueId = p.SuffixValueId,
IsDeceased = p.IsDeceased,
Email = p.Email,
Gender = p.Gender,
PhotoId = p.PhotoId,
CampusIds = p.Members
.Where(m =>
m.Group.GroupTypeId == familyGroupTypeId &&
m.Group.CampusId.HasValue)
.Select(m => m.Group.CampusId.Value)
.ToList(),
HomeAddresses = p.Members
.Where(m => m.Group.GroupTypeId == familyGroupTypeId)
.SelectMany(m => m.Group.GroupLocations)
.Where(gl => gl.GroupLocationTypeValueId == homeAddressTypeId)
.Select(gl => gl.Location),
PhoneNumbers = p.PhoneNumbers
.Where(n => n.NumberTypeValueId.HasValue)
.Select(n => new PersonSearchResultPhone
{
NumberTypeValueId = n.NumberTypeValueId.Value,
Number = n.NumberFormatted,
PhoneTypeName = n.NumberTypeValue.Value
})
.ToList(),
TopSignalColor = p.TopSignalColor,
TopSignalIconCssClass = p.TopSignalIconCssClass
}).ToList();
if (type.ToLower() == "name")
{
var similarNames = personService.GetSimilarNames(term,
personList.Select(p => p.Id).ToList(), true);
if (similarNames.Any())
{
var hyperlinks = new List <string>();
foreach (string name in similarNames.Distinct())
{
var pageRef = CurrentPageReference;
pageRef.Parameters["SearchTerm"] = name;
hyperlinks.Add(string.Format("<a href='{0}'>{1}</a>", pageRef.BuildUrl(), name));
}
string altNames = string.Join(", ", hyperlinks);
nbNotice.Text = string.Format("Other Possible Matches: {0}", altNames);
nbNotice.Visible = true;
}
}
_inactiveStatus = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE);
var personIds = personList.Select(a => a.Id).ToList();
if (envelopeNumberField != null && envelopeNumberField.Visible)
{
_envelopeNumbers = new AttributeValueService(rockContext).Queryable()
.Where(a => a.AttributeId == personGivingEnvelopeAttribute.Id)
.Where(a => personIds.Contains(a.EntityId.Value))
.Select(a => new
{
PersonId = a.EntityId.Value,
Value = a.Value
}).ToList().ToDictionary(k => k.PersonId, v => v.Value);
}
gPeople.EntityTypeId = EntityTypeCache.GetId <Person>();
gPeople.DataSource = personList;
gPeople.DataBind();
}
}
private void CreateControls(bool setSelection)
{
// Load all the attribute controls
attributeControls.Clear();
pnlAttributes.Controls.Clear();
phDuplicates.Controls.Clear();
var rockContext = new RockContext();
var attributeService = new AttributeService(rockContext);
var locationService = new LocationService(rockContext);
foreach (string categoryGuid in GetAttributeValue("AttributeCategories").SplitDelimitedValues(false))
{
Guid guid = Guid.Empty;
if (Guid.TryParse(categoryGuid, out guid))
{
var category = CategoryCache.Read(guid);
if (category != null)
{
var attributeControl = new NewGroupAttributes();
attributeControl.ClearRows();
pnlAttributes.Controls.Add(attributeControl);
attributeControls.Add(attributeControl);
attributeControl.ID = "groupAttributes_" + category.Id.ToString();
attributeControl.CategoryId = category.Id;
foreach (var attribute in attributeService.GetByCategoryId(category.Id))
{
if (attribute.IsAuthorized(Authorization.EDIT, CurrentPerson))
{
attributeControl.AttributeList.Add(AttributeCache.Read(attribute));
}
}
}
}
}
nfmMembers.ClearRows();
nfciContactInfo.ClearRows();
var groupMemberService = new GroupMemberService(rockContext);
int defaultRoleId = _groupType.DefaultGroupRoleId ?? _groupType.Roles.Select(r => r.Id).FirstOrDefault();
var location = new Location();
acAddress.GetValues(location);
foreach (var groupMember in GroupMembers)
{
string groupMemberGuidString = groupMember.Person.Guid.ToString().Replace("-", "_");
var groupMemberRow = new NewGroupMembersRow();
groupMemberRow.GroupTypeId = _groupType.Id;
nfmMembers.Controls.Add(groupMemberRow);
groupMemberRow.ID = string.Format("row_{0}", groupMemberGuidString);
groupMemberRow.RoleUpdated += groupMemberRow_RoleUpdated;
groupMemberRow.DeleteClick += groupMemberRow_DeleteClick;
groupMemberRow.PersonGuid = groupMember.Person.Guid;
groupMemberRow.RequireGender = nfmMembers.RequireGender;
groupMemberRow.RequireGrade = nfmMembers.RequireGrade;
groupMemberRow.RoleId = groupMember.GroupRoleId;
groupMemberRow.ShowGradeColumn = _isFamilyGroupType;
groupMemberRow.ShowGradePicker = groupMember.GroupRoleId == _childRoleId;
groupMemberRow.ValidationGroup = BlockValidationGroup;
var contactInfoRow = new NewGroupContactInfoRow();
nfciContactInfo.Controls.Add(contactInfoRow);
contactInfoRow.ID = string.Format("ci_row_{0}", groupMemberGuidString);
contactInfoRow.PersonGuid = groupMember.Person.Guid;
contactInfoRow.IsMessagingEnabled = _SMSEnabled;
contactInfoRow.PersonName = groupMember.Person.FullName;
if (_homePhone != null)
{
var homePhoneNumber = groupMember.Person.PhoneNumbers.Where(p => p.NumberTypeValueId == _homePhone.Id).FirstOrDefault();
if (homePhoneNumber != null)
{
contactInfoRow.HomePhoneNumber = PhoneNumber.FormattedNumber(homePhoneNumber.CountryCode, homePhoneNumber.Number);
contactInfoRow.HomePhoneCountryCode = homePhoneNumber.CountryCode;
}
else
{
contactInfoRow.HomePhoneNumber = string.Empty;
contactInfoRow.HomePhoneCountryCode = string.Empty;
}
}
if (_cellPhone != null)
{
var cellPhoneNumber = groupMember.Person.PhoneNumbers.Where(p => p.NumberTypeValueId == _cellPhone.Id).FirstOrDefault();
if (cellPhoneNumber != null)
{
contactInfoRow.CellPhoneNumber = PhoneNumber.FormattedNumber(cellPhoneNumber.CountryCode, cellPhoneNumber.Number);
contactInfoRow.CellPhoneCountryCode = cellPhoneNumber.CountryCode;
}
else
{
contactInfoRow.CellPhoneNumber = string.Empty;
contactInfoRow.CellPhoneCountryCode = string.Empty;
}
}
contactInfoRow.Email = groupMember.Person.Email;
if (setSelection)
{
if (groupMember.Person != null)
{
groupMemberRow.TitleValueId = groupMember.Person.TitleValueId;
groupMemberRow.FirstName = groupMember.Person.FirstName;
groupMemberRow.LastName = groupMember.Person.LastName;
groupMemberRow.SuffixValueId = groupMember.Person.SuffixValueId;
groupMemberRow.Gender = groupMember.Person.Gender;
groupMemberRow.BirthDate = groupMember.Person.BirthDate;
groupMemberRow.ConnectionStatusValueId = groupMember.Person.ConnectionStatusValueId;
groupMemberRow.GradeOffset = groupMember.Person.GradeOffset;
}
}
foreach (var attributeControl in attributeControls)
{
var attributeRow = new NewGroupAttributesRow();
attributeControl.Controls.Add(attributeRow);
attributeRow.ID = string.Format("{0}_{1}", attributeControl.ID, groupMemberGuidString);
attributeRow.AttributeList = attributeControl.AttributeList;
attributeRow.PersonGuid = groupMember.Person.Guid;
attributeRow.PersonName = groupMember.Person.FullName;
if (setSelection)
{
attributeRow.SetEditValues(groupMember.Person);
}
}
if (Duplicates.ContainsKey(groupMember.Person.Guid))
{
var dupRow = new HtmlGenericControl("div");
dupRow.AddCssClass("row");
dupRow.ID = string.Format("dupRow_{0}", groupMemberGuidString);
phDuplicates.Controls.Add(dupRow);
var newPersonCol = new HtmlGenericControl("div");
newPersonCol.AddCssClass("col-md-6");
newPersonCol.ID = string.Format("newPersonCol_{0}", groupMemberGuidString);
dupRow.Controls.Add(newPersonCol);
newPersonCol.Controls.Add(PersonHtmlPanel(
groupMemberGuidString,
groupMember.Person,
groupMember.GroupRole,
location,
rockContext));
LinkButton lbRemoveMember = new LinkButton();
lbRemoveMember.ID = string.Format("lbRemoveMember_{0}", groupMemberGuidString);
lbRemoveMember.AddCssClass("btn btn-danger btn-xs");
lbRemoveMember.Text = "Remove";
lbRemoveMember.Click += lbRemoveMember_Click;
newPersonCol.Controls.Add(lbRemoveMember);
var dupPersonCol = new HtmlGenericControl("div");
dupPersonCol.AddCssClass("col-md-6");
dupPersonCol.ID = string.Format("dupPersonCol_{0}", groupMemberGuidString);
dupRow.Controls.Add(dupPersonCol);
var duplicateHeader = new HtmlGenericControl("h4");
duplicateHeader.InnerText = "Possible Duplicate Records";
dupPersonCol.Controls.Add(duplicateHeader);
foreach (var duplicate in Duplicates[groupMember.Person.Guid])
{
GroupTypeRole groupTypeRole = null;
Location duplocation = null;
var dupGroupMember = groupMemberService.Queryable()
.Where(a => a.PersonId == duplicate.Id)
.Where(a => a.Group.GroupTypeId == _groupType.Id)
.Select(s => new
{
s.GroupRole,
GroupLocation = s.Group.GroupLocations.Where(a => a.GroupLocationTypeValue.Guid.Equals(_locationType.Guid)).Select(a => a.Location).FirstOrDefault()
})
.FirstOrDefault();
if (dupGroupMember != null)
{
groupTypeRole = dupGroupMember.GroupRole;
duplocation = dupGroupMember.GroupLocation;
}
dupPersonCol.Controls.Add(PersonHtmlPanel(
groupMemberGuidString,
duplicate,
groupTypeRole,
duplocation,
rockContext));
}
}
}
ShowPage();
}
private void BindGrid()
{
string type = PageParameter("SearchType");
string term = PageParameter("SearchTerm");
if (!string.IsNullOrWhiteSpace(type) && !string.IsNullOrWhiteSpace(term))
{
term = term.Trim();
type = type.Trim();
var rockContext = new RockContext();
var personService = new PersonService(rockContext);
IQueryable <Person> people = null;
switch (type.ToLower())
{
case ("name"):
{
bool allowFirstNameOnly = false;
if (!bool.TryParse(PageParameter("allowFirstNameOnly"), out allowFirstNameOnly))
{
allowFirstNameOnly = false;
}
people = personService.GetByFullName(term, allowFirstNameOnly, true);
break;
}
case ("phone"):
{
var phoneService = new PhoneNumberService(rockContext);
var personIds = phoneService.GetPersonIdsByNumber(term);
people = personService.Queryable().Where(p => personIds.Contains(p.Id));
break;
}
case ("address"):
{
var groupMemberService = new GroupMemberService(rockContext);
var personIds2 = groupMemberService.GetPersonIdsByHomeAddress(term);
people = personService.Queryable().Where(p => personIds2.Contains(p.Id));
break;
}
case ("email"):
{
people = personService.Queryable().Where(p => p.Email.Contains(term));
break;
}
}
SortProperty sortProperty = gPeople.SortProperty;
if (sortProperty != null)
{
people = people.Sort(sortProperty);
}
else
{
people = people.OrderBy(p => p.LastName).ThenBy(p => p.FirstName);
}
Guid familyGuid = new Guid(Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY);
Guid homeAddressTypeGuid = new Guid(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME);
var personList = people.Select(p => new PersonSearchResult
{
Id = p.Id,
FirstName = p.FirstName,
NickName = p.NickName,
LastName = p.LastName,
BirthDate = p.BirthDate,
BirthYear = p.BirthYear,
BirthMonth = p.BirthMonth,
BirthDay = p.BirthDay,
ConnectionStatusValueId = p.ConnectionStatusValueId,
RecordStatusValueId = p.RecordStatusValueId,
RecordTypeValueId = p.RecordTypeValueId,
SuffixValueId = p.SuffixValueId,
IsDeceased = p.IsDeceased,
Email = p.Email,
Gender = p.Gender,
PhotoId = p.PhotoId,
CampusIds = p.Members
.Where(m =>
m.Group.GroupType.Guid.Equals(familyGuid) &&
m.Group.CampusId.HasValue)
.Select(m => m.Group.CampusId.Value)
.ToList(),
HomeAddresses = p.Members
.Where(m => m.Group.GroupType.Guid == familyGuid)
.SelectMany(m => m.Group.GroupLocations)
.Where(gl => gl.GroupLocationTypeValue.Guid.Equals(homeAddressTypeGuid))
.Select(gl => gl.Location)
}).ToList();
if (personList.Count == 1)
{
Response.Redirect(string.Format("~/Person/{0}", personList[0].Id), false);
Context.ApplicationInstance.CompleteRequest();
}
else
{
if (type.ToLower() == "name")
{
var similiarNames = personService.GetSimiliarNames(term,
personList.Select(p => p.Id).ToList(), true);
if (similiarNames.Any())
{
var hyperlinks = new List <string>();
foreach (string name in similiarNames.Distinct())
{
var pageRef = CurrentPageReference;
pageRef.Parameters["SearchTerm"] = name;
hyperlinks.Add(string.Format("<a href='{0}'>{1}</a>", pageRef.BuildUrl(), name));
}
string altNames = string.Join(", ", hyperlinks);
nbNotice.Text = string.Format("Other Possible Matches: {0}", altNames);
nbNotice.Visible = true;
}
}
_inactiveStatus = DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.PERSON_RECORD_STATUS_INACTIVE);
gPeople.EntityTypeId = EntityTypeCache.GetId <Person>();
gPeople.DataSource = personList;
gPeople.DataBind();
}
}
}
/// <summary>
/// Gets the merge object list for the current EntitySet
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="fetchCount">The fetch count.</param>
/// <returns></returns>
private List <object> GetMergeObjectList(RockContext rockContext, int?fetchCount = null)
{
int entitySetId = hfEntitySetId.Value.AsInteger();
var entitySetService = new EntitySetService(rockContext);
var entitySet = entitySetService.Get(entitySetId);
Dictionary <int, object> mergeObjectsDictionary = new Dictionary <int, object>();
// If this EntitySet contains IEntity Items, add those first
if (entitySet.EntityTypeId.HasValue)
{
var qryEntity = entitySetService.GetEntityQuery(entitySetId);
if (fetchCount.HasValue)
{
qryEntity = qryEntity.Take(fetchCount.Value);
}
var entityTypeCache = EntityTypeCache.Read(entitySet.EntityTypeId.Value);
bool isPersonEntityType = entityTypeCache != null && entityTypeCache.Guid == Rock.SystemGuid.EntityType.PERSON.AsGuid();
bool isGroupMemberEntityType = entityTypeCache != null && entityTypeCache.Guid == Rock.SystemGuid.EntityType.GROUP_MEMBER.AsGuid();
bool combineFamilyMembers = cbCombineFamilyMembers.Visible && cbCombineFamilyMembers.Checked;
if ((isGroupMemberEntityType || isPersonEntityType) && combineFamilyMembers)
{
IQueryable <IEntity> qryPersons;
if (isGroupMemberEntityType)
{
qryPersons = qryEntity.OfType <GroupMember>().Select(a => a.Person).Distinct();
}
else
{
qryPersons = qryEntity;
}
Guid familyGroupType = Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY.AsGuid();
var qryFamilyGroupMembers = new GroupMemberService(rockContext).Queryable()
.Where(a => a.Group.GroupType.Guid == familyGroupType)
.Where(a => qryPersons.Any(aa => aa.Id == a.PersonId));
var qryCombined = qryFamilyGroupMembers.Join(
qryPersons,
m => m.PersonId,
p => p.Id,
(m, p) => new { GroupMember = m, Person = p })
.GroupBy(a => a.GroupMember.GroupId)
.Select(x => new
{
GroupId = x.Key,
Persons = x.Select(xx => xx.Person).Distinct()
});
foreach (var combinedFamilyItem in qryCombined)
{
object mergeObject;
string commaPersonIds = combinedFamilyItem.Persons.Select(a => a.Id).Distinct().ToList().AsDelimited(",");
var primaryGroupPerson = combinedFamilyItem.Persons.FirstOrDefault() as Person;
if (mergeObjectsDictionary.ContainsKey(primaryGroupPerson.Id))
{
foreach (var person in combinedFamilyItem.Persons)
{
if (!mergeObjectsDictionary.ContainsKey(person.Id))
{
primaryGroupPerson = person as Person;
break;
}
}
}
// if we are combining from a GroupMemberEntityType list add the GroupMember attributes of the primary person in the combined list
if (isGroupMemberEntityType)
{
var groupMember = qryEntity.OfType <GroupMember>().Where(a => a.PersonId == primaryGroupPerson.Id).FirstOrDefault();
primaryGroupPerson.AdditionalLavaFields = primaryGroupPerson.AdditionalLavaFields ?? new Dictionary <string, object>();
if (groupMember != null)
{
primaryGroupPerson.AdditionalLavaFields.AddOrIgnore("GroupMember", groupMember);
}
}
if (combinedFamilyItem.Persons.Count() > 1)
{
var combinedPerson = primaryGroupPerson.ToJson().FromJsonOrNull <MergeTemplateCombinedPerson>();
var familyTitle = RockUdfHelper.ufnCrm_GetFamilyTitle(rockContext, null, combinedFamilyItem.GroupId, commaPersonIds, true);
combinedPerson.FullName = familyTitle;
var firstNameList = combinedFamilyItem.Persons.Select(a => (a as Person).FirstName).ToList();
var nickNameList = combinedFamilyItem.Persons.Select(a => (a as Person).NickName).ToList();
combinedPerson.FirstName = firstNameList.AsDelimited(", ", " & ");
combinedPerson.NickName = nickNameList.AsDelimited(", ", " & ");
combinedPerson.LastName = primaryGroupPerson.LastName;
combinedPerson.SuffixValueId = null;
combinedPerson.SuffixValue = null;
mergeObject = combinedPerson;
}
else
{
mergeObject = primaryGroupPerson;
}
mergeObjectsDictionary.AddOrIgnore(primaryGroupPerson.Id, mergeObject);
}
}
else if (isGroupMemberEntityType)
{
foreach (var groupMember in qryEntity.AsNoTracking().OfType <GroupMember>())
{
var person = groupMember.Person;
person.AdditionalLavaFields = new Dictionary <string, object>();
person.AdditionalLavaFields.Add("GroupMember", groupMember);
mergeObjectsDictionary.AddOrIgnore(groupMember.PersonId, person);
}
}
else
{
foreach (var item in qryEntity.AsNoTracking())
{
mergeObjectsDictionary.AddOrIgnore(item.Id, item);
}
}
}
var entitySetItemService = new EntitySetItemService(rockContext);
string[] emptyJson = new string[] { string.Empty, "{}" };
var entitySetItemMergeValuesQry = entitySetItemService.GetByEntitySetId(entitySetId, true).Where(a => !emptyJson.Contains(a.AdditionalMergeValuesJson));
if (fetchCount.HasValue)
{
entitySetItemMergeValuesQry = entitySetItemMergeValuesQry.Take(fetchCount.Value);
}
// the entityId to use for NonEntity objects
int nonEntityId = 1;
// now, add the additional MergeValues regardless of if the EntitySet contains IEntity items or just Non-IEntity items
foreach (var additionalMergeValuesItem in entitySetItemMergeValuesQry.AsNoTracking())
{
object mergeObject;
int entityId;
if (additionalMergeValuesItem.EntityId > 0)
{
entityId = additionalMergeValuesItem.EntityId;
}
else
{
// not pointing to an actual EntityId, so use the nonEntityId for ti
entityId = nonEntityId++;
}
if (mergeObjectsDictionary.ContainsKey(entityId))
{
mergeObject = mergeObjectsDictionary[entityId];
}
else
{
if (entitySet.EntityTypeId.HasValue)
{
// if already have real entities in our list, don't add additional items to the mergeObjectsDictionary
continue;
}
// non-Entity merge object, so just use Dictionary
mergeObject = new Dictionary <string, object>();
mergeObjectsDictionary.AddOrIgnore(entityId, mergeObject);
}
foreach (var additionalMergeValue in additionalMergeValuesItem.AdditionalMergeValues)
{
if (mergeObject is IEntity)
{
// add the additional fields to AdditionalLavaFields
IEntity mergeEntity = (mergeObject as IEntity);
mergeEntity.AdditionalLavaFields = mergeEntity.AdditionalLavaFields ?? new Dictionary <string, object>();
object mergeValueObject = additionalMergeValue.Value;
// if the mergeValueObject is a JArray (JSON Object), convert it into an ExpandoObject or List<ExpandoObject> so that Lava will work on it
if (mergeValueObject is JArray)
{
var jsonOfObject = mergeValueObject.ToJson();
try
{
mergeValueObject = Rock.Lava.RockFilters.FromJSON(jsonOfObject);
}
catch (Exception ex)
{
LogException(new Exception("MergeTemplateEntry couldn't do a FromJSON", ex));
}
}
mergeEntity.AdditionalLavaFields.AddOrIgnore(additionalMergeValue.Key, mergeValueObject);
}
else if (mergeObject is IDictionary <string, object> )
{
// anonymous object with no fields yet
IDictionary <string, object> nonEntityObject = mergeObject as IDictionary <string, object>;
nonEntityObject.AddOrIgnore(additionalMergeValue.Key, additionalMergeValue.Value);
}
else
{
throw new Exception(string.Format("Unexpected MergeObject Type: {0}", mergeObject));
}
}
}
var result = mergeObjectsDictionary.Select(a => a.Value);
if (fetchCount.HasValue)
{
// make sure the result is limited to fetchCount (even though the above queries are also limited to fetch count)
result = result.Take(fetchCount.Value);
}
return(result.ToList());
}
/// <summary>
/// Binds the data.
/// </summary>
private void BindData()
{
ShowRole = GetAttributeValue("ShowRole").AsBoolean();
if (person != null && person.Id > 0)
{
if (ownerRoleGuid != Guid.Empty)
{
using (var rockContext = new RockContext())
{
var memberService = new GroupMemberService(rockContext);
var group = memberService.Queryable(true)
.Where(m =>
m.PersonId == person.Id &&
m.GroupRole.Guid == ownerRoleGuid)
.Select(m => m.Group)
.FirstOrDefault();
if (group != null)
{
lGroupName.Text = group.Name.Pluralize();
lGroupTypeIcon.Text = string.Format("<i class='{0}'></i>", group.GroupType.IconCssClass);
lGroupTypeIcon.Visible = !string.IsNullOrWhiteSpace(group.GroupType.IconCssClass);
if (group.IsAuthorized(Authorization.VIEW, CurrentPerson))
{
int?maxRelationshipsToDisplay = this.GetAttributeValue("MaxRelationshipsToDisplay").AsIntegerOrNull();
var roles = new List <int>();
if (canCheckInOnly)
{
foreach (var role in new GroupTypeRoleService(rockContext)
.Queryable().AsNoTracking()
.Where(r => r.GroupType.Guid.Equals(new Guid(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS))))
{
role.LoadAttributes(rockContext);
if (role.Attributes.ContainsKey("CanCheckin"))
{
bool canCheckIn = false;
if (bool.TryParse(role.GetAttributeValue("CanCheckin"), out canCheckIn) && canCheckIn)
{
roles.Add(role.Id);
}
}
if (role.Attributes.ContainsKey("InverseRelationship"))
{
var inverseRoleGuid = role.GetAttributeValue("InverseRelationship").AsGuidOrNull();
if (inverseRoleGuid != null)
{
var groupTypeRole = new GroupTypeRoleService(rockContext)
.Queryable().AsNoTracking()
.FirstOrDefault(r => r.Guid.Equals(( Guid )inverseRoleGuid));
if (groupTypeRole != null)
{
groupTypeRole.LoadAttributes(rockContext);
if (groupTypeRole.Attributes.ContainsKey("CanCheckin"))
{
bool canCheckIn = false;
if (bool.TryParse(groupTypeRole.GetAttributeValue("CanCheckin"), out canCheckIn) && canCheckIn)
{
roles.Add(role.Id);
}
}
}
}
}
}
}
else
{
foreach (var role in new GroupTypeRoleService(rockContext)
.Queryable().AsNoTracking()
.Where(r => r.GroupType.Guid.Equals(new Guid(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS))))
{
roles.Add(role.Id);
}
}
IQueryable <GroupMember> qryGroupMembers = new GroupMemberService(rockContext).GetByGroupId(group.Id, true)
.Where(m => m.PersonId != person.Id)
.Where(m => roles.Contains(m.GroupRoleId))
.OrderBy(m => m.Person.LastName)
.ThenBy(m => m.Person.FirstName);
if (maxRelationshipsToDisplay.HasValue)
{
qryGroupMembers = qryGroupMembers.Take(maxRelationshipsToDisplay.Value);
}
rGroupMembers.ItemDataBound += rptrMembers_ItemDataBound;
rGroupMembers.DataSource = qryGroupMembers.ToList();
rGroupMembers.DataBind();
}
else
{
lAccessWarning.Text = string.Format("<div class='alert alert-info'>You do not have security rights to view {0}.", group.Name.Pluralize());
}
}
}
}
}
}
/// <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 (RegistrantState != null)
{
RockContext rockContext = new RockContext();
var personService = new PersonService(rockContext);
var registrantService = new RegistrationRegistrantService(rockContext);
var registrantFeeService = new RegistrationRegistrantFeeService(rockContext);
var registrationTemplateFeeService = new RegistrationTemplateFeeService(rockContext);
RegistrationRegistrant registrant = null;
if (RegistrantState.Id > 0)
{
registrant = registrantService.Get(RegistrantState.Id);
}
bool newRegistrant = false;
var registrantChanges = new List <string>();
if (registrant == null)
{
newRegistrant = true;
registrant = new RegistrationRegistrant();
registrant.RegistrationId = RegistrantState.RegistrationId;
registrantService.Add(registrant);
registrantChanges.Add("Created Registrant");
}
if (!registrant.PersonAliasId.Equals(ppPerson.PersonAliasId))
{
string prevPerson = (registrant.PersonAlias != null && registrant.PersonAlias.Person != null) ?
registrant.PersonAlias.Person.FullName : string.Empty;
string newPerson = ppPerson.PersonName;
History.EvaluateChange(registrantChanges, "Person", prevPerson, newPerson);
}
int?personId = ppPerson.PersonId.Value;
registrant.PersonAliasId = ppPerson.PersonAliasId.Value;
// Get the name of registrant for history
string registrantName = "Unknown";
if (ppPerson.PersonId.HasValue)
{
var person = personService.Get(ppPerson.PersonId.Value);
if (person != null)
{
registrantName = person.FullName;
}
}
History.EvaluateChange(registrantChanges, "Cost", registrant.Cost, cbCost.Text.AsDecimal());
registrant.Cost = cbCost.Text.AsDecimal();
if (!Page.IsValid)
{
return;
}
// Remove/delete any registrant fees that are no longer in UI with quantity
foreach (var dbFee in registrant.Fees.ToList())
{
if (!RegistrantState.FeeValues.Keys.Contains(dbFee.RegistrationTemplateFeeId) ||
RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId] == null ||
!RegistrantState.FeeValues[dbFee.RegistrationTemplateFeeId]
.Any(f =>
f.Option == dbFee.Option &&
f.Quantity > 0))
{
registrantChanges.Add(string.Format("Removed '{0}' Fee (Quantity:{1:N0}, Cost:{2:C2}, Option:{3}",
dbFee.RegistrationTemplateFee.Name, dbFee.Quantity, dbFee.Cost, dbFee.Option));
registrant.Fees.Remove(dbFee);
registrantFeeService.Delete(dbFee);
}
}
// Add/Update any of the fees from UI
foreach (var uiFee in RegistrantState.FeeValues.Where(f => f.Value != null))
{
foreach (var uiFeeOption in uiFee.Value)
{
var dbFee = registrant.Fees
.Where(f =>
f.RegistrationTemplateFeeId == uiFee.Key &&
f.Option == uiFeeOption.Option)
.FirstOrDefault();
if (dbFee == null)
{
dbFee = new RegistrationRegistrantFee();
dbFee.RegistrationTemplateFeeId = uiFee.Key;
dbFee.Option = uiFeeOption.Option;
registrant.Fees.Add(dbFee);
}
var templateFee = dbFee.RegistrationTemplateFee;
if (templateFee == null)
{
templateFee = registrationTemplateFeeService.Get(uiFee.Key);
}
string feeName = templateFee != null ? templateFee.Name : "Fee";
if (!string.IsNullOrWhiteSpace(uiFeeOption.Option))
{
feeName = string.Format("{0} ({1})", feeName, uiFeeOption.Option);
}
if (dbFee.Id <= 0)
{
registrantChanges.Add(feeName + " Fee Added");
}
History.EvaluateChange(registrantChanges, feeName + " Quantity", dbFee.Quantity, uiFeeOption.Quantity);
dbFee.Quantity = uiFeeOption.Quantity;
History.EvaluateChange(registrantChanges, feeName + " Cost", dbFee.Cost, uiFeeOption.Cost);
dbFee.Cost = uiFeeOption.Cost;
}
}
if (TemplateState.RequiredSignatureDocumentTemplate != null)
{
var person = new PersonService(rockContext).Get(personId.Value);
var documentService = new SignatureDocumentService(rockContext);
var binaryFileService = new BinaryFileService(rockContext);
SignatureDocument document = null;
int?signatureDocumentId = hfSignedDocumentId.Value.AsIntegerOrNull();
int?binaryFileId = fuSignedDocument.BinaryFileId;
if (signatureDocumentId.HasValue)
{
document = documentService.Get(signatureDocumentId.Value);
}
if (document == null && binaryFileId.HasValue)
{
var instance = new RegistrationInstanceService(rockContext).Get(RegistrationInstanceId);
document = new SignatureDocument();
document.SignatureDocumentTemplateId = TemplateState.RequiredSignatureDocumentTemplate.Id;
document.AppliesToPersonAliasId = registrant.PersonAliasId.Value;
document.AssignedToPersonAliasId = registrant.PersonAliasId.Value;
document.Name = string.Format("{0}_{1}",
(instance != null ? instance.Name : TemplateState.Name),
(person != null ? person.FullName.RemoveSpecialCharacters() : string.Empty));
document.Status = SignatureDocumentStatus.Signed;
document.LastStatusDate = RockDateTime.Now;
documentService.Add(document);
}
if (document != null)
{
int?origBinaryFileId = document.BinaryFileId;
document.BinaryFileId = binaryFileId;
if (origBinaryFileId.HasValue && origBinaryFileId.Value != document.BinaryFileId)
{
// if a new the binaryFile was uploaded, mark the old one as Temporary so that it gets cleaned up
var oldBinaryFile = binaryFileService.Get(origBinaryFileId.Value);
if (oldBinaryFile != null && !oldBinaryFile.IsTemporary)
{
oldBinaryFile.IsTemporary = true;
}
}
// ensure the IsTemporary is set to false on binaryFile associated with this document
if (document.BinaryFileId.HasValue)
{
var binaryFile = binaryFileService.Get(document.BinaryFileId.Value);
if (binaryFile != null && binaryFile.IsTemporary)
{
binaryFile.IsTemporary = false;
}
}
}
}
if (!registrant.IsValid)
{
// Controls will render the error messages
return;
}
// use WrapTransaction since SaveAttributeValues does it's own RockContext.SaveChanges()
rockContext.WrapTransaction(() =>
{
rockContext.SaveChanges();
registrant.LoadAttributes();
foreach (var field in TemplateState.Forms
.SelectMany(f => f.Fields
.Where(t =>
t.FieldSource == RegistrationFieldSource.RegistrationAttribute &&
t.AttributeId.HasValue)))
{
var attribute = AttributeCache.Read(field.AttributeId.Value);
if (attribute != null)
{
string originalValue = registrant.GetAttributeValue(attribute.Key);
var fieldValue = RegistrantState.FieldValues
.Where(f => f.Key == field.Id)
.Select(f => f.Value.FieldValue)
.FirstOrDefault();
string newValue = fieldValue != null ? fieldValue.ToString() : string.Empty;
if ((originalValue ?? string.Empty).Trim() != (newValue ?? string.Empty).Trim())
{
string formattedOriginalValue = string.Empty;
if (!string.IsNullOrWhiteSpace(originalValue))
{
formattedOriginalValue = attribute.FieldType.Field.FormatValue(null, originalValue, attribute.QualifierValues, false);
}
string formattedNewValue = string.Empty;
if (!string.IsNullOrWhiteSpace(newValue))
{
formattedNewValue = attribute.FieldType.Field.FormatValue(null, newValue, attribute.QualifierValues, false);
}
History.EvaluateChange(registrantChanges, attribute.Name, formattedOriginalValue, formattedNewValue);
}
if (fieldValue != null)
{
registrant.SetAttributeValue(attribute.Key, fieldValue.ToString());
}
}
}
registrant.SaveAttributeValues(rockContext);
});
if (newRegistrant && TemplateState.GroupTypeId.HasValue && ppPerson.PersonId.HasValue)
{
using (var newRockContext = new RockContext())
{
var reloadedRegistrant = new RegistrationRegistrantService(newRockContext).Get(registrant.Id);
if (reloadedRegistrant != null &&
reloadedRegistrant.Registration != null &&
reloadedRegistrant.Registration.Group != null &&
reloadedRegistrant.Registration.Group.GroupTypeId == TemplateState.GroupTypeId.Value)
{
int?groupRoleId = TemplateState.GroupMemberRoleId.HasValue ?
TemplateState.GroupMemberRoleId.Value :
reloadedRegistrant.Registration.Group.GroupType.DefaultGroupRoleId;
if (groupRoleId.HasValue)
{
var groupMemberService = new GroupMemberService(newRockContext);
var groupMember = groupMemberService
.Queryable().AsNoTracking()
.Where(m =>
m.GroupId == reloadedRegistrant.Registration.Group.Id &&
m.PersonId == reloadedRegistrant.PersonId &&
m.GroupRoleId == groupRoleId.Value)
.FirstOrDefault();
if (groupMember == null)
{
groupMember = new GroupMember();
groupMemberService.Add(groupMember);
groupMember.GroupId = reloadedRegistrant.Registration.Group.Id;
groupMember.PersonId = ppPerson.PersonId.Value;
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = TemplateState.GroupMemberStatus;
newRockContext.SaveChanges();
registrantChanges.Add(string.Format("Registrant added to {0} group", reloadedRegistrant.Registration.Group.Name));
}
else
{
registrantChanges.Add(string.Format("Registrant group member reference updated to existing person in {0} group", reloadedRegistrant.Registration.Group.Name));
}
reloadedRegistrant.GroupMemberId = groupMember.Id;
newRockContext.SaveChanges();
}
}
}
}
HistoryService.SaveChanges(
rockContext,
typeof(Registration),
Rock.SystemGuid.Category.HISTORY_EVENT_REGISTRATION.AsGuid(),
registrant.RegistrationId,
registrantChanges,
"Registrant: " + registrantName,
null, null);
}
NavigateToRegistration();
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The workflow action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override bool Execute(RockContext rockContext, Model.WorkflowAction action, Object entity, out List <string> errorMessages)
{
var checkInState = GetCheckInState(entity, out errorMessages);
if (checkInState != null)
{
var family = checkInState.CheckIn.CurrentFamily;
if (family != null)
{
var commonMergeFields = Rock.Lava.LavaHelper.GetCommonMergeFields(null);
var groupMemberService = new GroupMemberService(rockContext);
var familyLabels = new List <Guid>();
var people = family.GetPeople(true);
foreach (var person in people)
{
var personGroupTypes = person.GetGroupTypes(true);
var groupTypes = new List <CheckInGroupType>();
// Get Primary area group types first
personGroupTypes.Where(t => checkInState.ConfiguredGroupTypes.Contains(t.GroupType.Id)).ToList().ForEach(t => groupTypes.Add(t));
// Then get additional areas
personGroupTypes.Where(t => !checkInState.ConfiguredGroupTypes.Contains(t.GroupType.Id)).ToList().ForEach(t => groupTypes.Add(t));
var personLabels = new List <Guid>();
foreach (var groupType in groupTypes)
{
groupType.Labels = new List <CheckInLabel>();
var groupTypeLabels = GetGroupTypeLabels(groupType.GroupType);
var PrinterIPs = new Dictionary <int, string>();
foreach (var labelCache in groupTypeLabels.OrderBy(l => l.LabelType).ThenBy(l => l.Order))
{
person.SetOptions(labelCache);
foreach (var group in groupType.GetGroups(true))
{
foreach (var location in group.GetLocations(true))
{
if (labelCache.LabelType == KioskLabelType.Family)
{
if (familyLabels.Contains(labelCache.Guid) ||
personLabels.Contains(labelCache.Guid))
{
break;
}
else
{
familyLabels.Add(labelCache.Guid);
}
}
else if (labelCache.LabelType == KioskLabelType.Person)
{
if (personLabels.Contains(labelCache.Guid))
{
break;
}
else
{
personLabels.Add(labelCache.Guid);
}
}
var mergeObjects = new Dictionary <string, object>();
foreach (var keyValue in commonMergeFields)
{
mergeObjects.Add(keyValue.Key, keyValue.Value);
}
mergeObjects.Add("Location", location);
mergeObjects.Add("Group", group);
mergeObjects.Add("Person", person);
mergeObjects.Add("People", people);
mergeObjects.Add("GroupType", groupType);
var groupMembers = groupMemberService.Queryable().AsNoTracking()
.Where(m =>
m.PersonId == person.Person.Id &&
m.GroupId == group.Group.Id)
.ToList();
mergeObjects.Add("GroupMembers", groupMembers);
//string debugInfo = mergeObjects.lavaDebugInfo();
var label = new CheckInLabel(labelCache, mergeObjects, person.Person.Id);
label.FileGuid = labelCache.Guid;
label.PrintFrom = checkInState.Kiosk.Device.PrintFrom;
label.PrintTo = checkInState.Kiosk.Device.PrintToOverride;
if (label.PrintTo == PrintTo.Default)
{
label.PrintTo = groupType.GroupType.AttendancePrintTo;
}
if (label.PrintTo == PrintTo.Kiosk)
{
var device = checkInState.Kiosk.Device;
if (device != null)
{
label.PrinterDeviceId = device.PrinterDeviceId;
}
}
else if (label.PrintTo == PrintTo.Location)
{
var deviceId = location.Location.PrinterDeviceId;
if (deviceId != null)
{
label.PrinterDeviceId = deviceId;
}
}
if (label.PrinterDeviceId.HasValue)
{
if (PrinterIPs.ContainsKey(label.PrinterDeviceId.Value))
{
label.PrinterAddress = PrinterIPs[label.PrinterDeviceId.Value];
}
else
{
var printerDevice = new DeviceService(rockContext).Get(label.PrinterDeviceId.Value);
if (printerDevice != null)
{
PrinterIPs.Add(printerDevice.Id, printerDevice.IPAddress);
label.PrinterAddress = printerDevice.IPAddress;
}
}
}
groupType.Labels.Add(label);
}
}
}
}
}
}
return(true);
}
return(false);
}
/// <summary>
/// Executes the specified workflow.
/// </summary>
/// <param name="rockContext">The rock context.</param>
/// <param name="action">The action.</param>
/// <param name="entity">The entity.</param>
/// <param name="errorMessages">The error messages.</param>
/// <returns></returns>
public override bool Execute(RockContext rockContext, WorkflowAction action, Object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// Determine which group to add the person to
Group group = null;
int? groupRoleId = null;
var groupAndRoleValues = (GetAttributeValue(action, "GroupAndRole") ?? string.Empty).Split('|');
if (groupAndRoleValues.Count() > 1)
{
var groupGuid = groupAndRoleValues[1].AsGuidOrNull();
if (groupGuid.HasValue)
{
group = new GroupService(rockContext).Get(groupGuid.Value);
if (groupAndRoleValues.Count() > 2)
{
var groupTypeRoleGuid = groupAndRoleValues[2].AsGuidOrNull();
if (groupTypeRoleGuid.HasValue)
{
var groupRole = new GroupTypeRoleService(rockContext).Get(groupTypeRoleGuid.Value);
if (groupRole != null)
{
groupRoleId = groupRole.Id;
}
}
}
if (!groupRoleId.HasValue && group != null)
{
// use the group's grouptype's default group role if a group role wasn't specified
groupRoleId = group.GroupType.DefaultGroupRoleId;
}
}
}
if (group == null)
{
errorMessages.Add("No group was provided");
}
if (!groupRoleId.HasValue)
{
errorMessages.Add("No group role was provided and group doesn't have a default group role");
}
// determine the person that will be added to the group
Person person = null;
// get the Attribute.Guid for this workflow's Person Attribute so that we can lookup the value
var guidPersonAttribute = GetAttributeValue(action, "Person").AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorkflowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
if (attributePerson.FieldType.Class == typeof(Rock.Field.Types.PersonFieldType).FullName)
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
}
}
else
{
errorMessages.Add("The attribute used to provide the person was not of type 'Person'.");
}
}
}
}
if (person == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
}
// Add Person to Group
if (!errorMessages.Any())
{
var status = this.GetAttributeValue(action, "GroupMemberStatus").ConvertToEnum <GroupMemberStatus>(GroupMemberStatus.Active);
var groupMemberService = new GroupMemberService(rockContext);
var groupMember = groupMemberService.GetByGroupIdAndPersonIdAndPreferredGroupRoleId(group.Id, person.Id, groupRoleId.Value);
bool isNew = false;
if (groupMember == null)
{
groupMember = new GroupMember();
groupMember.PersonId = person.Id;
groupMember.GroupId = group.Id;
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = status;
isNew = true;
}
else
{
if (GetAttributeValue(action, "UpdateExisting").AsBoolean())
{
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = status;
}
action.AddLogEntry($"{person.FullName} was already a member of the selected group.", true);
}
if (groupMember.IsValidGroupMember(rockContext))
{
if (isNew)
{
groupMemberService.Add(groupMember);
}
rockContext.SaveChanges();
}
else
{
// if the group member couldn't be added (for example, one of the group membership rules didn't pass), add the validation messages to the errormessages
errorMessages.AddRange(groupMember.ValidationResults.Select(a => a.ErrorMessage));
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Creates the iCalendar object and populates it with events
/// </summary>
/// <param name="calendarProps">The calendar props.</param>
/// <returns></returns>
private Calendar CreateICalendar(CalendarProps calendarProps, string interactionDeviceType)
{
// Get a list of confirmed attendances filtered by calendarProps
List <Attendance> attendances = GetAttendances(calendarProps);
// Create the iCalendar
var icalendar = new Calendar();
icalendar.AddTimeZone(TimeZoneInfo.Local);
TimeSpan duration = TimeSpan.MinValue;
int currentScheduleId = -1;
// Create each of the attendances
foreach (var attendance in attendances)
{
using (var rockContext = new RockContext())
{
var attendanceOccurrenceService = new AttendanceOccurrenceService(rockContext);
var schedule = attendanceOccurrenceService
.Queryable()
.AsNoTracking()
.Where(a => a.Id == attendance.OccurrenceId)
.Select(a => a.Schedule)
.FirstOrDefault();
string scheduleName = schedule.Name;
// TODO: Construct a description that includes the group leader contact info and the URL to the schedule toolbox.
string description = schedule.Description;
string locationName = attendanceOccurrenceService
.Queryable()
.AsNoTracking()
.Where(a => a.Id == attendance.OccurrenceId)
.Select(a => a.Location.Name)
.FirstOrDefault() ?? string.Empty;
if (schedule.Id != currentScheduleId)
{
// We have to get the duration from Schedule.iCal for this attendance.
// Attendances are ordered by scheduleId so this only happens once for each unique schedule.
var serializer = new CalendarSerializer();
var ical = ( CalendarCollection )serializer.Deserialize(schedule.iCalendarContent.ToStreamReader());
duration = ical[0].Events[0].Duration;
currentScheduleId = schedule.Id;
}
var iCalEvent = new Event();
iCalEvent.Summary = scheduleName;
iCalEvent.Location = locationName;
iCalEvent.DtStart = new CalDateTime(attendance.StartDateTime, icalendar.TimeZones[0].TzId);
iCalEvent.Duration = duration;
// Don't set the description prop for outlook to force it to use the X-ALT-DESC property which can have markup.
if (interactionDeviceType != "Outlook")
{
iCalEvent.Description = description.ConvertBrToCrLf().SanitizeHtml();
}
// HTML version of the description for outlook
iCalEvent.AddProperty("X-ALT-DESC;FMTTYPE=text/html", "<html>" + description + "</html>");
// classification: "PUBLIC", "PRIVATE", "CONFIDENTIAL"
iCalEvent.Class = "PUBLIC";
//Add contact info for the group leader
int groupId = attendanceOccurrenceService
.Queryable()
.AsNoTracking()
.Where(a => a.Id == attendance.OccurrenceId)
.Select(a => a.GroupId)
.FirstOrDefault() ?? -1;
Person groupLeader = new GroupMemberService(rockContext).GetLeaders(groupId).AsNoTracking().Select(m => m.Person).FirstOrDefault() ?? null;
if (groupLeader != null)
{
iCalEvent.Organizer = new Organizer(string.Format("MAILTO:{0}", groupLeader.Email));
iCalEvent.Organizer.CommonName = groupLeader.FullName;
// Outlook doesn't seem to use Contacts or Comments
string contactName = !string.IsNullOrEmpty(groupLeader.FullName) ? "Name: " + groupLeader.FullName : string.Empty;
string contactEmail = !string.IsNullOrEmpty(groupLeader.Email) ? ", Email: " + groupLeader.Email : string.Empty;
string contactInfo = contactName + contactEmail;
iCalEvent.Contacts.Add(contactInfo);
iCalEvent.Comments.Add(contactInfo);
}
icalendar.Events.Add(iCalEvent);
}
}
return(icalendar);
}