/// <summary>
/// Show the details for the given person.
/// </summary>
/// <param name="personGuid"></param>
private void ShowDetail(Guid personGuid)
{
btnReprintLabels.Visible = GetAttributeValue(AttributeKey.AllowLabelReprinting).AsBoolean();
using (var rockContext = new RockContext())
{
var personService = new PersonService(rockContext);
var person = personService.Queryable("PhoneNumbers.NumberTypeValue,RecordTypeValue", true, true)
.FirstOrDefault(a => a.Guid == personGuid);
if (person == null)
{
return;
}
lName.Text = person.FullName;
string photoTag = Rock.Model.Person.GetPersonPhotoImageTag(person, 200, 200);
if (person.PhotoId.HasValue)
{
lPhoto.Text = string.Format("<div class='photo'><a href='{0}'>{1}</a></div>", person.PhotoUrl, photoTag);
}
else
{
lPhoto.Text = photoTag;
}
var campus = person.GetCampus();
if (campus != null)
{
hlCampus.Visible = true;
hlCampus.Text = campus.Name;
}
else
{
hlCampus.Visible = false;
}
lGender.Text = person.Gender != Gender.Unknown ? person.Gender.ConvertToString() : "";
if (person.BirthDate.HasValue)
{
string ageText = (person.BirthYear.HasValue && person.BirthYear != DateTime.MinValue.Year) ?
string.Format("{0} yrs old ", person.BirthDate.Value.Age()) : string.Empty;
lAge.Text = string.Format("{0} <small>({1})</small><br/>", ageText, person.BirthDate.Value.ToShortDateString());
}
else
{
lAge.Text = string.Empty;
}
lGrade.Text = person.GradeFormatted;
lEmail.Visible = !string.IsNullOrWhiteSpace(person.Email);
lEmail.Text = person.GetEmailTag(ResolveRockUrl("/"), "btn btn-default", "<i class='fa fa-envelope'></i>");
BindAttribute(person);
// Text Message
var phoneNumber = person.PhoneNumbers.FirstOrDefault(n => n.IsMessagingEnabled && n.Number.IsNotNullOrWhiteSpace());
if (GetAttributeValue(AttributeKey.SMSFrom).IsNotNullOrWhiteSpace() && phoneNumber != null)
{
btnSms.Text = string.Format("<i class='fa fa-mobile'></i> {0} <small>({1})</small>", phoneNumber.NumberFormatted, phoneNumber.NumberTypeValue);
btnSms.Visible = true;
rcwTextMessage.Label = "Text Message";
}
else
{
btnSms.Visible = false;
rcwTextMessage.Label = string.Empty;
}
// Get all family member from all families ( including self )
var allFamilyMembers = personService.GetFamilyMembers(person.Id, true).ToList();
// Add flag for this person in each family indicating if they are a child in family.
var childGuid = Rock.SystemGuid.GroupRole.GROUPROLE_FAMILY_MEMBER_CHILD.AsGuid();
var isFamilyChild = new Dictionary <int, bool>();
foreach (var thisPerson in allFamilyMembers.Where(m => m.PersonId == person.Id))
{
isFamilyChild.Add(thisPerson.GroupId, thisPerson.GroupRole.Guid.Equals(childGuid));
}
// Get the current url's root (without the person's guid)
string urlRoot = Request.Url.ToString().ReplaceCaseInsensitive(personGuid.ToString(), "");
// Get the other family members and the info needed for rendering
var familyMembers = allFamilyMembers.Where(m => m.PersonId != person.Id)
.OrderBy(m => m.GroupId)
.ThenBy(m => m.Person.BirthDate)
.Select(m => new
{
Url = urlRoot + m.Person.Guid.ToString(),
FullName = m.Person.FullName,
Gender = m.Person.Gender,
FamilyRole = m.GroupRole,
Note = isFamilyChild[m.GroupId] ?
(m.GroupRole.Guid.Equals(childGuid) ? " (Sibling)" : "(Parent)") :
(m.GroupRole.Guid.Equals(childGuid) ? " (Child)" : "")
})
.ToList();
rcwFamily.Visible = familyMembers.Any();
rptrFamily.DataSource = familyMembers;
rptrFamily.DataBind();
rcwRelationships.Visible = false;
if (GetAttributeValue(AttributeKey.ShowRelatedPeople).AsBoolean())
{
var roles = new List <int>();
var krRoles = new GroupTypeRoleService(rockContext)
.Queryable().AsNoTracking()
.Where(r => r.GroupType.Guid.Equals(new Guid(Rock.SystemGuid.GroupType.GROUPTYPE_KNOWN_RELATIONSHIPS)))
.ToList();
foreach (var role in krRoles)
{
role.LoadAttributes(rockContext);
if (role.GetAttributeValue("CanCheckin").AsBoolean() &&
role.Attributes.ContainsKey("InverseRelationship"))
{
var inverseRoleGuid = role.GetAttributeValue("InverseRelationship").AsGuidOrNull();
if (inverseRoleGuid.HasValue)
{
var inverseRole = krRoles.FirstOrDefault(r => r.Guid == inverseRoleGuid.Value);
if (inverseRole != null)
{
roles.Add(inverseRole.Id);
}
}
}
}
if (roles.Any())
{
var relatedMembers = personService.GetRelatedPeople(new List <int> {
person.Id
}, roles)
.OrderBy(m => m.Person.LastName)
.ThenBy(m => m.Person.NickName)
.Select(m => new
{
Url = urlRoot + m.Person.Guid.ToString(),
FullName = m.Person.FullName,
Gender = m.Person.Gender,
Note = " (" + m.GroupRole.Name + ")"
})
.ToList();
rcwRelationships.Visible = relatedMembers.Any();
rptrRelationships.DataSource = relatedMembers;
rptrRelationships.DataBind();
}
}
var phoneNumbers = person.PhoneNumbers.Where(p => !p.IsUnlisted).ToList();
rptrPhones.DataSource = phoneNumbers;
rptrPhones.DataBind();
rcwPhone.Visible = phoneNumbers.Any();
var schedules = new ScheduleService(rockContext)
.Queryable().AsNoTracking()
.Where(s => s.CheckInStartOffsetMinutes.HasValue)
.ToList();
var scheduleIds = schedules.Select(s => s.Id).ToList();
int?personAliasId = person.PrimaryAliasId;
PersonAliasService personAliasService = new PersonAliasService(rockContext);
if (!personAliasId.HasValue)
{
personAliasId = personAliasService.GetPrimaryAliasId(person.Id);
}
var attendances = new AttendanceService(rockContext)
.Queryable("Occurrence.Schedule,Occurrence.Group,Occurrence.Location,AttendanceCode")
.Where(a =>
a.PersonAliasId.HasValue &&
a.PersonAliasId == personAliasId &&
a.Occurrence.ScheduleId.HasValue &&
a.Occurrence.GroupId.HasValue &&
a.Occurrence.LocationId.HasValue &&
a.DidAttend.HasValue &&
a.DidAttend.Value &&
scheduleIds.Contains(a.Occurrence.ScheduleId.Value))
.OrderByDescending(a => a.StartDateTime)
.Take(20)
.ToList() // Run query to get recent most 20 checkins
.OrderByDescending(a => a.Occurrence.OccurrenceDate) // Then sort again by start datetime and schedule start (which is not avail to sql query )
.ThenByDescending(a => a.Occurrence.Schedule.StartTimeOfDay)
.ToList()
.Select(a =>
{
var checkedInByPerson = a.CheckedInByPersonAliasId.HasValue ? personAliasService.GetPerson(a.CheckedInByPersonAliasId.Value) : null;
return(new AttendanceInfo
{
Id = a.Id,
Date = a.StartDateTime,
GroupId = a.Occurrence.Group.Id,
Group = a.Occurrence.Group.Name,
LocationId = a.Occurrence.LocationId.Value,
Location = a.Occurrence.Location.Name,
Schedule = a.Occurrence.Schedule.Name,
IsActive = a.IsCurrentlyCheckedIn,
Code = a.AttendanceCode != null ? a.AttendanceCode.Code : "",
CheckInByPersonName = checkedInByPerson != null ? checkedInByPerson.FullName : string.Empty,
CheckInByPersonGuid = checkedInByPerson != null ? checkedInByPerson.Guid : ( Guid? )null
});
}
).ToList();
// Set active locations to be a link to the room in manager page
var qryParam = new Dictionary <string, string>();
qryParam.Add("Group", "");
qryParam.Add("Location", "");
foreach (var attendance in attendances.Where(a => a.IsActive))
{
qryParam["Group"] = attendance.GroupId.ToString();
qryParam["Location"] = attendance.LocationId.ToString();
attendance.Location = string.Format("<a href='{0}'>{1}</a>",
LinkedPageUrl(AttributeKey.ManagerPage, qryParam), attendance.Location);
}
rcwCheckinHistory.Visible = attendances.Any();
// Get the index of the delete column
var deleteField = gHistory.Columns.OfType <Rock.Web.UI.Controls.DeleteField>().First();
_deleteFieldIndex = gHistory.Columns.IndexOf(deleteField);
gHistory.DataSource = attendances;
gHistory.DataBind();
}
}
private void BindGrid()
{
var changeId = hfChangeId.ValueAsInt();
if (changeId == 0)
{
changeId = PageParameter("ChangeRequest").AsInteger();
hfChangeId.SetValue(changeId);
}
RockContext rockContext = new RockContext();
ChangeRequestService changeRequestService = new ChangeRequestService(rockContext);
ChangeRequest changeRequest = changeRequestService.Get(changeId);
if (changeRequest == null)
{
return;
}
if (!IsUserAuthorized(Rock.Security.Authorization.EDIT) &&
(CurrentPerson == null || !CurrentPerson.Aliases.Select(a => a.Id).Contains(changeRequest.RequestorAliasId)))
{
this.Visible = false;
return;
}
CheckForBlacklist(changeRequest);
var link = "";
if (changeRequest.EntityTypeId == EntityTypeCache.Get(typeof(PersonAlias)).Id)
{
PersonAliasService personAliasService = new PersonAliasService(rockContext);
var personAlias = personAliasService.Get(changeRequest.EntityId);
if (personAlias != null)
{
link = string.Format("<a href='/Person/{0}' target='_blank' class='btn btn-default btn-sm'><i class='fa fa-user'></i></a>", personAlias.Person.Id);
}
}
lName.Text = string.Format(@"
<h1 class='panel-title'>{0} {1}</h1>
<div class='panel-labels'>
<span class='label label-default'>
Requested by: <a href='/Person/{2}' target='_blank'>{3}</a>
</span>
<span class='label label-{4}'>
{5}
</span>
</div>",
link,
changeRequest.Name,
changeRequest.RequestorAlias.PersonId,
changeRequest.RequestorAlias.Person.FullName,
changeRequest.IsComplete ? "primary" : "success",
changeRequest.IsComplete ? "Complete" : "Active");
var changeRecords = changeRequest.ChangeRecords.ToList();
var errors = new List <string>();
var entity = ChangeRequest.GetEntity(changeRequest.EntityTypeId, changeRequest.EntityId, rockContext, errors);
foreach (var changeRecord in changeRecords)
{
FormatValues(changeRequest.EntityTypeId, entity, changeRecord, rockContext);
}
if (changeRecords.Any())
{
gRecords.DataSource = changeRecords;
gRecords.DataBind();
}
else
{
gRecords.Visible = false;
}
if (changeRequest.RequestorComment.IsNotNullOrWhiteSpace())
{
ltRequestComments.Visible = true;
ltRequestComments.Text = changeRequest.RequestorComment;
}
ltApproverComment.Text = changeRequest.ApproverComment;
tbApproverComment.Text = changeRequest.ApproverComment;
if (!IsUserAuthorized(Rock.Security.Authorization.EDIT))
{
btnComplete.Visible = false;
tbApproverComment.Visible = false;
ltApproverComment.Visible = true;
(( DataControlField )gRecords.Columns
.Cast <DataControlField>()
.Where(fld => (fld.HeaderText == "Is Rejected"))
.SingleOrDefault()).Visible = false;
}
}
/// <summary>
/// Handles the Click event of the btnSaveGroup 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 btnSaveGroup_Click(object sender, EventArgs e)
{
var rockContext = new RockContext();
GroupService groupService = new GroupService(rockContext);
Group group = groupService.Get(_groupId);
if (group != null && group.IsAuthorized(Authorization.EDIT, CurrentPerson))
{
group.Name = tbName.Text;
group.Description = tbDescription.Text;
group.IsActive = cbIsActive.Checked;
group.IsPublic = cbIsPublic.Checked;
if (pnlSchedule.Visible)
{
if (group.Schedule == null)
{
group.Schedule = new Schedule();
group.Schedule.iCalendarContent = null;
}
group.Schedule.WeeklyDayOfWeek = dowWeekly.SelectedDayOfWeek;
group.Schedule.WeeklyTimeOfDay = timeWeekly.SelectedTime;
}
// set attributes
group.LoadAttributes(rockContext);
Rock.Attribute.Helper.GetEditValues(phAttributes, group);
// configure locations
if (GetAttributeValue("EnableLocationEdit").AsBoolean())
{
// get selected location
Location location = null;
int? memberPersonAliasId = null;
if (LocationTypeTab.Equals(MEMBER_LOCATION_TAB_TITLE))
{
if (ddlMember.SelectedValue != null)
{
var ids = ddlMember.SelectedValue.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (ids.Length == 2)
{
var dbLocation = new LocationService(rockContext).Get(int.Parse(ids[0]));
if (dbLocation != null)
{
location = dbLocation;
}
memberPersonAliasId = new PersonAliasService(rockContext).GetPrimaryAliasId(int.Parse(ids[1]));
}
}
}
else
{
if (locpGroupLocation.Location != null)
{
location = new LocationService(rockContext).Get(locpGroupLocation.Location.Id);
}
}
if (location != null)
{
GroupLocation groupLocation = group.GroupLocations.FirstOrDefault();
if (groupLocation == null)
{
groupLocation = new GroupLocation();
group.GroupLocations.Add(groupLocation);
}
groupLocation.GroupMemberPersonAliasId = memberPersonAliasId;
groupLocation.Location = location;
groupLocation.LocationId = groupLocation.Location.Id;
groupLocation.GroupLocationTypeValueId = ddlLocationType.SelectedValueAsId();
}
}
rockContext.SaveChanges();
group.SaveAttributeValues(rockContext);
}
this.IsEditingGroup = false;
// reload the group info
pnlGroupEdit.Visible = false;
pnlGroupView.Visible = true;
DisplayViewGroup();
}
private void ShowReadonlyDetails()
{
hfMode.Value = "View";
if (Workflow != null)
{
if (Workflow.IsAuthorized(Authorization.VIEW, CurrentPerson))
{
tdName.Description = Workflow.Name;
tdStatus.Description = Workflow.Status;
if (Workflow.InitiatorPersonAlias != null && Workflow.InitiatorPersonAlias.Person != null)
{
var person = Workflow.InitiatorPersonAlias.Person;
tdInitiator.Description = string.Format("<a href='{0}{1}'>{2}</a>", ResolveRockUrl("~/Person/"), person.Id, person.FullName);
}
else
{
tdInitiator.Description = string.Empty;
}
if (Workflow.ActivatedDateTime.HasValue)
{
tdActivatedWhen.Description = string.Format("{0} {1} ({2})",
Workflow.ActivatedDateTime.Value.ToShortDateString(),
Workflow.ActivatedDateTime.Value.ToShortTimeString(),
Workflow.ActivatedDateTime.Value.ToRelativeDateString());
}
if (Workflow.LastProcessedDateTime.HasValue)
{
tdLastProcessed.Description = string.Format("{0} {1} ({2})",
Workflow.LastProcessedDateTime.Value.ToShortDateString(),
Workflow.LastProcessedDateTime.Value.ToShortTimeString(),
Workflow.LastProcessedDateTime.Value.ToRelativeDateString());
}
if (Workflow.CompletedDateTime.HasValue)
{
tdCompletedWhen.Description = string.Format("{0} {1} ({2})",
Workflow.CompletedDateTime.Value.ToShortDateString(),
Workflow.CompletedDateTime.Value.ToShortTimeString(),
Workflow.CompletedDateTime.Value.ToRelativeDateString());
}
ShowAttributeValues();
var rockContext = new RockContext();
_personAliasService = new PersonAliasService(rockContext);
_groupService = new GroupService(rockContext);
rptrActivities.DataSource = Workflow.Activities.OrderBy(a => a.ActivatedDateTime).ToList();
rptrActivities.DataBind();
BindLog();
}
else
{
nbNotAuthorized.Visible = true;
pnlContent.Visible = false;
}
}
HideSecondaryBlocks(false);
}
/// <summary>
/// Handles the Click event of the lbSave control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
protected void lbSave_Click(object sender, EventArgs e)
{
if (_group != null && _occurrence != null)
{
var rockContext = new RockContext();
var attendanceService = new AttendanceService(rockContext);
var personAliasService = new PersonAliasService(rockContext);
var locationService = new LocationService(rockContext);
bool dateAdjusted = false;
DateTime startDate = _occurrence.Date;
// If this is a manuall entered occurrence, check to see if date was changed
if (!_occurrence.ScheduleId.HasValue)
{
DateTime?originalDate = PageParameter("Date").AsDateTime();
if (originalDate.HasValue && originalDate.Value.Date != startDate.Date)
{
startDate = originalDate.Value.Date;
dateAdjusted = true;
}
}
DateTime endDate = startDate.AddDays(1);
var existingAttendees = attendanceService
.Queryable("PersonAlias")
.Where(a =>
a.GroupId == _group.Id &&
a.LocationId == _occurrence.LocationId &&
a.ScheduleId == _occurrence.ScheduleId &&
a.StartDateTime >= startDate &&
a.StartDateTime < endDate);
if (dateAdjusted)
{
foreach (var attendee in existingAttendees)
{
attendee.StartDateTime = _occurrence.Date;
}
}
// If did not meet was selected and this was a manually entered occurrence (not based on a schedule/location)
// then just delete all the attendance records instead of tracking a 'did not meet' value
if (cbDidNotMeet.Checked && !_occurrence.ScheduleId.HasValue)
{
foreach (var attendance in existingAttendees)
{
attendanceService.Delete(attendance);
}
}
else
{
int?campusId = locationService.GetCampusIdForLocation(_occurrence.LocationId);
if (!campusId.HasValue)
{
campusId = _group.CampusId;
}
if (!campusId.HasValue && _allowCampusFilter)
{
var campus = CampusCache.Read(bddlCampus.SelectedValueAsInt() ?? 0);
if (campus != null)
{
campusId = campus.Id;
}
}
if (cbDidNotMeet.Checked)
{
// If the occurrence is based on a schedule, set the did not meet flags
foreach (var attendance in existingAttendees)
{
attendance.DidAttend = null;
attendance.DidNotOccur = true;
}
}
foreach (var attendee in _attendees)
{
var attendance = existingAttendees
.Where(a => a.PersonAlias.PersonId == attendee.PersonId)
.FirstOrDefault();
if (attendance == null)
{
int?personAliasId = personAliasService.GetPrimaryAliasId(attendee.PersonId);
if (personAliasId.HasValue)
{
attendance = new Attendance();
attendance.GroupId = _group.Id;
attendance.ScheduleId = _group.ScheduleId;
attendance.PersonAliasId = personAliasId;
attendance.StartDateTime = _occurrence.Date.Date.Add(_occurrence.StartTime);
attendance.LocationId = _occurrence.LocationId;
attendance.CampusId = campusId;
attendance.ScheduleId = _occurrence.ScheduleId;
// check that the attendance record is valid
cvAttendance.IsValid = attendance.IsValid;
if (!cvAttendance.IsValid)
{
cvAttendance.ErrorMessage = attendance.ValidationResults.Select(a => a.ErrorMessage).ToList().AsDelimited("<br />");
return;
}
attendanceService.Add(attendance);
}
}
if (attendance != null)
{
if (cbDidNotMeet.Checked)
{
attendance.DidAttend = null;
attendance.DidNotOccur = true;
}
else
{
attendance.DidAttend = attendee.Attended;
attendance.DidNotOccur = null;
}
}
}
}
if (_occurrence.LocationId.HasValue)
{
Rock.CheckIn.KioskLocationAttendance.Flush(_occurrence.LocationId.Value);
}
rockContext.SaveChanges();
Guid?workflowTypeGuid = GetAttributeValue("Workflow").AsGuidOrNull();
if (workflowTypeGuid.HasValue)
{
var workflowType = WorkflowTypeCache.Read(workflowTypeGuid.Value);
if (workflowType != null && (workflowType.IsActive ?? true))
{
try
{
var workflow = Workflow.Activate(workflowType, _group.Name);
workflow.SetAttributeValue("StartDateTime", _occurrence.Date.ToString("o"));
workflow.SetAttributeValue("Schedule", _group.Schedule.Guid.ToString());
List <string> workflowErrors;
new WorkflowService(rockContext).Process(workflow, _group, out workflowErrors);
}
catch (Exception ex)
{
ExceptionLogService.LogException(ex, this.Context);
}
}
}
var qryParams = new Dictionary <string, string> {
{ "GroupId", _group.Id.ToString() }
};
var groupTypeIds = PageParameter("GroupTypeIds");
if (!string.IsNullOrWhiteSpace(groupTypeIds))
{
qryParams.Add("GroupTypeIds", groupTypeIds);
}
NavigateToParentPage(qryParams);
}
}
/// <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);
string to = GetAttributeValue(action, AttributeKey.To);
string fromValue = GetAttributeValue(action, AttributeKey.From);
string replyTo = GetAttributeValue(action, AttributeKey.ReplyTo);
string subject = GetAttributeValue(action, AttributeKey.Subject);
string body = GetAttributeValue(action, AttributeKey.Body);
string cc = GetActionAttributeValue(action, AttributeKey.Cc);
string bcc = GetActionAttributeValue(action, AttributeKey.Bcc);
var attachmentOneGuid = GetAttributeValue(action, AttributeKey.AttachmentOne, true).AsGuid();
var attachmentTwoGuid = GetAttributeValue(action, AttributeKey.AttachmentTwo, true).AsGuid();
var attachmentThreeGuid = GetAttributeValue(action, AttributeKey.AttachmentThree, true).AsGuid();
var attachmentList = new List <BinaryFile>();
if (!attachmentOneGuid.IsEmpty())
{
attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentOneGuid));
}
if (!attachmentTwoGuid.IsEmpty())
{
attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentTwoGuid));
}
if (!attachmentThreeGuid.IsEmpty())
{
attachmentList.Add(new BinaryFileService(rockContext).Get(attachmentThreeGuid));
}
var attachments = attachmentList.ToArray();
bool createCommunicationRecord = GetAttributeValue(action, AttributeKey.SaveCommunicationHistory).AsBoolean();
string fromEmailAddress = string.Empty;
string fromName = string.Empty;
Guid? fromGuid = fromValue.AsGuidOrNull();
if (fromGuid.HasValue)
{
var attribute = AttributeCache.Get(fromGuid.Value, rockContext);
if (attribute != null)
{
string fromAttributeValue = action.GetWorkflowAttributeValue(fromGuid.Value);
if (!string.IsNullOrWhiteSpace(fromAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = fromAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person != null && !string.IsNullOrWhiteSpace(person.Email))
{
fromEmailAddress = person.Email;
fromName = person.FullName;
}
}
}
else
{
fromEmailAddress = fromAttributeValue;
}
}
}
}
else
{
fromEmailAddress = fromValue.ResolveMergeFields(mergeFields);
}
string replyToEmailAddress = string.Empty;
Guid? replyToGuid = replyTo.AsGuidOrNull();
// If there is a "Reply To" value for the attribute, use that to get the "Reply To" email.
if (replyToGuid.HasValue)
{
var attribute = AttributeCache.Get(replyToGuid.Value, rockContext);
if (attribute != null)
{
string replyToAttributeValue = action.GetWorkflowAttributeValue(replyToGuid.Value);
if (!string.IsNullOrWhiteSpace(replyToAttributeValue))
{
if (attribute.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
Guid personAliasGuid = replyToAttributeValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var personEmail = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person.Email)
.FirstOrDefault();
if (personEmail.IsNotNullOrWhiteSpace())
{
replyToEmailAddress = personEmail;
}
}
}
else
{
replyToEmailAddress = replyToAttributeValue;
}
}
}
}
else
{
replyToEmailAddress = replyTo.ResolveMergeFields(mergeFields);
}
// To Email recipients list.
if (GetEmailsFromAttributeValue(RecipientType.SendTo, to, action, mergeFields, rockContext, out string toDelimitedEmails, out List <RockEmailMessageRecipient> toRecipients))
{
// CC emails recipients list.
GetEmailsFromAttributeValue(RecipientType.CC, cc, action, mergeFields, rockContext, out string ccDelimitedEmails, out List <RockEmailMessageRecipient> ccRecipients);
List <string> ccEmails = BuildEmailList(ccDelimitedEmails, mergeFields, ccRecipients);
// BCC emails recipients list.
GetEmailsFromAttributeValue(RecipientType.BCC, bcc, action, mergeFields, rockContext, out string bccDelimitedEmails, out List <RockEmailMessageRecipient> bccRecipients);
List <string> bccEmails = BuildEmailList(bccDelimitedEmails, mergeFields, bccRecipients);
if (!string.IsNullOrWhiteSpace(toDelimitedEmails))
{
Send(toDelimitedEmails, fromEmailAddress, fromName, replyToEmailAddress, subject, body, ccEmails, bccEmails, mergeFields, createCommunicationRecord, attachments, out errorMessages);
}
else if (toRecipients != null)
{
Send(toRecipients, fromEmailAddress, fromName, replyToEmailAddress, subject, body, ccEmails, bccEmails, createCommunicationRecord, attachments, out errorMessages);
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
private IQueryable <CommunionData> getQuery <T>()
{
using (var rockContext = new RockContext())
{
var workflowService = new WorkflowService(rockContext);
var attributeService = new AttributeService(rockContext);
var attributeValueService = new AttributeValueService(rockContext);
var personAliasService = new PersonAliasService(rockContext);
var personService = new PersonService(rockContext);
var definedValueService = new DefinedValueService(rockContext);
Guid hospitalWorkflow = GetAttributeValue("HospitalAdmissionWorkflow").AsGuid();
Guid nursingHomeAdmissionWorkflow = GetAttributeValue("NursingHomeResidentWorkflow").AsGuid();
Guid homeBoundPersonWorkflow = GetAttributeValue("HomeboundPersonWorkflow").AsGuid();
Guid hospitalList = GetAttributeValue("HospitalList").AsGuid();
Guid nursingHomeList = GetAttributeValue("NursingHomeList").AsGuid();
var workflowTypesIdAsStrings = new WorkflowTypeService(rockContext).Queryable()
.Where(wt =>
wt.Guid == hospitalWorkflow ||
wt.Guid == nursingHomeAdmissionWorkflow ||
wt.Guid == homeBoundPersonWorkflow
)
.ToList()
.Select(wf => wf.Id.ToString())
.ToList();
var attributeIds = attributeService.Queryable()
.Where(a => a.EntityTypeQualifierColumn == "WorkflowTypeId" && workflowTypesIdAsStrings.Contains(a.EntityTypeQualifierValue))
.Select(a => a.Id).ToList();
var wfTmpqry = workflowService.Queryable().AsNoTracking()
.Where(w => (
w.WorkflowType.Guid == hospitalWorkflow ||
w.WorkflowType.Guid == nursingHomeAdmissionWorkflow ||
w.WorkflowType.Guid == homeBoundPersonWorkflow
) && (w.Status == "Active"));
var tqry = wfTmpqry.Join(attributeValueService.Queryable(),
obj => obj.Id,
av => av.EntityId.Value,
(obj, av) => new { Workflow = obj, AttributeValue = av })
.Where(a => attributeIds.Contains(a.AttributeValue.AttributeId))
.GroupBy(obj => obj.Workflow)
.Select(obj => new { Workflow = obj.Key, AttributeValues = obj.Select(a => a.AttributeValue) });
var qry = tqry.ToList();
List <DefinedValueCache> facilities = DefinedTypeCache.All().Where(dv => dv.Guid == hospitalList || dv.Guid == nursingHomeList).SelectMany(dv => dv.DefinedValues).ToList();
var newQry = qry.Select(w => new CommunionData
{
Campus = new Func <Campus>(() =>
{
Campus campus = null;
AttributeValue personAliasAV = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "PersonToVisit" || av.AttributeKey == "HomeboundPerson").FirstOrDefault();
if (personAliasAV != null)
{
PersonAlias pa = personAliasService.Get(personAliasAV.Value.AsGuid());
if (pa != null)
{
campus = pa.Person.GetCampus();
}
}
if (campus == null)
{
campus = new Campus()
{
Name = "Unknown"
};
}
return(campus);
})(),
Person = GetPerson(personAliasService, w.AttributeValues),
Age = GetPerson(personAliasService, w.AttributeValues).Age,
Description = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "VisitationRequestDescription" || av.AttributeKey == "HomeboundResidentDescription").Select(av => av.ValueFormatted).FirstOrDefault(),
Location = new Func <string>(() =>
{
return(w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "NursingHome" || av.AttributeKey == "Hospital").Select(av => av.ValueFormatted).DefaultIfEmpty("Home").FirstOrDefault());
})(),
Address = GetLocation(personService, w.AttributeValues, facilities).Street1 + " " + GetLocation(personService, w.AttributeValues, facilities).Street2,
City = GetLocation(personService, w.AttributeValues, facilities).City,
State = GetLocation(personService, w.AttributeValues, facilities).State,
PostalCode = GetLocation(personService, w.AttributeValues, facilities).PostalCode,
FacilityNumber = GetFacilityNumber(personService, w.AttributeValues, facilities),
Room = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "Room").Select(av => av.ValueFormatted).FirstOrDefault(),
AdmitDate = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "AdmitDate" || av.AttributeKey == "StartDate").Select(av => av.ValueFormatted).FirstOrDefault(),
Status = w.Workflow.Status,
Communion = w.AttributeValues.AsQueryable().Where(av => av.AttributeKey == "Communion").FirstOrDefault().ValueFormatted
})
.Where(o => o.Communion.AsBoolean() && !o.Person.IsDeceased)
.OrderBy(a => a.PostalCode)
.ThenBy(a => a.Address)
.ToList()
.AsQueryable();
List <COMMUNION_STATES> states = cblState.Items.Cast <ListItem>().Where(i => i.Selected).Select(i => ( COMMUNION_STATES )int.Parse(i.Value)).ToList();
if (states.Count > 0)
{
newQry = newQry.Where(o => (states.Contains(COMMUNION_STATES.KY) && o.State == "KY") ||
(states.Contains(COMMUNION_STATES.IN) && o.State == "IN") ||
((states.Contains(COMMUNION_STATES.Other) && o.State != "IN" && o.State != "KY")));
}
List <int> campuses = cpCampus.Items.Cast <ListItem>().Where(i => i.Selected).Select(i => int.Parse(i.Value)).ToList();
if (campuses.Count > 0)
{
newQry = newQry.Where(o => campuses.Contains(o.Campus.Id));
}
//AddGridColumns( newQry.FirstOrDefault() );
SortProperty sortProperty = gReport.SortProperty;
if (sortProperty != null)
{
newQry = newQry.Sort(sortProperty);
}
return(newQry);
}
}
public override bool Execute(RockContext rockContext, WorkflowAction action, object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
// Check to see if the action's activity does not yet have the the 'InviteLink' attribute.
string signNowDocumentId = action.GetWorklowAttributeValue(GetActionAttributeValue(action, "SignNowDocumentId").AsGuid());
if (string.IsNullOrEmpty(signNowDocumentId))
{
errorMessages.Add("A sign now document is required to complete this action");
return(false);
}
Guid documentGuid = action.GetWorklowAttributeValue(GetActionAttributeValue(action, "Document").AsGuid()).AsGuid();
PersonAliasService personAliasService = new PersonAliasService(rockContext);
BinaryFileService binaryfileService = new BinaryFileService(rockContext);
SignNow signNow = new SignNow();
string snErrorMessage = "";
string token = signNow.GetAccessToken(false, out snErrorMessage);
if (!string.IsNullOrEmpty(snErrorMessage))
{
errorMessages.Add(snErrorMessage);
return(false);
}
//Check if document is signed.
JObject document = SignNowSDK.Document.Get(token, signNowDocumentId);
if ((( JArray )document["signatures"]).Count() > 0)
{
// Download the file
string tempPath = Path.GetTempPath();
string tempFileName = (String)document["document_name"];
var result = SignNowSDK.Document.Download(token, signNowDocumentId, tempPath, tempFileName);
// Put it into the workflow attribute
BinaryFile signedPDF = binaryfileService.Get(documentGuid);
if (signedPDF == null)
{
signedPDF = new BinaryFile();
// TODO: This probably shouldn't be hardcoded
signedPDF.MimeType = "application/pdf";
signedPDF.FileName = tempFileName;
signedPDF.IsTemporary = false;
binaryfileService.Add(signedPDF);
// Update the file type if necessary
Guid binaryFileTypeGuid = Guid.Empty;
var destinationAttribute = AttributeCache.Get(GetActionAttributeValue(action, "Document").AsGuid(), rockContext);
var binaryFileTypeQualifier = destinationAttribute.QualifierValues["binaryFileType"];
if (!String.IsNullOrWhiteSpace(binaryFileTypeQualifier.Value))
{
if (binaryFileTypeQualifier.Value != null)
{
binaryFileTypeGuid = binaryFileTypeQualifier.Value.AsGuid();
signedPDF.BinaryFileTypeId = new BinaryFileTypeService(rockContext).Get(binaryFileTypeGuid).Id;
}
}
signedPDF.DatabaseData = new BinaryFileData();
signedPDF.DatabaseData.Content = File.ReadAllBytes(tempPath + tempFileName + ".pdf");
rockContext.SaveChanges();
// Now store the attribute
if (destinationAttribute.EntityTypeId == new Workflow().TypeId)
{
action.Activity.Workflow.SetAttributeValue(destinationAttribute.Key, signedPDF.Guid.ToString());
}
else if (destinationAttribute.EntityTypeId == new WorkflowActivity().TypeId)
{
action.Activity.SetAttributeValue(destinationAttribute.Key, signedPDF.Guid.ToString());
}
}
else
{
signedPDF.FileName = tempFileName;
signedPDF.DatabaseData.Content = File.ReadAllBytes(tempPath + tempFileName + ".pdf");
}
// Delete the file when we are done:
File.Delete(tempPath + tempFileName);
// We have a signed copy
SetWorkflowAttributeValue(action, GetActionAttributeValue(action, "PDFSigned").AsGuid(), "True");
}
else
{
// Not signed yet.
SetWorkflowAttributeValue(action, GetActionAttributeValue(action, "PDFSigned").AsGuid(), "False");
}
return(true);
}
private void DisplayResults()
{
RockContext rockContext = new RockContext();
var statementYear = RockDateTime.Now.Year;
if (Request["StatementYear"] != null)
{
Int32.TryParse(Request["StatementYear"].ToString(), out statementYear);
}
FinancialTransactionDetailService financialTransactionDetailService = new FinancialTransactionDetailService(rockContext);
Person targetPerson = CurrentPerson;
List <Guid> excludedCurrencyTypes = new List <Guid>();
if (!string.IsNullOrWhiteSpace(GetAttributeValue("ExcludedCurrencyTypes")))
{
excludedCurrencyTypes = GetAttributeValue("ExcludedCurrencyTypes").Split(',').Select(Guid.Parse).ToList();
}
if (GetAttributeValue("AllowPersonQuerystring").AsBoolean())
{
if (!string.IsNullOrWhiteSpace(Request["PersonGuid"]))
{
Guid?personGuid = Request["PersonGuid"].AsGuidOrNull();
if (personGuid.HasValue)
{
var person = new PersonService(rockContext).Get(personGuid.Value);
if (person != null)
{
targetPerson = person;
}
}
}
}
// fetch all the possible PersonAliasIds that have this GivingID to help optimize the SQL
var personAliasIds = new PersonAliasService(rockContext).Queryable().Where(a => a.Person.GivingId == targetPerson.GivingId).Select(a => a.Id).ToList();
// get the transactions for the person or all the members in the person's giving group (Family)
var qry = financialTransactionDetailService.Queryable().AsNoTracking()
.Where(t => t.Transaction.AuthorizedPersonAliasId.HasValue && personAliasIds.Contains(t.Transaction.AuthorizedPersonAliasId.Value));
qry = qry.Where(t => t.Transaction.TransactionDateTime.Value.Year == statementYear);
if (string.IsNullOrWhiteSpace(GetAttributeValue("Accounts")))
{
qry = qry.Where(t => t.Account.IsTaxDeductible);
}
else
{
var accountGuids = GetAttributeValue("Accounts").Split(',').Select(Guid.Parse).ToList();
qry = qry.Where(t => accountGuids.Contains(t.Account.Guid));
}
if (excludedCurrencyTypes.Count > 0)
{
qry = qry.Where(t => !excludedCurrencyTypes.Contains(t.Transaction.FinancialPaymentDetail.CurrencyTypeValue.Guid));
}
qry = qry.OrderByDescending(t => t.Transaction.TransactionDateTime);
var mergeFields = new Dictionary <string, object>();
mergeFields.Add("StatementStartDate", "1/1/" + statementYear.ToString());
if (statementYear == RockDateTime.Now.Year)
{
mergeFields.Add("StatementEndDate", RockDateTime.Now);
}
else
{
mergeFields.Add("StatementEndDate", "12/31/" + statementYear.ToString());
}
var familyGroupTypeId = GroupTypeCache.Read(Rock.SystemGuid.GroupType.GROUPTYPE_FAMILY).Id;
var groupMemberQry = new GroupMemberService(rockContext).Queryable().Where(m => m.Group.GroupTypeId == familyGroupTypeId);
// get giving group members in order by family role (adult -> child) and then gender (male -> female)
var givingGroup = new PersonService(rockContext).Queryable().AsNoTracking()
.Where(p => p.GivingId == targetPerson.GivingId)
.GroupJoin(
groupMemberQry,
p => p.Id,
m => m.PersonId,
(p, m) => new { p, m })
.SelectMany(x => x.m.DefaultIfEmpty(), (y, z) => new { Person = y.p, GroupMember = z })
.Select(p => new { FirstName = p.Person.NickName, LastName = p.Person.LastName, FamilyRoleOrder = p.GroupMember.GroupRole.Order, Gender = p.Person.Gender, PersonId = p.Person.Id })
.DistinctBy(p => p.PersonId)
.OrderBy(p => p.FamilyRoleOrder).ThenBy(p => p.Gender)
.ToList();
string salutation = string.Empty;
if (givingGroup.GroupBy(g => g.LastName).Count() == 1)
{
salutation = string.Join(", ", givingGroup.Select(g => g.FirstName)) + " " + givingGroup.FirstOrDefault().LastName;
if (salutation.Contains(","))
{
salutation = salutation.ReplaceLastOccurrence(",", " &");
}
}
else
{
salutation = string.Join(", ", givingGroup.Select(g => g.FirstName + " " + g.LastName));
if (salutation.Contains(","))
{
salutation = salutation.ReplaceLastOccurrence(",", " &");
}
}
mergeFields.Add("Salutation", salutation);
var homeAddress = targetPerson.GetHomeLocation();
if (homeAddress != null)
{
mergeFields.Add("StreetAddress1", homeAddress.Street1);
mergeFields.Add("StreetAddress2", homeAddress.Street2);
mergeFields.Add("City", homeAddress.City);
mergeFields.Add("State", homeAddress.State);
mergeFields.Add("PostalCode", homeAddress.PostalCode);
mergeFields.Add("Country", homeAddress.Country);
}
else
{
mergeFields.Add("StreetAddress1", string.Empty);
mergeFields.Add("StreetAddress2", string.Empty);
mergeFields.Add("City", string.Empty);
mergeFields.Add("State", string.Empty);
mergeFields.Add("PostalCode", string.Empty);
mergeFields.Add("Country", string.Empty);
}
mergeFields.Add("TransactionDetails", qry.ToList());
mergeFields.Add("AccountSummary", qry.GroupBy(t => t.Account.Name).Select(s => new AccountSummary {
AccountName = s.Key, Total = s.Sum(a => a.Amount), Order = s.Max(a => a.Account.Order)
}).OrderBy(s => s.Order));
// pledge information
var pledges = new FinancialPledgeService(rockContext).Queryable().AsNoTracking()
.Where(p => p.PersonAliasId.HasValue && personAliasIds.Contains(p.PersonAliasId.Value) &&
(p.StartDate.Year == statementYear || p.EndDate.Year == statementYear))
.GroupBy(p => p.Account)
.Select(g => new PledgeSummary
{
AccountId = g.Key.Id,
AccountName = g.Key.Name,
AmountPledged = g.Sum(p => p.TotalAmount),
PledgeStartDate = g.Min(p => p.StartDate),
PledgeEndDate = g.Max(p => p.EndDate)
})
.ToList();
// add detailed pledge information
foreach (var pledge in pledges)
{
var adjustedPedgeEndDate = pledge.PledgeEndDate.Value.Date.AddDays(1);
pledge.AmountGiven = new FinancialTransactionDetailService(rockContext).Queryable()
.Where(t =>
t.AccountId == pledge.AccountId &&
t.Transaction.AuthorizedPersonAliasId.HasValue && personAliasIds.Contains(t.Transaction.AuthorizedPersonAliasId.Value) &&
t.Transaction.TransactionDateTime >= pledge.PledgeStartDate &&
t.Transaction.TransactionDateTime < adjustedPedgeEndDate)
.Sum(t => ( decimal? )t.Amount) ?? 0;
pledge.AmountRemaining = (pledge.AmountGiven > pledge.AmountPledged) ? 0 : (pledge.AmountPledged - pledge.AmountGiven);
if (pledge.AmountPledged > 0)
{
var test = (double)pledge.AmountGiven / (double)pledge.AmountPledged;
pledge.PercentComplete = (int)((pledge.AmountGiven * 100) / pledge.AmountPledged);
}
}
mergeFields.Add("Pledges", pledges);
var template = GetAttributeValue("LavaTemplate");
lResults.Text = template.ResolveMergeFields(mergeFields);
// show debug info
if (GetAttributeValue("EnableDebug").AsBoolean() && IsUserAuthorized(Authorization.EDIT))
{
lDebug.Visible = true;
lDebug.Text = mergeFields.lavaDebugInfo();
}
}
/// <summary>
/// Processes the giving journeys.
/// </summary>
internal void UpdateGivingJourneyStages()
{
var givingAnalyticsSetting = GivingAutomationSettings.LoadGivingAutomationSettings();
var rockContext = new RockContext();
rockContext.Database.CommandTimeout = this.SqlCommandTimeout;
var personService = new PersonService(rockContext);
// Limit to only Business and Person type records.
// Include deceased to cover transactions that could have occurred when they were not deceased
// or transactions that are dated after they were marked deceased.
var personQuery = personService.Queryable(new PersonService.PersonQueryOptions
{
IncludeDeceased = true,
IncludeBusinesses = true,
IncludePersons = true,
IncludeNameless = false,
IncludeRestUsers = false
});
var personAliasService = new PersonAliasService(rockContext);
var personAliasQuery = personAliasService.Queryable();
var financialTransactionService = new FinancialTransactionService(rockContext);
var financialTransactionGivingAnalyticsQuery = financialTransactionService.GetGivingAutomationSourceTransactionQuery();
if (OnProgress != null)
{
string progressMessage = "Calculating journey classifications...";
OnProgress.Invoke(this, new ProgressEventArgs(progressMessage));
}
/* Get Non-Giver GivingIds */
var nonGiverGivingIdsQuery = personQuery.Where(p =>
!financialTransactionGivingAnalyticsQuery.Any(ft => personAliasQuery.Any(pa => pa.Id == ft.AuthorizedPersonAliasId && pa.Person.GivingId == p.GivingId)));
var nonGiverGivingIdsList = nonGiverGivingIdsQuery.Select(a => a.GivingId).Distinct().ToList();
/* Get TransactionDateList for each GivingId in the system */
var transactionDateTimes = financialTransactionGivingAnalyticsQuery.Select(a => new
{
GivingId = personAliasQuery.Where(pa => pa.Id == a.AuthorizedPersonAliasId).Select(pa => pa.Person.GivingId).FirstOrDefault(),
a.TransactionDateTime
}).Where(a => a.GivingId != null).ToList();
var transactionDateTimesByGivingId = transactionDateTimes
.GroupBy(g => g.GivingId)
.Select(s => new
{
GivingId = s.Key,
TransactionDateTimeList = s.Select(x => x.TransactionDateTime).ToList()
}).ToDictionary(k => k.GivingId, v => v.TransactionDateTimeList);
List <AttributeCache> journeyStageAttributesList = new List <AttributeCache> {
_currentJourneyStageAttribute, _previousJourneyStageAttribute, _journeyStageChangeDateAttribute
};
if (journeyStageAttributesList.Any(a => a == null))
{
throw new Exception("Journey Stage Attributes are not installed correctly.");
}
var journeyStageAttributeIds = journeyStageAttributesList.Where(a => a != null).Select(a => a.Id).ToList();
var personCurrentJourneyAttributeValues = new AttributeValueService(rockContext).Queryable()
.WhereAttributeIds(journeyStageAttributeIds)
.Where(av => av.EntityId.HasValue)
.Join(
personQuery.Where(x => !string.IsNullOrEmpty(x.GivingId)),
av => av.EntityId.Value,
p => p.Id,
(av, p) => new
{
AttributeId = av.AttributeId,
AttributeValue = av.Value,
PersonGivingId = p.GivingId,
PersonId = p.Id
})
.GroupBy(a => a.PersonGivingId)
.Select(a => new
{
GivingId = a.Key,
AttributeValues = a.ToList()
}).ToDictionary(k => k.GivingId, v => v.AttributeValues);
var givingJourneySettings = givingAnalyticsSetting.GivingJourneySettings;
var currentDate = RockDateTime.Today;
var formerGiverGivingIds = new List <string>();
var lapsedGiverGivingIds = new List <string>();
var newGiverGivingIds = new List <string>();
var occasionalGiverGivingIds = new List <string>();
var consistentGiverGivingIds = new List <string>();
var noneOfTheAboveGiverGivingIds = new List <string>();
foreach (var givingIdTransactions in transactionDateTimesByGivingId)
{
var givingId = givingIdTransactions.Key;
var transactionDateList = givingIdTransactions.Value.Where(a => a.HasValue).Select(a => a.Value).ToList();
GivingJourneyStage?givingIdGivingJourneyStage = GetGivingJourneyStage(givingJourneySettings, currentDate, transactionDateList);
switch (givingIdGivingJourneyStage)
{
case GivingJourneyStage.Former:
formerGiverGivingIds.Add(givingId);
break;
case GivingJourneyStage.Lapsed:
lapsedGiverGivingIds.Add(givingId);
break;
case GivingJourneyStage.New:
newGiverGivingIds.Add(givingId);
break;
case GivingJourneyStage.Occasional:
occasionalGiverGivingIds.Add(givingId);
break;
case GivingJourneyStage.Consistent:
consistentGiverGivingIds.Add(givingId);
break;
case GivingJourneyStage.None:
// Shouldn't happen since we are only looking at people with transactions, and we have already
// figured out the non-givers
break;
default:
// if they are non of the above, then add them to the "none of the above" list
noneOfTheAboveGiverGivingIds.Add(givingId);
break;
}
}
Debug.WriteLine($@"
FormerGiverCount: {formerGiverGivingIds.Count}
LapsedGiverCount: {lapsedGiverGivingIds.Count}
NewGiverCount: {newGiverGivingIds.Count}
OccasionalGiverCount: {occasionalGiverGivingIds.Count}
ConsistentGiverCount: {consistentGiverGivingIds.Count}
NonGiverCount: {nonGiverGivingIdsList.Count}
NoneOfTheAboveCount: {noneOfTheAboveGiverGivingIds.Count}
");
_attributeValuesByGivingIdAndPersonId = personCurrentJourneyAttributeValues
.ToDictionary(
k => k.Key,
v =>
{
var lookupByPersonId = v.Value
.Select(s => new AttributeValueCache(s.AttributeId, s.PersonId, s.AttributeValue))
.GroupBy(g => g.EntityId.Value)
.ToDictionary(k => k.Key, vv => vv.ToList());
return(lookupByPersonId);
});
_personIdsByGivingId = personQuery.Where(x => !string.IsNullOrEmpty(x.GivingId))
.Select(a => new { a.GivingId, PersonId = a.Id })
.GroupBy(a => a.GivingId)
.ToDictionary(
k => k.Key,
v => v.Select(p => p.PersonId).ToList());
UpdateJourneyStageAttributeValuesForGivingId(formerGiverGivingIds, GivingJourneyStage.Former);
UpdateJourneyStageAttributeValuesForGivingId(lapsedGiverGivingIds, GivingJourneyStage.Lapsed);
UpdateJourneyStageAttributeValuesForGivingId(newGiverGivingIds, GivingJourneyStage.New);
UpdateJourneyStageAttributeValuesForGivingId(occasionalGiverGivingIds, GivingJourneyStage.Occasional);
UpdateJourneyStageAttributeValuesForGivingId(consistentGiverGivingIds, GivingJourneyStage.Consistent);
UpdateJourneyStageAttributeValuesForGivingId(nonGiverGivingIdsList, GivingJourneyStage.None);
UpdateJourneyStageAttributeValuesForGivingId(noneOfTheAboveGiverGivingIds, null);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var rockContext = (RockContext)serviceInstance.Context;
SelectionConfig selectionConfig = SelectionConfig.Parse(selection);
if (selectionConfig == null)
{
return(null);
}
DateRange dateRange = SlidingDateRangePicker.CalculateDateRangeFromDelimitedValues(selectionConfig.DelimitedValues);
int transactionTypeContributionId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid()).Id;
var financialTransactionBaseQry = new FinancialTransactionService(rockContext)
.Queryable()
.Where(xx => xx.TransactionTypeValueId == transactionTypeContributionId);
var accountIdList = new FinancialAccountService(( RockContext )serviceInstance.Context).GetByGuids(selectionConfig.AccountGuids).Select(a => a.Id).ToList();
if (accountIdList.Any())
{
if (accountIdList.Count == 1)
{
int accountId = accountIdList.First();
financialTransactionBaseQry = financialTransactionBaseQry.Where(xx => xx.TransactionDetails.Any(a => a.AccountId == accountId));
}
else
{
financialTransactionBaseQry = financialTransactionBaseQry.Where(xx => xx.TransactionDetails.Any(a => accountIdList.Contains(a.AccountId)));
}
}
var personAliasQry = new PersonAliasService(rockContext).Queryable();
var personQryForJoin = new PersonService(rockContext).Queryable();
// Create explicit joins to person alias and person tables so that rendered SQL has an INNER Joins vs OUTER joins on PersonAlias
var financialTransactionsQry = financialTransactionBaseQry
.Join(personAliasQry, t => t.AuthorizedPersonAliasId, pa => pa.Id, (t, pa) => new
{
txn = t,
PersonId = pa.PersonId
});
var firstContributionDateQry = financialTransactionsQry
.GroupBy(xx => xx.PersonId)
.Select(ss => new
{
PersonId = ss.Key,
FirstTransactionDate = ss.Min(a => selectionConfig.UseSundayDate == true ? a.txn.SundayDate : a.txn.TransactionDateTime)
});
if (dateRange.Start.HasValue)
{
firstContributionDateQry = firstContributionDateQry.Where(xx => xx.FirstTransactionDate >= dateRange.Start.Value);
}
if (dateRange.End.HasValue)
{
firstContributionDateQry = firstContributionDateQry.Where(xx => xx.FirstTransactionDate < dateRange.End.Value);
}
var innerQry = firstContributionDateQry.Select(xx => xx.PersonId).AsQueryable();
var qry = new PersonService(rockContext).Queryable().Where(p => innerQry.Any(xx => xx == p.Id));
return(FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p"));
}
/// <summary>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
RockContext rockContext = new RockContext();
FinancialTransactionService transService = new FinancialTransactionService(rockContext);
var qry = transService.Queryable("TransactionDetails.Account,FinancialPaymentDetail");
List <int> personAliasIds;
if (TargetPerson != null)
{
personAliasIds = new PersonAliasService(rockContext).Queryable().Where(a => a.Person.GivingId == TargetPerson.GivingId).Select(a => a.Id).ToList();
}
else
{
personAliasIds = new List <int>();
}
qry = qry.Where(t => t.AuthorizedPersonAliasId.HasValue && personAliasIds.Contains(t.AuthorizedPersonAliasId.Value));
// if the Account Checkboxlist is visible, filter to what was selected. Otherwise, show all the accounts that the person contributed to
if (cblAccounts.Visible)
{
// get list of selected accounts
List <int> selectedAccountIds = cblAccounts.Items.Cast <ListItem>()
.Where(i => i.Selected == true)
.Select(i => int.Parse(i.Value)).ToList();
qry = qry.Where(t => t.TransactionDetails.Any(d => selectedAccountIds.Contains(d.AccountId)));
}
if (drpFilterDates.LowerValue.HasValue)
{
qry = qry.Where(t => t.TransactionDateTime.Value >= drpFilterDates.LowerValue.Value);
}
if (drpFilterDates.UpperValue.HasValue)
{
var lastDate = drpFilterDates.UpperValue.Value.AddDays(1); // add one day to ensure we get all transactions till midnight
qry = qry.Where(t => t.TransactionDateTime.Value < lastDate);
}
// Transaction Types
var transactionTypeValueIdList = GetAttributeValue("TransactionTypes").SplitDelimitedValues().AsGuidList().Select(a => DefinedValueCache.Get(a)).Where(a => a != null).Select(a => a.Id).ToList();
if (transactionTypeValueIdList.Any())
{
qry = qry.Where(t => transactionTypeValueIdList.Contains(t.TransactionTypeValueId));
}
qry = qry.OrderByDescending(a => a.TransactionDateTime);
var txns = qry.ToList();
// get account totals
Dictionary <string, decimal> accountTotals = new Dictionary <string, decimal>();
foreach (var transaction in txns)
{
foreach (var transactionDetail in transaction.TransactionDetails)
{
if (accountTotals.Keys.Contains(transactionDetail.Account.PublicName))
{
accountTotals[transactionDetail.Account.PublicName] += transactionDetail.Amount;
}
else
{
accountTotals.Add(transactionDetail.Account.PublicName, transactionDetail.Amount);
}
}
}
lAccountSummary.Text = string.Empty;
if (accountTotals.Count > 0)
{
pnlSummary.Visible = true;
foreach (var key in accountTotals.Keys)
{
lAccountSummary.Text += string.Format("<li>{0}: {1}</li>", key, accountTotals[key].FormatAsCurrency());
}
}
else
{
pnlSummary.Visible = false;
}
gTransactions.EntityTypeId = EntityTypeCache.Get <FinancialTransaction>().Id;
gTransactions.DataSource = txns.Select(t => new
{
t.Id,
t.TransactionDateTime,
CurrencyType = FormatCurrencyType(t),
t.TransactionCode,
t.ForeignKey,
Summary = FormatSummary(t),
t.TotalAmount
}).ToList();
gTransactions.ColumnsOfType <Rock.Web.UI.Controls.RockBoundField>().First(c => c.HeaderText == "Transaction Code").Visible =
GetAttributeValue("ShowTransactionCode").AsBoolean();
gTransactions.ColumnsOfType <Rock.Web.UI.Controls.RockBoundField>().First(c => c.HeaderText == "Foreign Key").Visible =
GetAttributeValue("ShowForeignKey").AsBoolean();
gTransactions.DataBind();
}
/// <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;
DateTime attendanceDateTime = DateTime.MinValue;
bool addToGroup = true;
// get the group attribute
Guid groupAttributeGuid = GetAttributeValue(action, "Group").AsGuid();
if (!groupAttributeGuid.IsEmpty())
{
groupGuid = action.GetWorklowAttributeValue(groupAttributeGuid).AsGuidOrNull();
if (!groupGuid.HasValue)
{
errorMessages.Add("The group could not be found!");
}
}
// 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().AsNoTracking()
.Where(p => p.Guid.Equals(personAliasGuid))
.Select(p => p.Person)
.FirstOrDefault();
}
else
{
errorMessages.Add("The person could not be found in the attribute!");
}
}
// get attendance date
Guid dateTimeAttributeGuid = GetAttributeValue(action, "AttendanceDatetime").AsGuid();
if (!dateTimeAttributeGuid.IsEmpty())
{
string attributeDatetime = action.GetWorklowAttributeValue(dateTimeAttributeGuid);
if (string.IsNullOrWhiteSpace(attributeDatetime))
{
attendanceDateTime = RockDateTime.Now;
}
else
{
if (!DateTime.TryParse(attributeDatetime, out attendanceDateTime))
{
errorMessages.Add(string.Format("Could not parse the date provided {0}.", attributeDatetime));
}
}
}
// get add to group
addToGroup = GetAttributeValue(action, "AddToGroup").AsBoolean();
// get campus
Guid campusGuid = Guid.Empty;
Guid campusAttributeGuid = GetAttributeValue(action, "Campus").AsGuid();
if (!campusAttributeGuid.IsEmpty())
{
var campusAttribute = AttributeCache.Read(campusAttributeGuid, rockContext);
if (campusAttribute != null)
{
campusGuid = action.GetWorklowAttributeValue(campusAttributeGuid).AsGuid();
}
}
// set attribute
if (groupGuid.HasValue && person != null && attendanceDateTime != DateTime.MinValue)
{
var group = new GroupService(rockContext).Queryable("GroupType.DefaultGroupRole")
.Where(g => g.Guid == groupGuid)
.FirstOrDefault();
if (group != null)
{
GroupMemberService groupMemberService = new GroupMemberService(rockContext);
// get group member
var groupMember = groupMemberService.Queryable()
.Where(m => m.Group.Guid == groupGuid &&
m.PersonId == person.Id)
.FirstOrDefault();
if (groupMember == null)
{
if (addToGroup)
{
if (group != null)
{
groupMember = new GroupMember();
groupMember.GroupId = group.Id;
groupMember.PersonId = person.Id;
groupMember.GroupMemberStatus = GroupMemberStatus.Active;
groupMember.GroupRole = group.GroupType.DefaultGroupRole;
groupMemberService.Add(groupMember);
rockContext.SaveChanges();
}
}
else
{
action.AddLogEntry(string.Format("{0} was not a member of the group {1} and the action was not configured to add them.", person.FullName, group.Name));
return(true);
}
}
AttendanceService attendanceService = new AttendanceService(rockContext);
Attendance attendance = new Attendance();
attendance.GroupId = group.Id;
attendance.PersonAliasId = person.PrimaryAliasId;
attendance.StartDateTime = attendanceDateTime;
attendance.DidAttend = true;
if (campusGuid != Guid.Empty)
{
var campus = new CampusService(rockContext).Queryable().AsNoTracking()
.Where(l => l.Guid == campusGuid)
.FirstOrDefault();
if (campus != null)
{
attendance.CampusId = campus.Id;
}
}
attendanceService.Add(attendance);
rockContext.SaveChanges();
}
else
{
errorMessages.Add(string.Format("Could not find group matching the guid '{0}'.", groupGuid));
}
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(true);
}
/// <summary>
/// Gets the expression.
/// </summary>
/// <param name="entityType">Type of the entity.</param>
/// <param name="serviceInstance">The service instance.</param>
/// <param name="parameterExpression">The parameter expression.</param>
/// <param name="selection">The selection.</param>
/// <returns></returns>
public override Expression GetExpression(Type entityType, IService serviceInstance, ParameterExpression parameterExpression, string selection)
{
var rockContext = (RockContext)serviceInstance.Context;
string[] selectionValues = selection.Split('|');
if (selectionValues.Length < 4)
{
return(null);
}
ComparisonType comparisonType = selectionValues[0].ConvertToEnum <ComparisonType>(ComparisonType.GreaterThanOrEqualTo);
decimal amount = selectionValues[1].AsDecimalOrNull() ?? 0.00M;
DateTime? startDate = selectionValues[2].AsDateTime();
DateTime? endDate = selectionValues[3].AsDateTime();
var accountIdList = new List <int>();
if (selectionValues.Length >= 5)
{
var accountGuids = selectionValues[4].Split(',').Select(a => a.AsGuid()).ToList();
accountIdList = new FinancialAccountService((RockContext)serviceInstance.Context).GetByGuids(accountGuids).Select(a => a.Id).ToList();
}
bool combineGiving = false;
if (selectionValues.Length >= 6)
{
combineGiving = selectionValues[5].AsBooleanOrNull() ?? false;
}
int transactionTypeContributionId = Rock.Web.Cache.DefinedValueCache.Read(Rock.SystemGuid.DefinedValue.TRANSACTION_TYPE_CONTRIBUTION.AsGuid()).Id;
var financialTransactionQry = new FinancialTransactionService(rockContext).Queryable()
.Where(xx => xx.AuthorizedPersonAliasId.HasValue)
.Where(xx => xx.TransactionTypeValueId == transactionTypeContributionId);
if (startDate.HasValue)
{
financialTransactionQry = financialTransactionQry.Where(xx => xx.TransactionDateTime >= startDate.Value);
}
if (endDate.HasValue)
{
financialTransactionQry = financialTransactionQry.Where(xx => xx.TransactionDateTime < endDate.Value);
}
bool limitToAccounts = accountIdList.Any();
// Create an explicit join to person alias so that rendered SQL is an INNER Join vs OUTER join
var personAliasQry = new PersonAliasService(rockContext).Queryable();
var financialTransactionGivingGroupQry = financialTransactionQry
.Join(personAliasQry, t => t.AuthorizedPersonAliasId, p => p.Id, (t, p) => new
{
Txn = t,
GivingGroupId = p.Person.GivingGroupId
});
// query transactions for individuals.
// If CombineGiving, exclude people that are Giving Group, and we'll get those when we union with CombineGiving
var financialTransactionDetailsIndividualQry = financialTransactionGivingGroupQry.Where(a => !combineGiving || !a.GivingGroupId.HasValue).Select(a => a.Txn)
.GroupBy(xx => xx.AuthorizedPersonAlias.PersonId
).Select(xx =>
new
{
PersonId = xx.Key,
TotalAmount = xx.Sum(ss => ss.TransactionDetails.Where(td => !limitToAccounts || accountIdList.Contains(td.AccountId)).Sum(td => td.Amount))
});
if (comparisonType == ComparisonType.LessThan)
{
financialTransactionDetailsIndividualQry = financialTransactionDetailsIndividualQry.Where(xx => xx.TotalAmount < amount);
}
else if (comparisonType == ComparisonType.EqualTo)
{
financialTransactionDetailsIndividualQry = financialTransactionDetailsIndividualQry.Where(xx => xx.TotalAmount == amount);
}
else if (comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
financialTransactionDetailsIndividualQry = financialTransactionDetailsIndividualQry.Where(xx => xx.TotalAmount >= amount);
}
var innerQryIndividual = financialTransactionDetailsIndividualQry.Select(xx => xx.PersonId).AsQueryable();
IQueryable <int> qryTransactionPersonIds;
if (combineGiving)
{
// if CombineGiving=true, do another query to total by GivingGroupId for people with GivingGroupId specified
var financialTransactionDetailsGivingGroupQry = financialTransactionGivingGroupQry.Where(a => a.GivingGroupId.HasValue)
.GroupBy(xx => new
{
xx.GivingGroupId
}).Select(xx =>
new
{
GivingGroupId = xx.Key,
TotalAmount = xx.Sum(ss => ss.Txn.TransactionDetails.Where(td => !limitToAccounts || accountIdList.Contains(td.AccountId)).Sum(td => td.Amount))
});
if (comparisonType == ComparisonType.LessThan)
{
financialTransactionDetailsGivingGroupQry = financialTransactionDetailsGivingGroupQry.Where(xx => xx.TotalAmount < amount);
}
else if (comparisonType == ComparisonType.EqualTo)
{
financialTransactionDetailsGivingGroupQry = financialTransactionDetailsGivingGroupQry.Where(xx => xx.TotalAmount == amount);
}
else if (comparisonType == ComparisonType.GreaterThanOrEqualTo)
{
financialTransactionDetailsGivingGroupQry = financialTransactionDetailsGivingGroupQry.Where(xx => xx.TotalAmount >= amount);
}
var groupMemberService = new GroupMemberService(rockContext);
IQueryable <int> innerQryGivingGroupPersons = groupMemberService.Queryable()
.Where(a => financialTransactionDetailsGivingGroupQry.Select(xx => xx.GivingGroupId).AsQueryable().Any(gg => gg.GivingGroupId == a.GroupId))
.Select(s => s.PersonId);
// include people that either give as individuals or are members of a giving group
qryTransactionPersonIds = innerQryIndividual.Union(innerQryGivingGroupPersons);
}
else
{
// don't factor in GivingGroupId. Only include people that are directly associated with the transaction
qryTransactionPersonIds = innerQryIndividual;
}
var qry = new PersonService(rockContext).Queryable()
.Where(p => qryTransactionPersonIds.Any(xx => xx == p.Id));
Expression extractedFilterExpression = FilterExpressionExtractor.Extract <Rock.Model.Person>(qry, parameterExpression, "p");
return(extractedFilterExpression);
}
/// <summary>
/// Process inbound messages that are sent to a SMS number.
/// </summary>
/// <param name="toPhone">The phone number a message is sent to.</param>
/// <param name="fromPhone">The phone number a message is sent from.</param>
/// <param name="message">The message that was sent.</param>
/// <param name="errorMessage">The error message.</param>
public void ProcessResponse(string toPhone, string fromPhone, string message, out string errorMessage)
{
errorMessage = string.Empty;
string transportPhone = string.Empty;
using (var rockContext = new RockContext())
{
Person toPerson = null;
var mobilePhoneNumberValueId = DefinedValueCache.Get(SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE).Id;
var cleanFromPhone = fromPhone.Replace("+", "");
//
// Get the person who sent the message. Filter to any matching phone number, regardless
// of type. Then order by those with a matching number and SMS enabled; then further order
// by matching number with type == mobile; finally order by person Id to get the oldest
// person to get the oldest person in the case of duplicate records.
//
var fromPerson = new PersonService(rockContext).Queryable()
.Where(p => p.PhoneNumbers.Any(n => (n.CountryCode + n.Number) == cleanFromPhone))
.OrderByDescending(p => p.PhoneNumbers.Any(n => (n.CountryCode + n.Number) == cleanFromPhone && n.IsMessagingEnabled))
.ThenByDescending(p => p.PhoneNumbers.Any(n => (n.CountryCode + n.Number) == cleanFromPhone && n.NumberTypeValueId == mobilePhoneNumberValueId))
.ThenBy(p => p.Id)
.FirstOrDefault();
// get recipient from defined value
var fromPhoneDv = FindFromPhoneDefinedValue(toPhone);
if (fromPhoneDv != null)
{
var toPersonAliasGuid = fromPhoneDv.GetAttributeValue("ResponseRecipient").AsGuidOrNull();
if (toPersonAliasGuid.HasValue)
{
toPerson = new PersonAliasService(rockContext)
.Queryable().Where(p => p.Guid.Equals(toPersonAliasGuid.Value))
.Select(p => p.Person)
.FirstOrDefault();
}
}
if (fromPerson != null && toPerson != null && fromPerson.PrimaryAliasId.HasValue && toPerson.PrimaryAliasId.HasValue)
{
if (toPerson.Id == fromPerson.Id) // message from the medium recipient
{
// look for response code in the message
Match match = Regex.Match(message, @"@\d{3,5}");
if (match.Success)
{
string responseCode = match.ToString();
var recipient = new CommunicationRecipientService(rockContext).Queryable("Communication")
.Where(r => r.ResponseCode == responseCode)
.OrderByDescending(r => r.CreatedDateTime).FirstOrDefault();
if (recipient != null && recipient.Communication.SenderPersonAliasId.HasValue)
{
CreateCommunication(fromPerson.PrimaryAliasId.Value, fromPerson.FullName, recipient.Communication.SenderPersonAliasId.Value, message.Replace(responseCode, ""), fromPhoneDv, "", rockContext);
}
else // send a warning message back to the medium recipient
{
string warningMessage = string.Format("A conversation could not be found with the response token {0}.", responseCode);
CreateCommunication(fromPerson.PrimaryAliasId.Value, fromPerson.FullName, fromPerson.PrimaryAliasId.Value, warningMessage, fromPhoneDv, "", rockContext);
}
}
}
else // response from someone other than the medium recipient
{
string messageId = GenerateResponseCode(rockContext);
message = string.Format("-{0}-\n{1}\n( {2} )", fromPerson.FullName, message, messageId);
CreateCommunication(fromPerson.PrimaryAliasId.Value, fromPerson.FullName, toPerson.PrimaryAliasId.Value, message, fromPhoneDv, messageId, rockContext);
}
}
else
{
var globalAttributes = GlobalAttributesCache.Get();
string organizationName = globalAttributes.GetValue("OrganizationName");
errorMessage = string.Format("Could not deliver message. This phone number is not registered in the {0} database.", organizationName);
}
}
}
/// <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>
public override bool Execute(RockContext rockContext, WorkflowAction action, object entity, out List <string> errorMessages)
{
errorMessages = new List <string>();
var actionType = action.ActionTypeCache;
if (!action.LastProcessedDateTime.HasValue &&
actionType != null &&
actionType.WorkflowForm != null &&
actionType.WorkflowForm.NotificationSystemEmailId.HasValue)
{
if (action.Activity != null && (action.Activity.AssignedPersonAliasId.HasValue || action.Activity.AssignedGroupId.HasValue))
{
var recipients = new List <RecipientData>();
var workflowMergeFields = GetMergeFields(action);
if (action.Activity.AssignedPersonAliasId.HasValue)
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Id == action.Activity.AssignedPersonAliasId.Value)
.Select(a => a.Person)
.FirstOrDefault();
if (person != null && !string.IsNullOrWhiteSpace(person.Email))
{
recipients.Add(new RecipientData(person.Email, CombinePersonMergeFields(person, workflowMergeFields)));
action.AddLogEntry(string.Format("Form notification sent to '{0}'", person.FullName));
}
}
if (action.Activity.AssignedGroupId.HasValue)
{
var personList = new GroupMemberService(rockContext).GetByGroupId(action.Activity.AssignedGroupId.Value)
.Where(m =>
m.GroupMemberStatus == GroupMemberStatus.Active &&
m.Person.Email != "")
.Select(m => m.Person)
.ToList();
foreach (var person in personList)
{
recipients.Add(new RecipientData(person.Email, CombinePersonMergeFields(person, workflowMergeFields)));
action.AddLogEntry(string.Format("Form notification sent to '{0}'", person.FullName));
}
}
if (recipients.Count > 0)
{
// The email may need to reference activity Id, so we need to save here.
WorkflowService workflowService = new WorkflowService(rockContext);
workflowService.PersistImmediately(action);
var systemEmail = new SystemEmailService(rockContext).Get(action.ActionTypeCache.WorkflowForm.NotificationSystemEmailId.Value);
if (systemEmail != null)
{
var emailMessage = new RockEmailMessage(systemEmail);
emailMessage.SetRecipients(recipients);
emailMessage.CreateCommunicationRecord = false;
emailMessage.AppRoot = GlobalAttributesCache.Get().GetValue("InternalApplicationRoot") ?? string.Empty;
emailMessage.Send();
}
else
{
action.AddLogEntry("Could not find the selected notification system email", true);
}
}
else
{
action.AddLogEntry("Could not send form notification due to no assigned person or group member not having email address", true);
}
}
else
{
action.AddLogEntry("Could not send form notification due to no assigned person or group", 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>();
// get person
int?personId = null;
string personAttributeValue = GetAttributeValue(action, "Person");
Guid? guidPersonAttribute = personAttributeValue.AsGuidOrNull();
if (guidPersonAttribute.HasValue)
{
var attributePerson = AttributeCache.Get(guidPersonAttribute.Value, rockContext);
if (attributePerson != null && attributePerson.FieldType.Class == "Rock.Field.Types.PersonFieldType")
{
string attributePersonValue = action.GetWorklowAttributeValue(guidPersonAttribute.Value);
if (!string.IsNullOrWhiteSpace(attributePersonValue))
{
Guid personAliasGuid = attributePersonValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
personId = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.PersonId)
.FirstOrDefault();
if (personId == null)
{
errorMessages.Add(string.Format("Person could not be found for selected value ('{0}')!", guidPersonAttribute.ToString()));
return(false);
}
}
}
}
}
if (personId == null)
{
errorMessages.Add("The attribute used to provide the person was invalid, or not of type 'Person'.");
return(false);
}
// determine the phone type to edit
DefinedValueCache phoneType = null;
var phoneTypeAttributeValue = action.GetWorklowAttributeValue(GetAttributeValue(action, "PhoneTypeAttribute").AsGuid());
if (phoneTypeAttributeValue != null)
{
phoneType = DefinedValueCache.Get(phoneTypeAttributeValue.AsGuid());
}
if (phoneType == null)
{
phoneType = DefinedValueCache.Get(GetAttributeValue(action, "PhoneType").AsGuid());
}
if (phoneType == null)
{
errorMessages.Add("The phone type to be updated was not selected.");
return(false);
}
// get the ignore blank setting
var ignoreBlanks = GetActionAttributeValue(action, "IgnoreBlankValues").AsBoolean(true);
// get the new phone number value
string phoneNumberValue = GetAttributeValue(action, "PhoneNumber");
Guid? phoneNumberValueGuid = phoneNumberValue.AsGuidOrNull();
if (phoneNumberValueGuid.HasValue)
{
phoneNumberValue = action.GetWorklowAttributeValue(phoneNumberValueGuid.Value);
}
else
{
phoneNumberValue = phoneNumberValue.ResolveMergeFields(GetMergeFields(action));
}
phoneNumberValue = PhoneNumber.CleanNumber(phoneNumberValue);
// gets value indicating if phone number is unlisted
string unlistedValue = GetAttributeValue(action, "Unlisted");
Guid? unlistedValueGuid = unlistedValue.AsGuidOrNull();
if (unlistedValueGuid.HasValue)
{
unlistedValue = action.GetWorklowAttributeValue(unlistedValueGuid.Value);
}
else
{
unlistedValue = unlistedValue.ResolveMergeFields(GetMergeFields(action));
}
bool?unlisted = unlistedValue.AsBooleanOrNull();
// gets value indicating if messaging should be enabled for phone number
string smsEnabledValue = GetAttributeValue(action, "MessagingEnabled");
Guid? smsEnabledValueGuid = smsEnabledValue.AsGuidOrNull();
if (smsEnabledValueGuid.HasValue)
{
smsEnabledValue = action.GetWorklowAttributeValue(smsEnabledValueGuid.Value);
}
else
{
smsEnabledValue = smsEnabledValue.ResolveMergeFields(GetMergeFields(action));
}
bool?smsEnabled = smsEnabledValue.AsBooleanOrNull();
bool updated = false;
bool newPhoneNumber = false;
var phoneNumberService = new PhoneNumberService(rockContext);
var phoneNumber = phoneNumberService.Queryable()
.Where(n =>
n.PersonId == personId.Value &&
n.NumberTypeValueId == phoneType.Id)
.FirstOrDefault();
string oldValue = string.Empty;
if (phoneNumber == null)
{
phoneNumber = new PhoneNumber {
NumberTypeValueId = phoneType.Id, PersonId = personId.Value
};
newPhoneNumber = true;
updated = true;
}
else
{
oldValue = phoneNumber.NumberFormattedWithCountryCode;
}
if (!string.IsNullOrWhiteSpace(phoneNumberValue) || !ignoreBlanks)
{
updated = updated || phoneNumber.Number != phoneNumberValue;
phoneNumber.Number = phoneNumberValue;
}
if (unlisted.HasValue)
{
updated = updated || phoneNumber.IsUnlisted != unlisted.Value;
phoneNumber.IsUnlisted = unlisted.Value;
}
if (smsEnabled.HasValue)
{
updated = updated || phoneNumber.IsMessagingEnabled != smsEnabled.Value;
phoneNumber.IsMessagingEnabled = smsEnabled.Value;
}
if (updated)
{
if (oldValue != phoneNumber.NumberFormattedWithCountryCode)
{
var changes = new History.HistoryChangeList();
changes.AddChange(History.HistoryVerb.Modify, History.HistoryChangeType.Record, "Phone").SetSourceOfChange($"{action.ActionTypeCache.ActivityType.WorkflowType.Name} workflow");
HistoryService.SaveChanges(rockContext, typeof(Person), Rock.SystemGuid.Category.HISTORY_PERSON_DEMOGRAPHIC_CHANGES.AsGuid(), personId.Value, changes, false);
}
if (phoneNumber.Number.IsNullOrWhiteSpace())
{
if (!newPhoneNumber)
{
phoneNumberService.Delete(phoneNumber);
}
}
else
{
if (newPhoneNumber)
{
phoneNumberService.Add(phoneNumber);
}
}
rockContext.SaveChanges();
if (action.Activity != null && action.Activity.Workflow != null)
{
var workflowType = action.Activity.Workflow.WorkflowTypeCache;
if (workflowType != null && workflowType.LoggingLevel == WorkflowLoggingLevel.Action)
{
var person = new PersonService(rockContext).Get(personId.Value);
action.AddLogEntry(string.Format("Updated {0} phone for {1} to {2}.", phoneType.Value, person.FullName, phoneNumber.NumberFormattedWithCountryCode));
}
}
}
return(true);
}
/// <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>
/// Gets either a delimited string of email addresses or a list of recipients from an attribute value.
/// </summary>
/// <param name="recipientType">The recipient type.</param>
/// <param name="attributeValue">The attribute value.</param>
/// <param name="action">The action.</param>
/// <param name="mergeFields">The merge fields.</param>
/// <param name="rockContext">The rock context.</param>
/// <param name="delimitedEmails">The delimited emails.</param>
/// <param name="recipientList">The recipient list.</param>
/// <returns></returns>
private bool GetEmailsFromAttributeValue(RecipientType recipientType, string attributeValue, WorkflowAction action, Dictionary <string, object> mergeFields, RockContext rockContext, out string delimitedEmails, out List <RockEmailMessageRecipient> recipientList)
{
delimitedEmails = null;
recipientList = null;
Guid?guid = attributeValue.AsGuidOrNull();
if (guid.HasValue)
{
var attribute = AttributeCache.Get(guid.Value, rockContext);
if (attribute != null)
{
var recipientTypePrefix = string.Empty;
var groupRoleAttributeKey = AttributeKey.GroupRole;
switch (recipientType)
{
case RecipientType.CC:
recipientTypePrefix = "CC ";
break;
case RecipientType.BCC:
recipientTypePrefix = "BCC ";
break;
}
string toValue = action.GetWorkflowAttributeValue(guid.Value);
if (!string.IsNullOrWhiteSpace(toValue))
{
switch (attribute.FieldType.Class)
{
case "Rock.Field.Types.TextFieldType":
case "Rock.Field.Types.EmailFieldType":
{
delimitedEmails = toValue;
return(true);
}
case "Rock.Field.Types.PersonFieldType":
{
Guid personAliasGuid = toValue.AsGuid();
if (!personAliasGuid.IsEmpty())
{
var person = new PersonAliasService(rockContext).Queryable()
.Where(a => a.Guid.Equals(personAliasGuid))
.Select(a => a.Person)
.FirstOrDefault();
if (person == null)
{
action.AddLogEntry($"Invalid {recipientTypePrefix}Recipient: Person not found", true);
}
else if (string.IsNullOrWhiteSpace(person.Email))
{
action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient does not have an email address", true);
}
else if (!person.IsEmailActive)
{
action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient email is not active", true);
}
else if (person.EmailPreference == EmailPreference.DoNotEmail)
{
action.AddLogEntry($"{recipientTypePrefix}Email was not sent: Recipient has requested 'Do Not Email'", true);
}
else
{
var personDict = new Dictionary <string, object>(mergeFields)
{
{ "Person", person }
};
recipientList = new List <RockEmailMessageRecipient> {
new RockEmailMessageRecipient(person, personDict)
};
return(true);
}
}
return(false);
}
case "Rock.Field.Types.GroupFieldType":
case "Rock.Field.Types.SecurityRoleFieldType":
{
int? groupId = toValue.AsIntegerOrNull();
Guid?groupGuid = toValue.AsGuidOrNull();
/*
* 2020-03-25 - JPH
*
* Per Jon, even though the user may select a Group or Security Role Attribute for the CC and BCC
* Attributes, we only want to allow Group Role filtering for the 'Send To Email Addresses' Attribute.
* Otherwise, the UI starts to become too overwhelming for the end user making the selections.
*/
Guid?groupRoleValueGuid = recipientType == RecipientType.SendTo ?
GetGroupRoleValueGuid(action, groupRoleAttributeKey) :
null;
IQueryable <GroupMember> qry = null;
// Handle situations where the attribute value is the ID
if (groupId.HasValue)
{
qry = new GroupMemberService(rockContext).GetByGroupId(groupId.Value);
}
else if (groupGuid.HasValue)
{
// Handle situations where the attribute value stored is the Guid
qry = new GroupMemberService(rockContext).GetByGroupGuid(groupGuid.Value);
}
else
{
action.AddLogEntry($"Invalid {recipientTypePrefix}Recipient: No valid group id or Guid", true);
}
if (groupRoleValueGuid.HasValue)
{
qry = qry.Where(m => m.GroupRole != null && m.GroupRole.Guid.Equals(groupRoleValueGuid.Value));
}
if (qry != null)
{
recipientList = new List <RockEmailMessageRecipient>();
foreach (var person in qry
.Where(m => m.GroupMemberStatus == GroupMemberStatus.Active)
.Select(m => m.Person))
{
if (person.IsEmailActive &&
person.EmailPreference != EmailPreference.DoNotEmail &&
!string.IsNullOrWhiteSpace(person.Email))
{
var personDict = new Dictionary <string, object>(mergeFields)
{
{ "Person", person }
};
recipientList.Add(new RockEmailMessageRecipient(person, personDict));
}
}
return(true);
}
return(false);
}
}
}
}
}
else if (!string.IsNullOrWhiteSpace(attributeValue))
{
delimitedEmails = attributeValue;
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.Read(guidPersonAttribute.Value, rockContext);
if (attributePerson != null)
{
string attributePersonValue = action.GetWorklowAttributeValue(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 groupMemberService = new GroupMemberService(rockContext);
var groupMember = new GroupMember();
groupMember.PersonId = person.Id;
groupMember.GroupId = group.Id;
groupMember.GroupRoleId = groupRoleId.Value;
groupMember.GroupMemberStatus = this.GetAttributeValue(action, "GroupMemberStatus").ConvertToEnum <GroupMemberStatus>(GroupMemberStatus.Active);
if (groupMember.IsValidGroupMember(rockContext))
{
groupMemberService.Add(groupMember);
rockContext.SaveChanges();
if (group.IsSecurityRole || group.GroupType.Guid.Equals(Rock.SystemGuid.GroupType.GROUPTYPE_SECURITY_ROLE.AsGuid()))
{
Rock.Security.Role.Flush(group.Id);
}
}
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>
/// Binds the grid.
/// </summary>
private void BindGrid()
{
var rockContext = new RockContext();
var groupMemberService = new GroupMemberService(rockContext);
var groupService = new GroupService(rockContext);
var groupTypeService = new GroupTypeService(rockContext);
var attributeService = new AttributeService(rockContext);
var attributeValueService = new AttributeValueService(rockContext);
var personService = new PersonService(rockContext);
var personAliasService = new PersonAliasService(rockContext);
var entityTypeService = new EntityTypeService(rockContext);
var registrationRegistrantService = new RegistrationRegistrantService(rockContext);
var eiogmService = new EventItemOccurrenceGroupMapService(rockContext);
var groupLocationService = new GroupLocationService(rockContext);
var locationService = new LocationService(rockContext);
var signatureDocumentServce = new SignatureDocumentService(rockContext);
var phoneNumberService = new PhoneNumberService(rockContext);
int[] signatureDocumentIds = { };
if (!string.IsNullOrWhiteSpace(GetAttributeValue("SignatureDocumentTemplates")))
{
signatureDocumentIds = Array.ConvertAll(GetAttributeValue("SignatureDocumentTemplates").Split(','), int.Parse);
}
int[] registrationInstanceIds = { };
if (!string.IsNullOrWhiteSpace(GetAttributeValue("RegistrationInstances")))
{
registrationInstanceIds = Array.ConvertAll(GetAttributeValue("RegistrationInstances").Split(','), int.Parse);
}
Guid bbGroup = GetAttributeValue("Group").AsGuid();
var group = new GroupService(rockContext).Get(bbGroup);
Guid hsmGroupTypeGuid = GetAttributeValue("MSMGroupType").AsGuid();
int? hsmGroupTypeId = groupTypeService.Queryable().Where(gt => gt.Guid == hsmGroupTypeGuid).Select(gt => gt.Id).FirstOrDefault();
int entityTypeId = entityTypeService.Queryable().Where(et => et.Name == typeof(Rock.Model.Group).FullName).FirstOrDefault().Id;
var registrationTemplateIds = eiogmService.Queryable().Where(r => r.GroupId == group.Id).Select(m => m.RegistrationInstance.RegistrationTemplateId.ToString()).ToList();
hlGroup.NavigateUrl = "/group/" + group.Id;
var attributeIds = attributeService.Queryable()
.Where(a => (a.EntityTypeQualifierColumn == "GroupId" && a.EntityTypeQualifierValue == group.Id.ToString()) ||
(a.EntityTypeQualifierColumn == "GroupTypeId" && a.EntityTypeQualifierValue == group.GroupTypeId.ToString()) ||
(a.EntityTypeQualifierColumn == "RegistrationTemplateId" && registrationTemplateIds.Contains(a.EntityTypeQualifierValue)))
.Select(a => a.Id).ToList();
var gmTmpqry = groupMemberService.Queryable()
.Where(gm => (gm.GroupId == group.Id));
var qry = gmTmpqry
.Join(personAliasService.Queryable(),
obj => obj.PersonId,
pa => pa.PersonId,
(obj, pa) => new { GroupMember = obj, PersonAlias = pa }
)
.Join(registrationRegistrantService.Queryable(),
obj => obj.PersonAlias.Id,
rr => rr.PersonAliasId,
(obj, rr) => new { GroupMember = obj.GroupMember, Person = obj.GroupMember.Person, RegistrationRegistrant = rr })
.GroupJoin(attributeValueService.Queryable(),
obj => new { PersonId = (int?)obj.Person.Id, AttributeId = 739 },
av => new { PersonId = av.EntityId, av.AttributeId },
(obj, av) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, School = av.Select(s => s.Value).FirstOrDefault() })
.GroupJoin(attributeValueService.Queryable(),
obj => obj.GroupMember.Id,
av => av.EntityId.Value,
(obj, avs) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, GroupMemberAttributeValues = avs.Where(av => attributeIds.Contains(av.AttributeId)), School = obj.School /*, Location = obj.Location */ })
.GroupJoin(attributeValueService.Queryable(),
obj => obj.RegistrationRegistrant.Id,
av => av.EntityId.Value,
(obj, avs) => new { GroupMember = obj.GroupMember, Person = obj.Person, RegistrationRegistrant = obj.RegistrationRegistrant, GroupMemberAttributeValues = obj.GroupMemberAttributeValues, RegistrationAttributeValues = avs.Where(av => attributeIds.Contains(av.AttributeId)), School = obj.School /*, Location = obj.Location */ })
.Where(obj => registrationInstanceIds.Contains(obj.RegistrationRegistrant.Registration.RegistrationInstanceId));
var qry2 = gmTmpqry
.GroupJoin(
groupMemberService.Queryable()
.Join(groupService.Queryable(),
gm => new { Id = gm.GroupId, GroupTypeId = 10 },
g => new { g.Id, g.GroupTypeId },
(gm, g) => new { GroupMember = gm, Group = g })
.Join(groupLocationService.Queryable(),
obj => new { GroupId = obj.Group.Id, GroupLocationTypeValueId = (int?)19 },
gl => new { gl.GroupId, gl.GroupLocationTypeValueId },
(g, gl) => new { GroupMember = g.GroupMember, GroupLocation = gl })
.Join(locationService.Queryable(),
obj => obj.GroupLocation.LocationId,
l => l.Id,
(obj, l) => new { GroupMember = obj.GroupMember, Location = l }),
gm => gm.PersonId,
glgm => glgm.GroupMember.PersonId,
(obj, l) => new { GroupMember = obj, Location = l.Select(loc => loc.Location).FirstOrDefault() }
)
.GroupJoin(signatureDocumentServce.Queryable()
.Join(personAliasService.Queryable(),
sd => sd.AppliesToPersonAliasId,
pa => pa.Id,
(sd, pa) => new { SignatureDocument = sd, Alias = pa }),
obj => obj.GroupMember.PersonId,
sd => sd.Alias.PersonId,
(obj, sds) => new { GroupMember = obj.GroupMember, Location = obj.Location, SignatureDocuments = sds })
.GroupJoin(phoneNumberService.Queryable(),
obj => obj.GroupMember.PersonId,
p => p.PersonId,
(obj, pn) => new { GroupMember = obj.GroupMember, Location = obj.Location, SignatureDocuments = obj.SignatureDocuments, PhoneNumbers = pn });
if (!String.IsNullOrWhiteSpace(GetUserPreference(string.Format("{0}PersonName", keyPrefix))))
{
string personName = GetUserPreference(string.Format("{0}PersonName", keyPrefix)).ToLower();
qry = qry.ToList().Where(q => q.GroupMember.Person.FullName.ToLower().Contains(personName)).AsQueryable();
}
decimal?lowerVal = GetUserPreference(string.Format("{0}BalanceOwedLower", keyPrefix)).AsDecimalOrNull();
decimal?upperVal = GetUserPreference(string.Format("{0}BalanceOwedUpper", keyPrefix)).AsDecimalOrNull();
if (lowerVal != null && upperVal != null)
{
qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue >= lowerVal && q.RegistrationRegistrant.Registration.BalanceDue <= upperVal).AsQueryable();
}
else if (lowerVal != null)
{
qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue >= lowerVal).AsQueryable();
}
else if (upperVal != null)
{
qry = qry.ToList().Where(q => q.RegistrationRegistrant.Registration.BalanceDue <= upperVal).AsQueryable();
}
else if (!string.IsNullOrEmpty(cmpCampus.SelectedValue))
{
CampusCache campus = CampusCache.Get(cmpCampus.SelectedCampusId.Value);
qry = qry.ToList().Where(q => q.RegistrationAttributeValues.Where(ra => ra.AttributeKey == "Whichcampus" && ra.Value.Contains(campus.Name.Replace(" ", ""))).Any()).AsQueryable();
}
var stopwatch = new Stopwatch();
stopwatch.Start();
var tmp = qry.ToList();
var tmp2 = qry2.ToList();
lStats.Text = "Query Runtime: " + stopwatch.Elapsed;
stopwatch.Reset();
stopwatch.Start();
var newQry = tmp.Select(g => new
{
Id = g.GroupMember.Id,
RegisteredBy = new ModelValue <Person>(g.RegistrationRegistrant.Registration.PersonAlias.Person),
Registrant = new ModelValue <Person>(g.Person),
Age = g.Person.Age,
GraduationYear = g.Person.GraduationYear,
RegistrationId = g.RegistrationRegistrant.RegistrationId,
Group = new ModelValue <Rock.Model.Group>((Rock.Model.Group)g.GroupMember.Group),
DOB = g.Person.BirthDate.HasValue ? g.Person.BirthDate.Value.ToShortDateString() : "",
Address = new ModelValue <Rock.Model.Location>((Rock.Model.Location)tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location).FirstOrDefault()),
Email = g.Person.Email,
Gender = g.Person.Gender, // (B & B Registration)
GraduationYearProfile = g.Person.GraduationYear, // (Person Profile)
HomePhone = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.PhoneNumbers).Where(pn => pn.NumberTypeValue.Guid == Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_HOME.AsGuid()).Select(pn => pn.NumberFormatted).FirstOrDefault(),
CellPhone = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.PhoneNumbers).Where(pn => pn.NumberTypeValue.Guid == Rock.SystemGuid.DefinedValue.PERSON_PHONE_TYPE_MOBILE.AsGuid()).Select(pn => pn.NumberFormatted).FirstOrDefault(),
GroupMemberData = new Func <GroupMemberAttributes>(() =>
{
GroupMemberAttributes gma = new GroupMemberAttributes(g.GroupMember, g.Person, g.GroupMemberAttributeValues);
return(gma);
})(),
RegistrantData = new Func <RegistrantAttributes>(() =>
{
RegistrantAttributes row = new RegistrantAttributes(g.RegistrationRegistrant, g.RegistrationAttributeValues);
return(row);
})(),
School = string.IsNullOrEmpty(g.School)?"":DefinedValueCache.Get(g.School.AsGuid()) != null?DefinedValueCache.Get(g.School.AsGuid()).Value:"",
LegalRelease = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).SelectMany(gm => gm.SignatureDocuments).OrderByDescending(sd => sd.SignatureDocument.CreatedDateTime).Where(sd => signatureDocumentIds.Contains(sd.SignatureDocument.SignatureDocumentTemplateId)).Select(sd => sd.SignatureDocument.SignatureDocumentTemplate.Name + " (" + sd.SignatureDocument.Status.ToString() + ")").FirstOrDefault(),
Departure = g.GroupMemberAttributeValues.Where(av => av.AttributeKey == "Departure").Select(av => av.Value).FirstOrDefault(),
Campus = group.Campus, //
Role = group.ParentGroup.GroupType.Name.Contains("Serving") || group.Name.ToLower().Contains("leader")? "Leader":"Student", //
MSMGroup = String.Join(", ", groupMemberService.Queryable().Where(gm => gm.PersonId == g.GroupMember.PersonId && gm.Group.GroupTypeId == hsmGroupTypeId && gm.GroupMemberStatus == GroupMemberStatus.Active).Select(gm => gm.Group.Name).ToList()),
Person = g.Person,
AddressStreet = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location != null?gm.Location.Street1:"").FirstOrDefault(),
AddressCityStateZip = tmp2.Where(gm => gm.GroupMember.Id == g.GroupMember.Id).Select(gm => gm.Location != null ? gm.Location.City + ", " + gm.Location.State + " " + gm.Location.PostalCode : "").FirstOrDefault(),
RegistrantName = g.Person.FullName,
}).OrderBy(w => w.Registrant.Model.LastName).ToList().AsQueryable();
lStats.Text += "<br />Object Build Runtime: " + stopwatch.Elapsed;
stopwatch.Stop();
gReport.GetRecipientMergeFields += GReport_GetRecipientMergeFields;
var mergeFields = new List <String>();
mergeFields.Add("Id");
mergeFields.Add("RegisteredBy");
mergeFields.Add("Group");
mergeFields.Add("Registrant");
mergeFields.Add("Age");
mergeFields.Add("GraduationYear");
mergeFields.Add("DOB");
mergeFields.Add("Address");
mergeFields.Add("Email");
mergeFields.Add("Gender");
mergeFields.Add("GraduationYearProfile");
mergeFields.Add("HomePhone");
mergeFields.Add("CellPhone");
mergeFields.Add("GroupMemberData");
mergeFields.Add("RegistrantData");
mergeFields.Add("LegalRelease");
mergeFields.Add("Departure");
mergeFields.Add("Campus");
mergeFields.Add("Role");
mergeFields.Add("MSMGroup");
gReport.CommunicateMergeFields = mergeFields;
/*
* if (!String.IsNullOrWhiteSpace(GetUserPreference(string.Format("{0}POA", keyPrefix))))
* {
* string poa = GetUserPreference(string.Format("{0}POA", keyPrefix));
* if (poa == "[Blank]")
* {
* poa = "";
* }
* newQry = newQry.Where(q => q.GroupMemberData.POA == poa);
* }
*/
SortProperty sortProperty = gReport.SortProperty;
if (sortProperty != null)
{
gReport.SetLinqDataSource(newQry.Sort(sortProperty));
}
else
{
gReport.SetLinqDataSource(newQry.OrderBy(p => p.Registrant.Model.LastName));
}
gReport.DataBind();
}
/// <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 attribute = AttributeCache.Get(GetAttributeValue(action, "PersonAttribute").AsGuid(), rockContext);
if (attribute != null)
{
var mergeFields = GetMergeFields(action);
string firstName = GetAttributeValue(action, "FirstName", true).ResolveMergeFields(mergeFields);
string lastName = GetAttributeValue(action, "LastName", true).ResolveMergeFields(mergeFields);
string email = GetAttributeValue(action, "Email", true).ResolveMergeFields(mergeFields);
string phone = GetAttributeValue(action, "Phone", true).ResolveMergeFields(mergeFields);
DateTime?dateofBirth = GetAttributeValue(action, "DOB", true).AsDateTime();
Guid? addressGuid = GetAttributeValue(action, "Address", true).AsGuidOrNull();
Guid? familyOrPersonGuid = GetAttributeValue(action, "FamilyAttribute", true).AsGuidOrNull();
Location address = null;
// Set the street and postal code if we have an address
if (addressGuid.HasValue)
{
LocationService addressService = new LocationService(rockContext);
address = addressService.Get(addressGuid.Value);
}
if (string.IsNullOrWhiteSpace(firstName) ||
string.IsNullOrWhiteSpace(lastName) ||
(string.IsNullOrWhiteSpace(email) &&
string.IsNullOrWhiteSpace(phone) &&
!dateofBirth.HasValue &&
(address == null || address != null && string.IsNullOrWhiteSpace(address.Street1)))
)
{
errorMessages.Add("First Name, Last Name, and one of Email, Phone, DoB, or Address Street are required. One or more of these values was not provided!");
}
else
{
Rock.Model.Person person = null;
PersonAlias personAlias = null;
var personService = new PersonService(rockContext);
var people = personService.GetByMatch(firstName, lastName, dateofBirth, email, phone, address?.Street1, address?.PostalCode).ToList();
if (people.Count == 1 &&
// Make sure their email matches. If it doesn't, we need to go ahead and create a new person to be matched later.
(string.IsNullOrWhiteSpace(email) ||
(people.First().Email != null &&
email.ToLower().Trim() == people.First().Email.ToLower().Trim()))
)
{
person = people.First();
personAlias = person.PrimaryAlias;
}
else if (!GetAttributeValue(action, "MatchOnly").AsBoolean())
{
// Add New Person
person = new Rock.Model.Person();
person.FirstName = firstName;
person.LastName = lastName;
person.IsEmailActive = true;
person.Email = email;
if (dateofBirth.HasValue)
{
person.BirthDay = dateofBirth.Value.Day;
person.BirthMonth = dateofBirth.Value.Month;
person.BirthYear = dateofBirth.Value.Year;
}
person.EmailPreference = EmailPreference.EmailAllowed;
person.RecordTypeValueId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.PERSON_RECORD_TYPE_PERSON.AsGuid()).Id;
var defaultConnectionStatus = DefinedValueCache.Get(GetAttributeValue(action, "DefaultConnectionStatus").AsGuid());
if (defaultConnectionStatus != null)
{
person.ConnectionStatusValueId = defaultConnectionStatus.Id;
}
var defaultRecordStatus = DefinedValueCache.Get(GetAttributeValue(action, "DefaultRecordStatus").AsGuid());
if (defaultRecordStatus != null)
{
person.RecordStatusValueId = defaultRecordStatus.Id;
}
var defaultCampus = CampusCache.Get(GetAttributeValue(action, "DefaultCampus", true).AsGuid());
// Get the default family if applicable
Group family = null;
if (familyOrPersonGuid.HasValue)
{
PersonAliasService personAliasService = new PersonAliasService(rockContext);
family = personAliasService.Get(familyOrPersonGuid.Value)?.Person?.GetFamily();
if (family == null)
{
GroupService groupService = new GroupService(rockContext);
family = groupService.Get(familyOrPersonGuid.Value);
}
}
var familyGroup = SaveNewPerson(person, family, (defaultCampus != null ? defaultCampus.Id : ( int? )null), rockContext);
if (familyGroup != null && familyGroup.Members.Any())
{
personAlias = person.PrimaryAlias;
// If we have an address, go ahead and save it here.
if (address != null)
{
GroupLocation location = new GroupLocation();
location.GroupLocationTypeValueId = DefinedValueCache.Get(Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_HOME).Id;
location.Location = address;
familyGroup.GroupLocations.Add(location);
}
}
// Save/update the phone number
if (!string.IsNullOrWhiteSpace(phone))
{
List <string> changes = new List <string>();
var numberType = DefinedValueCache.Get(GetAttributeValue(action, "PhoneNumberType").AsGuid());
if (numberType != null)
{
// gets value indicating if phone number is unlisted
string unlistedValue = GetAttributeValue(action, "Unlisted");
Guid? unlistedValueGuid = unlistedValue.AsGuidOrNull();
if (unlistedValueGuid.HasValue)
{
unlistedValue = action.GetWorklowAttributeValue(unlistedValueGuid.Value);
}
else
{
unlistedValue = unlistedValue.ResolveMergeFields(GetMergeFields(action));
}
bool unlisted = unlistedValue.AsBoolean();
// gets value indicating if messaging should be enabled for phone number
string smsEnabledValue = GetAttributeValue(action, "MessagingEnabled");
Guid? smsEnabledValueGuid = smsEnabledValue.AsGuidOrNull();
if (smsEnabledValueGuid.HasValue)
{
smsEnabledValue = action.GetWorklowAttributeValue(smsEnabledValueGuid.Value);
}
else
{
smsEnabledValue = smsEnabledValue.ResolveMergeFields(GetMergeFields(action));
}
bool smsEnabled = smsEnabledValue.AsBoolean();
var phoneModel = person.PhoneNumbers.FirstOrDefault(p => p.NumberTypeValueId == numberType.Id);
string oldPhoneNumber = phoneModel != null ? phoneModel.NumberFormattedWithCountryCode : string.Empty;
string newPhoneNumber = PhoneNumber.CleanNumber(phone);
if (newPhoneNumber != string.Empty && newPhoneNumber != oldPhoneNumber)
{
if (phoneModel == null)
{
phoneModel = new PhoneNumber();
person.PhoneNumbers.Add(phoneModel);
phoneModel.NumberTypeValueId = numberType.Id;
}
else
{
oldPhoneNumber = phoneModel.NumberFormattedWithCountryCode;
}
phoneModel.Number = newPhoneNumber;
phoneModel.IsUnlisted = unlisted;
phoneModel.IsMessagingEnabled = smsEnabled;
}
}
}
}
if (person != null && personAlias != null)
{
SetWorkflowAttributeValue(action, attribute.Guid, personAlias.Guid.ToString());
action.AddLogEntry(string.Format("Set '{0}' attribute to '{1}'.", attribute.Name, person.FullName));
return(true);
}
else if (!GetAttributeValue(action, "MatchOnly").AsBoolean())
{
errorMessages.Add("Person or Primary Alias could not be determined!");
}
}
}
else
{
errorMessages.Add("Person Attribute could not be found!");
}
if (errorMessages.Any())
{
errorMessages.ForEach(m => action.AddLogEntry(m, true));
if (GetAttributeValue(action, "ContinueOnError").AsBoolean())
{
errorMessages.Clear();
return(true);
}
else
{
return(false);
}
}
return(true);
}
/// <summary>
/// Gets the suggestions.
/// </summary>
/// <param name="followingSuggestionType">Type of the following suggestion.</param>
/// <param name="followerPersonIds">The follower person ids.</param>
/// <returns></returns>
public override List <PersonEntitySuggestion> GetSuggestions(FollowingSuggestionType followingSuggestionType, List <int> followerPersonIds)
{
var suggestions = new List <PersonEntitySuggestion>();
var groupEntityType = EntityTypeCache.Get(typeof(Rock.Model.Group));
var personAliasEntityType = EntityTypeCache.Get(typeof(Rock.Model.PersonAlias));
bool isAutoFollow = GetAttributeValue(followingSuggestionType, "AutoFollow").AsBoolean();
// Get the grouptype guid
Guid?groupTypeGuid = GetAttributeValue(followingSuggestionType, "GroupType").AsGuidOrNull();
if (groupTypeGuid.HasValue)
{
using (var rockContext = new RockContext())
{
var followingService = new FollowingService(rockContext);
var groupMemberService = new GroupMemberService(rockContext);
var personAliasService = new PersonAliasService(rockContext);
var followings = followingService.Queryable()
.Where(a => a.EntityTypeId == groupEntityType.Id &&
followerPersonIds.Contains(a.PersonAlias.PersonId))
.Select(f => new
{
f.PersonAliasId,
f.PersonAlias.PersonId,
f.EntityId
}).Distinct()
.ToList();
var followedGroup = followings.Select(a => a.EntityId).Distinct().ToList();
// Get all the groupmember records of Followed group
var followedGroupMembersQry = groupMemberService.Queryable().AsNoTracking()
.Where(m =>
m.GroupMemberStatus == GroupMemberStatus.Active &&
m.Group != null &&
m.Group.IsActive && !m.Group.IsArchived &&
m.Group.GroupType.Guid.Equals(groupTypeGuid.Value) &&
followedGroup.Contains(m.GroupId));
// If a specific role for the people being followed was specified, limit the query to only those with the selected role
Guid?groupRoleGuid = GetAttributeValue(followingSuggestionType, "GroupRole").AsGuidOrNull();
if (groupRoleGuid.HasValue)
{
followedGroupMembersQry = followedGroupMembersQry.Where(m => m.GroupRole.Guid.Equals(groupRoleGuid.Value));
}
var followedGroupMembers = followedGroupMembersQry.ToList();
// Run the query to get all the groups that follower is a member of with selected filters
var followerPersonGroups = followings
.Select(f => new
{
GroupMembers = followedGroupMembers.Where(a => a.GroupId == f.EntityId).ToList(),
f.PersonAliasId,
f.PersonId
})
.ToList();
var followedMembersList = followedGroupMembers
.Select(a => a.PersonId)
.Distinct()
.ToList();
// Build a dictionary of the personid->personaliasid
var personAliasIds = new Dictionary <int, int>();
personAliasService.Queryable().AsNoTracking()
.Where(a =>
followedMembersList.Contains(a.PersonId) &&
a.PersonId == a.AliasPersonId)
.ToList()
.ForEach(a => personAliasIds.AddOrIgnore(a.PersonId, a.Id));
// Loop through each follower/group combination
foreach (var followerPersonGroup in followerPersonGroups)
{
// Loop through the other people in that group
foreach (var member in followerPersonGroup.GroupMembers)
{
if (!isAutoFollow)
{
// add them to the list of suggestions
suggestions.Add(new PersonEntitySuggestion(followerPersonGroup.PersonId, personAliasIds[member.PersonId]));
}
else
{
// auto-add the follow
int followeePersonAliasId = personAliasIds[member.PersonId];
// if person is not already following the person
bool isFollowing = followingService.Queryable().Where(f =>
f.EntityTypeId == personAliasEntityType.Id &&
f.EntityId == followeePersonAliasId &&
f.PersonAliasId == followerPersonGroup.PersonAliasId).Any();
if (!isFollowing)
{
var following = new Following();
following.EntityTypeId = personAliasEntityType.Id;
following.EntityId = followeePersonAliasId;
following.PersonAliasId = followerPersonGroup.PersonAliasId;
followingService.Add(following);
rockContext.SaveChanges();
}
}
}
}
}
}
return(suggestions);
}
/// <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>();
// Get the connection request
ConnectionRequest request = null;
Guid connectionRequestGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "ConnectionRequestAttribute").AsGuid()).AsGuid();
request = new ConnectionRequestService(rockContext).Get(connectionRequestGuid);
if (request == null)
{
errorMessages.Add("Invalid Connection Request Attribute or Value!");
return(false);
}
// Get the activity type
ConnectionActivityType activityType = null;
Guid activityTypeGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "ConnectionActivityTypeAttribute").AsGuid()).AsGuid();
activityType = new ConnectionActivityTypeService(rockContext).Get(activityTypeGuid);
if (activityType == null)
{
errorMessages.Add("Invalid Connection Activity Type Attribute or Value!");
return(false);
}
// Get the note
string noteValue = GetAttributeValue(action, "Note");
string note = string.Empty;
Guid? noteGuid = noteValue.AsGuidOrNull();
if (noteGuid.HasValue)
{
var attribute = AttributeCache.Read(noteGuid.Value, rockContext);
if (attribute != null)
{
note = action.GetWorklowAttributeValue(noteGuid.Value);
}
}
else
{
note = noteValue;
}
// Get the connector
int? personAliasId = null;
Guid?personAttributeGuid = GetAttributeValue(action, "PersonAttribute").AsGuidOrNull();
if (personAttributeGuid.HasValue)
{
Guid?personAliasGuid = action.GetWorklowAttributeValue(personAttributeGuid.Value).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid.Value);
if (personAlias != null)
{
personAliasId = personAlias.Id;
}
}
}
// Add the activity
var activity = new ConnectionRequestActivity();
activity.ConnectionRequestId = request.Id;
activity.ConnectionActivityTypeId = activityType.Id;
activity.ConnectionOpportunityId = request.ConnectionOpportunityId;
activity.ConnectorPersonAliasId = personAliasId;
activity.Note = note;
new ConnectionRequestActivityService(rockContext).Add(activity);
rockContext.SaveChanges();
return(true);
}
/// <summary>
/// Handles the filter display for each saved user value
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
protected void rFilter_DisplayFilterValue(object sender, GridFilter.DisplayFilterValueArgs e)
{
switch (e.Key)
{
case "Start Date":
case "End Date":
var dateTime = e.Value.AsDateTime();
if (dateTime.HasValue)
{
e.Value = dateTime.Value.ToShortDateString();
}
else
{
e.Value = null;
}
return;
case "First Name":
return;
case "Last Name":
return;
case "Campus":
{
int?campusId = e.Value.AsIntegerOrNull();
if (campusId.HasValue)
{
e.Value = CampusCache.Get(campusId.Value).Name;
}
return;
}
case "Government ID":
return;
case "Case Worker":
int?personAliasId = e.Value.AsIntegerOrNull();
if (personAliasId.HasValue)
{
var personAlias = new PersonAliasService(new RockContext()).Get(personAliasId.Value);
if (personAlias != null)
{
e.Value = personAlias.Person.FullName;
}
}
return;
case "Result":
case "Status":
var definedValueId = e.Value.AsIntegerOrNull();
if (definedValueId.HasValue)
{
var definedValue = DefinedValueCache.Get(definedValueId.Value);
if (definedValue != null)
{
e.Value = definedValue.Value;
}
}
return;
default:
e.Value = string.Empty;
return;
}
}
/// <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)
{
Guid checkinGroupAttributeGuid = GetAttributeValue(action, "CheckinGroupAttribute").AsGuid();
if (checkinGroupAttributeGuid == Guid.Empty)
{
throw new Exception("CheckInGroupAttribute not set. Set attribute to continue.");
}
string checkinGroupAttributeKey = AttributeCache.Get(checkinGroupAttributeGuid).Key;
string sessionAttributeKey = GetAttributeValue(action, "SessionAttributeKey");
AttendanceCode attendanceCode = null;
DateTime startDateTime = RockDateTime.Now;
bool reuseCodeForFamily = checkInState.CheckInType != null && checkInState.CheckInType.ReuseSameCode;
int securityCodeLength = checkInState.CheckInType != null ? checkInState.CheckInType.SecurityCodeAlphaNumericLength : 3;
AttendanceCodeService attendanceCodeService = new AttendanceCodeService(rockContext);
AttendanceService attendanceService = new AttendanceService(rockContext);
GroupMemberService groupMemberService = new GroupMemberService(rockContext);
PersonAliasService personAliasService = new PersonAliasService(rockContext);
GroupService groupService = new GroupService(rockContext);
var family = checkInState.CheckIn.CurrentFamily;
if (family != null)
{
foreach (var person in family.GetPeople(true))
{
if (reuseCodeForFamily && attendanceCode != null)
{
person.SecurityCode = attendanceCode.Code;
}
else
{
attendanceCode = AttendanceCodeService.GetNew(securityCodeLength);
person.SecurityCode = attendanceCode.Code;
}
foreach (var groupType in person.GetGroupTypes(true))
{
foreach (var group in groupType.GetGroups(true))
{
var referenceGroupGuid = group.Group.GetAttributeValue(checkinGroupAttributeKey).AsGuid();
var referenceGroup = groupService.Get(referenceGroupGuid);
if (referenceGroup == null)
{
group.Selected = false;
continue;
}
GroupMember groupMember = groupMemberService.GetByGroupIdAndPersonId(referenceGroup.Id, person.Person.Id).FirstOrDefault();
if (groupMember == null)
{
group.Selected = false;
continue;
}
groupMember.LoadAttributes();
int sessions = groupMember.GetAttributeValue(sessionAttributeKey).AsInteger();
foreach (var location in group.GetLocations(true))
{
foreach (var schedule in location.GetSchedules(true))
{
if (sessions == 0)
{
continue;
}
// Only create one attendance record per day for each person/schedule/group/location
var attendance = attendanceService.Get(startDateTime, location.Location.Id, schedule.Schedule.Id, group.Group.Id, person.Person.Id);
if (attendance == null)
{
var primaryAlias = personAliasService.GetPrimaryAlias(person.Person.Id);
if (primaryAlias != null)
{
attendance = attendanceService.AddOrUpdate(primaryAlias.Id, startDateTime.Date, group.Group.Id,
location.Location.Id, schedule.Schedule.Id, location.CampusId,
checkInState.Kiosk.Device.Id, checkInState.CheckIn.SearchType.Id,
checkInState.CheckIn.SearchValue, family.Group.Id, attendanceCode.Id);
attendanceService.Add(attendance);
}
//decrement sessions and save
sessions--;
groupMember.SetAttributeValue(sessionAttributeKey, sessions);
groupMember.SaveAttributeValues();
}
else
{
foreach (var cPerson in checkInState.CheckIn.Families.SelectMany(f => f.People))
{
cPerson.Selected = false;
cPerson.GroupTypes.ForEach(gt => gt.Selected = false);
}
return(true);
}
attendance.AttendanceCodeId = attendanceCode.Id;
attendance.StartDateTime = startDateTime;
attendance.EndDateTime = null;
attendance.DidAttend = true;
KioskLocationAttendance.AddAttendance(attendance);
}
}
}
}
}
}
rockContext.SaveChanges();
return(true);
}
errorMessages.Add($"Attempted to run {this.GetType().GetFriendlyTypeName()} in check-in, but the check-in state was null.");
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>();
var mergeFields = GetMergeFields(action);
// Get the connection request
ConnectionRequest connectionRequest = null;
Guid connectionRequestGuid = action.GetWorklowAttributeValue(GetAttributeValue(action, "ConnectionRequestAttribute").AsGuid()).AsGuid();
connectionRequest = new ConnectionRequestService(rockContext).Get(connectionRequestGuid);
if (connectionRequest == null)
{
errorMessages.Add("Invalid Connection Request Attribute or Value!");
return(false);
}
// Get the connector
int? personAliasId = null;
Guid?personAttributeGuid = GetAttributeValue(action, "PersonAttribute").AsGuidOrNull();
if (personAttributeGuid.HasValue)
{
Guid?personAliasGuid = action.GetWorklowAttributeValue(personAttributeGuid.Value).AsGuidOrNull();
if (personAliasGuid.HasValue)
{
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid.Value);
if (personAlias != null)
{
personAliasId = personAlias.Id;
}
}
else
{
errorMessages.Add("Invalid Person Attribute or Value!");
return(false);
}
}
// Set the connector to the connection
if (!connectionRequest.ConnectorPersonAliasId.HasValue || !GetAttributeValue(action, "Ignore").AsBoolean())
{
int?oldConnectorPersonAliasId = connectionRequest.ConnectorPersonAliasId;
int?newConnectorPersonAliasId = personAliasId;
connectionRequest.ConnectorPersonAliasId = newConnectorPersonAliasId;
rockContext.SaveChanges();
if (newConnectorPersonAliasId.HasValue && !newConnectorPersonAliasId.Equals(oldConnectorPersonAliasId))
{
var guid = Rock.SystemGuid.ConnectionActivityType.ASSIGNED.AsGuid();
var assignedActivityId = new ConnectionActivityTypeService(rockContext).Queryable()
.Where(t => t.Guid == guid)
.Select(t => t.Id)
.FirstOrDefault();
if (assignedActivityId > 0)
{
var connectionRequestActivityService = new ConnectionRequestActivityService(rockContext);
var connectionRequestActivity = new ConnectionRequestActivity();
connectionRequestActivity.ConnectionRequestId = connectionRequest.Id;
connectionRequestActivity.ConnectionOpportunityId = connectionRequest.ConnectionOpportunityId;
connectionRequestActivity.ConnectionActivityTypeId = assignedActivityId;
connectionRequestActivity.ConnectorPersonAliasId = newConnectorPersonAliasId;
connectionRequestActivityService.Add(connectionRequestActivity);
rockContext.SaveChanges();
}
}
}
return(true);
}
/// <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>();
if (entity != null && entity is IEntity)
{
Guid guid = GetAttributeValue(action, "Attribute").AsGuid();
if (!guid.IsEmpty())
{
var attribute = AttributeCache.Get(guid, rockContext);
if (attribute != null)
{
// If a lava template was specified, use that to set the attribute value
string lavaTemplate = GetAttributeValue(action, "LavaTemplate");
if (!string.IsNullOrWhiteSpace(lavaTemplate))
{
var mergeFields = GetMergeFields(action);
mergeFields.Add("Entity", entity);
string parsedValue = lavaTemplate.ResolveMergeFields(mergeFields);
SetWorkflowAttributeValue(action, guid, parsedValue);
}
else
{
// Person is handled special since it needs the person alias id
if (entity is Person && attribute.FieldTypeId == FieldTypeCache.Get(SystemGuid.FieldType.PERSON.AsGuid(), rockContext).Id)
{
var person = (Person)entity;
var primaryAlias = new PersonAliasService(rockContext).Queryable().FirstOrDefault(a => a.AliasPersonId == person.Id);
if (primaryAlias != null)
{
SetWorkflowAttributeValue(action, guid, primaryAlias.Guid.ToString());
return(true);
}
else
{
errorMessages.Add("Person Entity: Could not determine person's primary alias. PersonId=" + person.Id);
}
}
else
{
if (GetAttributeValue(action, "UseId").AsBoolean())
{
SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Id.ToString());
}
else
{
SetWorkflowAttributeValue(action, guid, ((IEntity)entity).Guid.ToString());
}
}
}
return(true);
}
else
{
errorMessages.Add("Unable to find the attribute from the attribute GUID=" + guid.ToStringSafe());
}
}
else
{
errorMessages.Add("Unable to find the attribute GUID.");
}
}
else
{
if (!GetAttributeValue(action, "EntityIsRequired").AsBoolean(true))
{
return(true);
}
errorMessages.Add("No entity was specified or the entity is not a Rock Entity.");
}
errorMessages.ForEach(m => action.AddLogEntry(m, true));
return(false);
}
/// <summary>
/// logic to setup the groups location entry panel
/// </summary>
/// <param name="group">The group.</param>
private void ConfigureGroupLocationControls(Group group)
{
var rockContext = new RockContext();
ddlMember.Items.Clear();
var groupType = GroupTypeCache.Read(group.GroupTypeId);
if (groupType != null)
{
// only allow editing groups with single locations
if (!groupType.AllowMultipleLocations)
{
GroupLocationPickerMode groupTypeModes = groupType.LocationSelectionMode;
if (groupTypeModes != GroupLocationPickerMode.None)
{
// Set the location picker modes allowed based on the group type's allowed modes
LocationPickerMode modes = LocationPickerMode.None;
if ((groupTypeModes & GroupLocationPickerMode.Named) == GroupLocationPickerMode.Named)
{
modes = modes | LocationPickerMode.Named;
}
if ((groupTypeModes & GroupLocationPickerMode.Address) == GroupLocationPickerMode.Address)
{
modes = modes | LocationPickerMode.Address;
}
if ((groupTypeModes & GroupLocationPickerMode.Point) == GroupLocationPickerMode.Point)
{
modes = modes | LocationPickerMode.Point;
}
if ((groupTypeModes & GroupLocationPickerMode.Polygon) == GroupLocationPickerMode.Polygon)
{
modes = modes | LocationPickerMode.Polygon;
}
bool displayMemberTab = (groupTypeModes & GroupLocationPickerMode.GroupMember) == GroupLocationPickerMode.GroupMember;
bool displayOtherTab = modes != LocationPickerMode.None;
ulNav.Visible = displayOtherTab && displayMemberTab;
pnlMemberSelect.Visible = displayMemberTab;
pnlLocationSelect.Visible = displayOtherTab && !displayMemberTab;
if (displayMemberTab)
{
var personService = new PersonService(rockContext);
Guid previousLocationType = Rock.SystemGuid.DefinedValue.GROUP_LOCATION_TYPE_PREVIOUS.AsGuid();
foreach (GroupMember member in new GroupMemberService(rockContext).GetByGroupId(group.Id))
{
foreach (Group family in personService.GetFamilies(member.PersonId))
{
foreach (GroupLocation familyGroupLocation in family.GroupLocations
.Where(l => l.IsMappedLocation && !l.GroupLocationTypeValue.Guid.Equals(previousLocationType)))
{
ListItem li = new ListItem(
string.Format("{0} {1} ({2})", member.Person.FullName, familyGroupLocation.GroupLocationTypeValue.Value, familyGroupLocation.Location.ToString()),
string.Format("{0}|{1}", familyGroupLocation.Location.Id, member.PersonId));
ddlMember.Items.Add(li);
}
}
}
}
if (displayOtherTab)
{
locpGroupLocation.AllowedPickerModes = modes;
}
ddlLocationType.DataSource = groupType.LocationTypeValues.ToList();
ddlLocationType.DataBind();
LocationTypeTab = (displayMemberTab && ddlMember.Items.Count > 0) ? MEMBER_LOCATION_TAB_TITLE : OTHER_LOCATION_TAB_TITLE;
var groupLocation = group.GroupLocations.FirstOrDefault();
if (groupLocation != null && groupLocation.Location != null)
{
if (displayOtherTab)
{
locpGroupLocation.SetBestPickerModeForLocation(groupLocation.Location);
locpGroupLocation.MapStyleValueGuid = GetAttributeValue("MapStyle").AsGuid();
if (groupLocation.Location != null)
{
locpGroupLocation.Location = new LocationService(rockContext).Get(groupLocation.Location.Id);
}
}
if (displayMemberTab && ddlMember.Items.Count > 0 && groupLocation.GroupMemberPersonAliasId.HasValue)
{
LocationTypeTab = MEMBER_LOCATION_TAB_TITLE;
int?personId = new PersonAliasService(rockContext).GetPersonId(groupLocation.GroupMemberPersonAliasId.Value);
if (personId.HasValue)
{
ddlMember.SetValue(string.Format("{0}|{1}", groupLocation.LocationId, personId.Value));
}
}
else if (displayOtherTab)
{
LocationTypeTab = OTHER_LOCATION_TAB_TITLE;
}
ddlLocationType.SetValue(groupLocation.GroupLocationTypeValueId);
}
else
{
LocationTypeTab = (displayMemberTab && ddlMember.Items.Count > 0) ? MEMBER_LOCATION_TAB_TITLE : OTHER_LOCATION_TAB_TITLE;
}
rptLocationTypes.DataSource = _tabs;
rptLocationTypes.DataBind();
ShowSelectedPane();
}
}
else
{
lContent.Text = "<div class='alert alert-warning'>This editor only allows editing groups with a single location.</div>";
}
}
}
/// <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)
{
/*
* 2019-12-09 - ED
* This activity will create a new assessment for each assessment type selected. If an assessment already exists for that type it is left in a pending status but a new assessment is still created.
* Per Jon, code in Rock should account for the possibility of multiple assessments for a type that are in a pending state and only select the latest one.
*/
rockContext = rockContext ?? new RockContext();
errorMessages = new List <string>();
var assessmentTypesGuidString = GetAttributeValue(action, AttributeKey.AssessmentTypesKey, true);
var assessmentTypeGuids = assessmentTypesGuidString.IsNullOrWhiteSpace() ? null : assessmentTypesGuidString.Split(new char[] { ',' });
var personAliasGuid = GetAttributeValue(action, AttributeKey.Person, true).AsGuidOrNull();
Guid?requestedByAliasGuid = GetAttributeValue(action, AttributeKey.RequestedBy, true).AsGuidOrNull();
var dueDate = GetAttributeValue(action, AttributeKey.DueDate, true).AsDateTime();
// Validate attribute data
if (!assessmentTypeGuids.Any())
{
errorMessages.Add("No Assessments selected.");
return(false);
}
if (personAliasGuid == null)
{
errorMessages.Add("Invalid Person Attribute or Value.");
return(false);
}
var personAlias = new PersonAliasService(rockContext).Get(personAliasGuid.Value);
if (personAlias == null)
{
errorMessages.Add("Invalid Person Attribute or Value.");
return(false);
}
PersonAlias requestedByAlias = null;
if (requestedByAliasGuid != null)
{
requestedByAlias = new PersonAliasService(rockContext).Get(requestedByAliasGuid.Value);
}
foreach (string assessmentTypeGuid in assessmentTypeGuids)
{
var assessmentTypeService = new AssessmentTypeService(rockContext);
int?assessmentTypeId = assessmentTypeService.GetId(assessmentTypeGuid.AsGuid());
if (assessmentTypeId == null)
{
// This really shouldn't be able to happen, but let's not risk an NRE.
errorMessages.Add($"Invalid Assessment Type: {assessmentTypeGuid}");
continue;
}
// Create a new assessment
var assessment = new Assessment
{
PersonAliasId = personAlias.Id,
AssessmentTypeId = assessmentTypeId.Value,
RequesterPersonAliasId = requestedByAlias?.Id,
RequestedDateTime = RockDateTime.Now,
RequestedDueDate = dueDate,
Status = AssessmentRequestStatus.Pending
};
var assessmentService = new AssessmentService(rockContext);
assessmentService.Add(assessment);
rockContext.SaveChanges();
}
return(true);
}
