public void SendMessageFromDonor(int pledgeId, int donationId, string message)
{
var toDonor = _pledgeService.GetDonorForPledge(pledgeId);
var donorContact = _donorService.GetEmailViaDonorId(toDonor);
var template = _communicationService.GetTemplate(_tripDonationMessageTemplateId);
var toContacts = new List <MpContact> {
new MpContact {
ContactId = donorContact.ContactId, EmailAddress = donorContact.Email
}
};
var from = new MpContact()
{
ContactId = 5,
EmailAddress = "*****@*****.**"
};
var comm = new MpCommunication
{
AuthorUserId = 5,
DomainId = 1,
EmailBody = message,
EmailSubject = template.Subject,
FromContact = from,
ReplyToContact = from,
ToContacts = toContacts,
MergeData = new Dictionary <string, object>()
};
var communicationId = _communicationService.SendMessage(comm, true);
AddDonationCommunication(donationId, communicationId);
}
public void ShouldSendTripEmail()
{
const int formResponseId = 12345;
const int contactId = 1234;
const int pledgeCampaignId = 9876;
var mycontact = new MpMyContact
{
Contact_ID = 7,
Email_Address = "*****@*****.**"
};
var to = new MpContact
{
ContactId = 8,
EmailAddress = "*****@*****.**"
};
var tolist = new List <MpContact> {
to
};
var mpc = new MpCommunication
{
AuthorUserId = 1,
DomainId = 1,
EmailBody = "body",
EmailSubject = "subject",
FromContact = to,
MergeData = new Dictionary <string, object>(),
ReplyToContact = to,
StartDate = new DateTime(2011, 10, 11),
TemplateId = 444,
ToContacts = tolist
};
_campaignService.Setup(m => m.GetPledgeCampaign(pledgeCampaignId)).Returns(mockPledgeCampaign());
_donationService.Setup(m => m.GetMyTripDistributions(contactId)).Returns(MockTripScholarshipDonationsResponse());
_formSubmissionService.Setup(f => f.SubmitFormResponse(It.IsAny <MpFormResponse>())).Returns(formResponseId);
_communicationService.Setup(
s =>
s.GetTemplateAsCommunication(It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <int>(),
It.IsAny <string>(),
It.IsAny <Dictionary <string, object> >())).Returns(mpc);
_communicationService.Setup(s => s.SendMessage(mpc, false)).Returns(9999);
_contactService.Setup(s => s.GetContactById(It.IsAny <int>())).Returns(mycontact);
var result = _fixture.SaveApplication(mockTripApplication(contactId, pledgeCampaignId));
Assert.IsTrue(result == formResponseId);
_configurationWrapper.Verify(v => v.GetConfigIntValue("TripApplicantSuccessTemplate"), Times.Exactly(1));
}
public void SendParticipantsEmail(string token, List <GroupParticipantDTO> participants, string subject, string body)
{
var senderRecord = _participantService.GetParticipantRecord(token);
var fromContact = new MpContact
{
ContactId = 1519180,
EmailAddress = "*****@*****.**"
};
var replyToContact = new MpContact
{
ContactId = senderRecord.ContactId,
EmailAddress = senderRecord.EmailAddress
};
var toContacts = participants.Select(p => new MpContact
{
ContactId = p.ContactId,
EmailAddress = p.Email
}).ToList();
var email = new MinistryPlatform.Translation.Models.MpCommunication
{
EmailBody = body,
EmailSubject = subject,
AuthorUserId = 5,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyToContact,
ToContacts = toContacts
};
_communicationService.SendMessage(email);
}
public void SendEmail(CommunicationDTO emailData)
{
var replyToContactId = emailData.ReplyToContactId ?? DefaultContactEmailId;
var from = new MpContact {
ContactId = DefaultContactEmailId, EmailAddress = _communicationService.GetEmailFromContactId(DefaultContactEmailId)
};
var replyTo = new MpContact {
ContactId = replyToContactId, EmailAddress = _communicationService.GetEmailFromContactId(replyToContactId)
};
var comm = new MpCommunication
{
AuthorUserId = DefaultAuthorUserId,
DomainId = DomainID,
EmailBody = emailData.Body,
EmailSubject = emailData.Subject,
FromContact = from,
ReplyToContact = replyTo,
MergeData = new Dictionary <string, object>(),
ToContacts = new List <MpContact>()
};
foreach (var to in emailData.ToContactIds)
{
var contact = new MpContact {
ContactId = to, EmailAddress = _communicationService.GetEmailFromContactId(to)
};
comm.ToContacts.Add(contact);
}
_communicationService.SendMessage(comm);
}
public void SendAllGroupLeadersEmail(string token, int groupId, GroupMessageDTO message)
{
var requestor = _participantRepository.GetParticipantRecord(token);
var requestorContact = _contactRepository.GetContactById(requestor.ContactId);
var group = _groupService.GetGroupDetails(groupId);
var fromContact = new MpContact
{
ContactId = _defaultGroupContactEmailId,
EmailAddress = "*****@*****.**"
};
var replyToContact = new MpContact
{
ContactId = requestor.ContactId,
EmailAddress = requestor.EmailAddress
};
var leaders = @group.Participants.
Where(groupParticipant => groupParticipant.GroupRoleId == _groupRoleLeaderId).
Select(groupParticipant => new MpContact
{
ContactId = groupParticipant.ContactId,
EmailAddress = groupParticipant.Email,
LastName = groupParticipant.LastName,
Nickname = groupParticipant.NickName
}).ToList();
var fromString = "<p><i>This email was sent from: " + requestorContact.Nickname + " " + requestorContact.Last_Name + " (" + requestor.EmailAddress + ")</i></p>";
var toString = "<p><i>This email was sent to: ";
foreach (var item in leaders)
{
toString += item.Nickname + " " + item.LastName + " (" + item.EmailAddress + "), ";
}
char[] trailingChars = { ',', ' ' };
toString = toString.TrimEnd(trailingChars);
toString += "</i></p>";
var email = new MpCommunication
{
EmailBody = fromString + "<p>" + message.Body + "</p>" + toString,
EmailSubject = $"Crossroads Group {@group.GroupName}: {message.Subject}",
AuthorUserId = _defaultAuthorUserId,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyToContact,
ToContacts = leaders
};
_communicationRepository.SendMessage(email);
}
public void SendAllGroupLeadersMemberRemovedEmail(string token, int groupId)
{
var requestorParticipant = _participantService.GetParticipantRecord(token);
var group = this.GetGroupDetails(groupId);
var leaders = @group.Participants.
Where(groupParticipant => groupParticipant.GroupRoleId == _groupRoleLeader).
Select(groupParticipant => new MpContact
{
ContactId = groupParticipant.ContactId,
EmailAddress = groupParticipant.Email,
LastName = groupParticipant.LastName,
Nickname = groupParticipant.NickName
}).ToList();
var mergeData = new Dictionary <string, object>
{
{ "Group_Participant_Name", requestorParticipant.DisplayName },
{ "Group_Name", group.GroupName },
};
int emailTemplateId = _removeSelfFromGroupTemplateId;
var emailTemplate = _communicationService.GetTemplate(emailTemplateId);
var fromContact = new MpContact
{
ContactId = emailTemplate.FromContactId,
EmailAddress = emailTemplate.FromEmailAddress
};
var replyTo = new MpContact
{
ContactId = emailTemplate.ReplyToContactId,
EmailAddress = emailTemplate.ReplyToEmailAddress
};
var message = new MinistryPlatform.Translation.Models.MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = _defaultAuthorUserId,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyTo,
TemplateId = emailTemplateId,
ToContacts = leaders,
MergeData = mergeData
};
_communicationService.SendMessage(message);
}
public void SendNewStudentMinistryGroupAlertEmail(List <MpGroupParticipant> leaders)
{
var emailTemplate = _communicationService.GetTemplate(NewStudentMinistryGroupAlertEmailTemplate);
const string toEmail = "*****@*****.**";
string formattedData = "<ul> ";
foreach (var participant in leaders)
{
formattedData += $"<li>Name: {participant.NickName} {participant.LastName} Email: {participant.Email} </li>";
}
var mergeData = new Dictionary <string, object>
{
{ "Leaders", formattedData + "</ul>" }
};
var domainId = Convert.ToInt32(AppSettings("DomainId"));
var from = new MpContact()
{
ContactId = DefaultEmailContactId,
EmailAddress = _communicationService.GetEmailFromContactId(DefaultEmailContactId)
};
var to = new List <MpContact>
{
new MpContact
{
ContactId = _contactService.GetContactIdByEmail(toEmail),
EmailAddress = toEmail
}
};
var newStudentMinistryGroup = new MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = 5,
DomainId = domainId,
FromContact = from,
MergeData = mergeData,
ReplyToContact = from,
TemplateId = NewStudentMinistryGroupAlertEmailTemplate,
ToContacts = to
};
_communicationService.SendMessage(newStudentMinistryGroup);
}
public void SendCommunityGroupConfirmationEmail(int participantId, int groupId, bool waitlist, bool childcareNeeded)
{
var emailTemplate = _communicationService.GetTemplate(waitlist ? CommunityGroupWaitListConfirmationTemplateId : CommunityGroupConfirmationTemplateId);
var toContact = _contactService.GetContactIdByParticipantId(participantId);
var toContactInfo = _contactService.GetContactById(toContact);
var groupInfo = getGroupDetails(groupId);
var mergeData = new Dictionary <string, object>
{
{ "Nickname", toContactInfo.Nickname },
{ "Group_Name", groupInfo.Name },
{ "Congregation_Name", groupInfo.Congregation },
{ "Childcare_Needed", (childcareNeeded) ? _contentBlockService["communityGroupChildcare"].Content : "" },
{ "Base_Url", _configurationWrapper.GetConfigValue("BaseUrl") }
};
var domainId = Convert.ToInt32(AppSettings("DomainId"));
var from = new MpContact()
{
ContactId = DefaultEmailContactId,
EmailAddress = _communicationService.GetEmailFromContactId(DefaultEmailContactId)
};
var to = new List <MpContact>
{
new MpContact
{
ContactId = toContact,
EmailAddress = toContactInfo.Email_Address
}
};
var confirmation = new MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = 5,
DomainId = domainId,
FromContact = from,
MergeData = mergeData,
ReplyToContact = from,
TemplateId = CommunityGroupConfirmationTemplateId,
ToContacts = to
};
_communicationService.SendMessage(confirmation);
}
public void SendAllGroupParticipantsEmail(string token, int groupId, int groupTypeId, string subject, string body)
{
var leaderRecord = _participantRepository.GetParticipantRecord(token);
var groups = _groupService.GetGroupByIdForAuthenticatedUser(token, groupId);
if (groups == null || !groups.Any())
{
throw new GroupNotFoundForParticipantException($"Could not find group {groupId} for groupParticipant {leaderRecord.ParticipantId}");
}
if (!ValidateUserAsLeader(token, groupTypeId, groupId, leaderRecord.ParticipantId, groups.First()))
{
throw new NotGroupLeaderException($"Group participant ID {leaderRecord.ParticipantId} is not a leader of group {groupId}");
}
var fromContact = new MpContact
{
ContactId = 1519180,
EmailAddress = "*****@*****.**"
};
var replyToContact = new MpContact
{
ContactId = leaderRecord.ContactId,
EmailAddress = leaderRecord.EmailAddress
};
var toContacts = groups.First().Participants.Select(groupParticipant => new MpContact
{
ContactId = groupParticipant.ContactId,
EmailAddress = groupParticipant.Email
}).DistinctBy(c => c.EmailAddress).ToList();
var email = new MpCommunication
{
EmailBody = body,
EmailSubject = subject,
AuthorUserId = 5,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyToContact,
ToContacts = toContacts
};
_communicationRepository.SendMessage(email);
}
// TODO Made this virtual so could mock in a unit test. Probably ought to refactor to a separate class - shouldn't have to mock the class we're testing...
public virtual void SendEmail(int communicationTemplateId, int donorId, decimal donationAmount, string paymentType, DateTime setupDate, DateTime startDate, string program, string emailReason, string frequency = null, string pledgeName = null)
{
var template = _communicationService.GetTemplate(communicationTemplateId);
var defaultContactId = AppSetting("DefaultGivingContactEmailId");
var defaultContactEmail = _contactService.GetContactEmail(defaultContactId);
MpContact contact = _contactService.GetEmailFromDonorId(donorId);
var comm = new MpCommunication
{
AuthorUserId = 5,
DomainId = 1,
EmailBody = template.Body,
EmailSubject = template.Subject,
FromContact = new MpContact {
ContactId = defaultContactId, EmailAddress = defaultContactEmail
},
ReplyToContact = new MpContact {
ContactId = defaultContactId, EmailAddress = defaultContactEmail
},
ToContacts = new List <MpContact> {
new MpContact {
ContactId = contact.ContactId, EmailAddress = contact.EmailAddress
}
},
MergeData = new Dictionary <string, object>
{
{ "Program_Name", program },
{ "Donation_Amount", donationAmount.ToString("N2") },
{ "Donation_Date", setupDate.ToString("MM/dd/yyyy h:mmtt", _dateTimeFormat) },
{ "Payment_Method", paymentType },
{ "Decline_Reason", emailReason },
{ "Start_Date", startDate.ToString("MM/dd/yyyy", _dateTimeFormat) }
}
};
if (!string.IsNullOrWhiteSpace(frequency))
{
comm.MergeData["Frequency"] = frequency;
}
if (!string.IsNullOrWhiteSpace(pledgeName))
{
comm.MergeData["Pledge_Donor"] = pledgeName;
}
_communicationService.SendMessage(comm);
}
public void SendEmail(EmailCommunicationDTO email, string token)
{
var template = _communicationService.GetTemplate(email.TemplateId);
if (token == null && email.FromUserId == null && template.FromContactId == 0)
{
throw (new InvalidOperationException("Must provide either email.FromUserId from or an authentication token."));
}
var replyToContactId = email.ReplyToContactId ?? template.ReplyToContactId;
var replyTo = new MpContact {
ContactId = replyToContactId, EmailAddress = _communicationService.GetEmailFromContactId(replyToContactId)
};
var fromContactId = email.FromContactId ?? template.FromContactId;
var from = new MpContact {
ContactId = fromContactId, EmailAddress = _communicationService.GetEmailFromContactId(fromContactId)
};
MpContact to = GetMpContactFromEmailCommunicationDto(email);
var communication = new MpCommunication
{
DomainId = DomainID,
AuthorUserId = email.FromUserId ?? DefaultAuthorUserId,
TemplateId = email.TemplateId,
EmailBody = template.Body,
EmailSubject = template.Subject,
ReplyToContact = replyTo,
FromContact = from,
StartDate = email.StartDate ?? DateTime.Now,
MergeData = email.MergeData,
ToContacts = new List <MpContact>()
};
communication.ToContacts.Add(to);
if (!communication.MergeData.ContainsKey("BaseUrl"))
{
communication.MergeData.Add("BaseUrl", _configurationWrapper.GetConfigValue("BaseUrl"));
}
_communicationService.SendMessage(communication);
}
public MpContact GetEmailFromDonorId(int donorId)
{
MpContact contact = new MpContact();
try
{
string searchFilter = $"Donor_Record={donorId}";
var foundEmails = _ministryPlatformRest.UsingAuthenticationToken(base.ApiLogin()).Search <MpContact>(searchFilter, "Contact_ID, Donor_Record, Email_Address");
if (foundEmails.Count == 1)
{
contact = foundEmails.First();
}
}
catch (Exception ex)
{
throw new ApplicationException(
string.Format("GetEmailFromDonorId failed. Donor Id: {0}", donorId), ex);
}
return(contact);
}
/// <summary>
/// Sends a participant and email based off of a template ID and any merge data you need for that template.
/// </summary>
/// <param name="participant"></param>
/// <param name="templateId"></param>
/// <param name="mergeData"></param>
public int SendSingleGroupParticipantEmail(GroupParticipantDTO participant, int templateId, Dictionary <string, object> mergeData)
{
var emailTemplate = _communicationRepository.GetTemplate(templateId);
var domainId = Convert.ToInt32(_domainId);
var from = new MpContact
{
ContactId = emailTemplate.FromContactId,
EmailAddress = emailTemplate.FromEmailAddress
};
var to = new List <MpContact>
{
new MpContact
{
ContactId = participant.ContactId,
EmailAddress = participant.Email
}
};
var message = new MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = 5,
DomainId = domainId,
FromContact = from,
MergeData = mergeData,
ReplyToContact = from,
TemplateId = templateId,
ToContacts = to,
StartDate = DateTime.Now
};
// ReSharper disable once RedundantArgumentDefaultValue
return(_communicationRepository.SendMessage(message, false));
}
private MpContact GetMpContactFromEmailCommunicationDto(EmailCommunicationDTO email)
{
MpContact to;
if (!email.ToContactId.HasValue && email.emailAddress == null)
{
throw (new InvalidOperationException("Must provide either ToContactId or emailAddress."));
}
if (email.ToContactId.HasValue)
{
return(new MpContact {
ContactId = email.ToContactId.Value, EmailAddress = _communicationService.GetEmailFromContactId(email.ToContactId.Value)
});
}
var contactId = 0;
try
{
contactId = _contactService.GetContactIdByEmail(email.emailAddress);
}
catch (Exception)
{
//work around incorrectly handled case where multiple contacts exists for a single contact
contactId = 0;
}
if (contactId == 0)
{
contactId = DefaultContactEmailId;
}
to = new MpContact {
ContactId = contactId, EmailAddress = email.emailAddress
};
return(to);
}
private static MpCommunication SMCommunication(int templateId, Dictionary <string, object> mergeData, string emailAddr, int contactId)
{
var from = new MpContact {
ContactId = 122222, EmailAddress = "*****@*****.**"
};
return(new MpCommunication
{
AuthorUserId = 1,
DomainId = 1,
EmailBody = "<h1> hello </h1>",
FromContact = from,
ReplyToContact = from,
TemplateId = templateId,
EmailSubject = "whateva",
MergeData = mergeData,
ToContacts = new List <MpContact>()
{
new MpContact {
EmailAddress = emailAddr, ContactId = contactId
}
}
});
}
private static MpCommunication NoReferenceCommunication(int templateId, Dictionary <string, object> mergeData, MpMyContact toContact)
{
var from = new MpContact()
{
ContactId = 122222, EmailAddress = "*****@*****.**"
};
return(new MpCommunication
{
AuthorUserId = 1,
DomainId = 1,
EmailBody = "<h1> hello </h1>",
FromContact = from,
ReplyToContact = from,
TemplateId = templateId,
EmailSubject = "Interview Needed",
MergeData = mergeData,
ToContacts = new List <MpContact> {
new MpContact {
EmailAddress = toContact.Email_Address, ContactId = toContact.Contact_ID
}
}
});
}
public List <MpRecordID> CreateContact(MpContact minorContact)
{
var storedProc = _configurationWrapper.GetConfigValue("CreateContactStoredProc");
var apiToken = _apiUserRepository.GetToken();
var fields = new Dictionary <String, Object>
{
{ "@FirstName", minorContact.FirstName },
{ "@LastName", minorContact.LastName },
{ "@MiddleName", minorContact.MiddleName },
{ "@PreferredName", minorContact.PreferredName },
{ "@NickName", minorContact.Nickname },
{ "@Birthdate", minorContact.BirthDate },
{ "@Gender", minorContact.Gender },
{ "@SchoolAttending", minorContact.SchoolAttending },
{ "@HouseholdId", minorContact.HouseholdId },
{ "@HouseholdPosition", minorContact.HouseholdPositionId },
{ "@MobilePhone", minorContact.MobilePhone }
};
var result = _ministryPlatformRest.UsingAuthenticationToken(apiToken).GetFromStoredProc <MpRecordID>(storedProc, fields);
var contactIdList = result.FirstOrDefault() ?? new List <MpRecordID>();
return(contactIdList);
}
private void SendEmail(MpInvitation invitation, MpParticipant leader, MpGroup group)
{
var leaderContact = _contactRepository.GetContactById(leader.ContactId);
// basic merge data here
var mergeData = new Dictionary <string, object>
{
{ "Invitation_GUID", invitation.InvitationGuid },
{ "Recipient_Name", invitation.RecipientName },
};
int emailTemplateId;
if (invitation.InvitationType == _groupInvitationType)
{
if (invitation.CustomMessage != null)
{
emailTemplateId = _groupInvitationEmailTemplateCustom;
mergeData.Add("Leader_Message", invitation.CustomMessage);
}
else
{
emailTemplateId = _groupInvitationEmailTemplate;
}
mergeData.Add("Leader_Name", leaderContact.Nickname + " " + leaderContact.Last_Name);
mergeData.Add("Group_Name", group.Name);
}
else if (invitation.InvitationType == _tripInvitationType)
{
emailTemplateId = _tripInvitationEmailTemplate;
}
else if (invitation.InvitationType == _anywhereGatheringInvitationTypeId)
{
mergeData["Recipient_Name"] = invitation.RecipientName.Substring(0, 1).ToUpper() + invitation.RecipientName.Substring(1).ToLower();
mergeData.Add("Leader_Name", leaderContact.Nickname.Substring(0, 1).ToUpper() + leaderContact.Nickname.Substring(1).ToLower() + " " + leaderContact.Last_Name.Substring(0, 1).ToUpper() + ".");
mergeData.Add("City", group.Address.City);
mergeData.Add("State", group.Address.State);
mergeData.Add("Description", group.GroupDescription);
mergeData.Add("Group_ID", group.GroupId);
emailTemplateId = _anywhereGatheringInvitationEmailTemplate;
}
else
{
emailTemplateId = _defaultInvitationEmailTemplate;
}
var emailTemplate = _communicationService.GetTemplate(emailTemplateId);
var fromContact = new MpContact
{
ContactId = emailTemplate.FromContactId,
EmailAddress = emailTemplate.FromEmailAddress
};
var replyTo = new MpContact
{
ContactId = leader.ContactId,
EmailAddress = leader.EmailAddress
};
var to = new List <MpContact>
{
new MpContact
{
// Just need a contact ID here, doesn't have to be for the recipient
ContactId = emailTemplate.FromContactId,
EmailAddress = invitation.EmailAddress
}
};
var confirmation = new MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = 5,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyTo,
TemplateId = emailTemplateId,
ToContacts = to,
MergeData = mergeData
};
_communicationService.SendMessage(confirmation);
}
public CampReservationDTO SaveCampReservation(CampReservationDTO campReservation, int eventId, string token)
{
var nickName = string.IsNullOrWhiteSpace(campReservation.PreferredName) ? campReservation.FirstName : campReservation.PreferredName;
var contactId = Convert.ToInt32(campReservation.ContactId);
var minorContact = new MpContact
{
FirstName = campReservation.FirstName,
LastName = campReservation.LastName,
PreferredName = $"{campReservation.LastName}, {campReservation.FirstName}",
MiddleName = campReservation.MiddleName,
MobilePhone = campReservation.MobilePhone,
BirthDate = Convert.ToDateTime(campReservation.BirthDate),
Gender = campReservation.Gender,
Nickname = nickName,
SchoolAttending = campReservation.SchoolAttending,
HouseholdId = (_contactRepository.GetMyProfile(token)).Household_ID,
HouseholdPositionId = 2
};
MpParticipant participant;
if (campReservation.ContactId == null || campReservation.ContactId == 0)
{
var newMinorContact = _contactRepository.CreateContact(minorContact);
contactId = newMinorContact[0].RecordId;
participant = _participantRepository.GetParticipant(contactId);
campReservation.ContactId = contactId;
}
else
{
var updateToDictionary = new Dictionary <String, Object>
{
{ "Contact_ID", Convert.ToInt32(campReservation.ContactId) },
{ "First_Name", minorContact.FirstName },
{ "Last_Name", minorContact.LastName },
{ "Middle_Name", minorContact.MiddleName },
{ "Nickname", nickName },
{ "Mobile_Phone", minorContact.MobilePhone },
{ "Gender_ID", campReservation.Gender },
{ "Date_Of_Birth", minorContact.BirthDate },
{ "Current_School", minorContact.SchoolAttending },
{ "Congregation_Name", (_congregationRepository.GetCongregationById(campReservation.CrossroadsSite)).Name }
};
_contactRepository.UpdateContact(Convert.ToInt32(campReservation.ContactId), updateToDictionary);
participant = _participantRepository.GetParticipant(Convert.ToInt32(campReservation.ContactId));
}
// Save shirt size if set
var configuration = MpObjectAttributeConfigurationFactory.Contact();
_objectAttributeService.SaveObjectAttributes(contactId, campReservation.AttributeTypes, campReservation.SingleAttributes, configuration);
// Save students in selected grade group
var group = _groupRepository.GetGradeGroupForContact(contactId, _apiUserRepository.GetToken());
if (group.Status && group.Value.GroupId != campReservation.CurrentGrade)
{
_groupRepository.endDateGroupParticipant(group.Value.GroupParticipantId, group.Value.GroupId, DateTime.Now);
_groupRepository.addParticipantToGroup(participant.ParticipantId,
campReservation.CurrentGrade,
_configurationWrapper.GetConfigIntValue("Group_Role_Default_ID"),
false,
DateTime.Now);
}
else if (!group.Status)
{
_groupRepository.addParticipantToGroup(participant.ParticipantId,
campReservation.CurrentGrade,
_configurationWrapper.GetConfigIntValue("Group_Role_Default_ID"),
false,
DateTime.Now);
}
// Check if this person is already an event participant
var eventParticipant = _eventParticipantRepository.GetEventParticipantEligibility(eventId, contactId);
var currentlyActive = (eventParticipant != null && (eventParticipant.EndDate == null || eventParticipant.EndDate >= DateTime.Now));
var rulesPass = true;
if (!currentlyActive)
{
rulesPass = _campRules.VerifyCampRules(eventId, campReservation.Gender);
}
// ALL OF THE BELOW CODE SHOULD ONLY HAPPEN IF THE RULES PASS
if (rulesPass)
{
//Create eventParticipant
int eventParticipantId;
// This is a new event participant, determine their pending timeout and create their entry in the database
if (eventParticipant == null)
{
var endDate = DetermineEndDate(eventId);
eventParticipantId = _eventRepository.RegisterInterestedParticipantWithEndDate(participant.ParticipantId, eventId, endDate);
}
else
{
eventParticipantId = eventParticipant.EventParticipantId;
// If the participant had previously started an application which expired, update its End Date now
if (eventParticipant.EndDate != null && eventParticipant.EndDate < DateTime.Now)
{
var endDate = DetermineEndDate(eventId);
_eventRepository.UpdateParticipantEndDate(eventParticipantId, endDate);
}
}
var crossroadsSite = _congregationRepository.GetCongregationById(campReservation.CrossroadsSite);
//form response
var answers = new List <MpFormAnswer>
{
new MpFormAnswer
{
Response = campReservation.SchoolAttendingNext,
FieldId = _configurationWrapper.GetConfigIntValue("SummerCampForm.SchoolAttendingNextYear"),
EventParticipantId = eventParticipantId
},
new MpFormAnswer
{
Response = campReservation.RoomMate,
FieldId = _configurationWrapper.GetConfigIntValue("SummerCampForm.PreferredRoommate"),
EventParticipantId = eventParticipantId
},
new MpFormAnswer
{
Response = crossroadsSite.Name,
FieldId = _configurationWrapper.GetConfigIntValue("SummerCampForm.CamperCongregation"),
EventParticipantId = eventParticipantId
}
};
var formId = _configurationWrapper.GetConfigIntValue("SummerCampFormID");
var formResponse = new MpFormResponse
{
ContactId = contactId,
FormId = formId,
FormAnswers = answers,
EventId = eventId
};
_formSubmissionRepository.SubmitFormResponse(formResponse);
return(campReservation);
}
throw new ApplicationException("Rules do not pass!");
}
public void SendGroupParticipantEmail(int groupId,
GroupDTO group,
int emailTemplateId,
MpParticipant toParticipant,
string subjectTemplateContentBlockTitle = null,
string emailTemplateContentBlockTitle = null,
string message = null,
MpParticipant fromParticipant = null)
{
var participant = new GroupParticipantDTO
{
ContactId = toParticipant.ContactId,
Email = toParticipant.EmailAddress,
NickName = toParticipant.PreferredName,
ParticipantId = toParticipant.ParticipantId
};
var emailTemplate = _communicationRepository.GetTemplate(emailTemplateId);
var fromContact = new MpContact
{
ContactId = emailTemplate.FromContactId,
EmailAddress = emailTemplate.FromEmailAddress
};
var replyTo = new MpContact
{
ContactId = fromParticipant?.ContactId ?? emailTemplate.ReplyToContactId,
EmailAddress = fromParticipant == null ? emailTemplate.ReplyToEmailAddress : fromParticipant.EmailAddress
};
var leader = _contactRepository.GetContactById(replyTo.ContactId);
var to = new List <MpContact>
{
new MpContact
{
ContactId = participant.ContactId,
EmailAddress = participant.Email
}
};
var subjectTemplateText = string.IsNullOrWhiteSpace(subjectTemplateContentBlockTitle)
? string.Empty
: _contentBlockService[subjectTemplateContentBlockTitle].Content ?? string.Empty;
var emailTemplateText = string.IsNullOrWhiteSpace(emailTemplateContentBlockTitle) ? string.Empty : _contentBlockService[emailTemplateContentBlockTitle].Content;
var mergeData = getDictionary(participant);
mergeData["Email_Custom_Message"] = string.IsNullOrWhiteSpace(message) ? string.Empty : message;
mergeData["Group_Name"] = group.GroupName;
mergeData["Group_Description"] = group.GroupDescription;
mergeData["Leader_Name"] = leader.Nickname != null && leader.Last_Name != null ? leader.Nickname + " " + leader.Last_Name : replyTo.EmailAddress;
mergeData["City"] = group.Address.City;
mergeData["State"] = group.Address.State;
if (fromParticipant != null)
{
mergeData["From_Display_Name"] = fromParticipant.DisplayName;
mergeData["From_Preferred_Name"] = fromParticipant.PreferredName;
}
// Since the templates are coming from content blocks, they may have replacement tokens in them as well.
// These will not get replaced with merge data in _communicationRepository.SendMessage(), (it doesn't doubly
// replace) so we'll parse them here before adding them to the merge data.
mergeData["Subject_Template_Text"] = _communicationRepository.ParseTemplateBody(Regex.Replace(subjectTemplateText, "<.*?>", string.Empty), mergeData);
mergeData["Email_Template_Text"] = _communicationRepository.ParseTemplateBody(emailTemplateText, mergeData);
var email = new MpCommunication
{
EmailBody = emailTemplate.Body,
EmailSubject = emailTemplate.Subject,
AuthorUserId = _emailAuthorId,
DomainId = _domainId,
FromContact = fromContact,
ReplyToContact = replyTo,
TemplateId = emailTemplateId,
ToContacts = to,
MergeData = mergeData
};
_communicationRepository.SendMessage(email);
}
public void ShouldSendPrimaryContactReminderEmails()
{
const string search = "";
const string apiToken = "qwerty1234";
var defaultContact = new MpMyContact()
{
Contact_ID = 321,
Email_Address = "*****@*****.**"
};
var testEvent = new MpEvent()
{
EventId = 32,
EventStartDate = new DateTime(),
EventEndDate = new DateTime().AddHours(2),
PrimaryContact = new MpContact()
{
EmailAddress = "*****@*****.**",
ContactId = 4321
}
};
var testEventList = new List <MpEvent>()
{
testEvent
};
_apiUserService.Setup(m => m.GetToken()).Returns(apiToken);
_eventService.Setup(m => m.EventsByPageViewId(apiToken, 2205, search)).Returns(testEventList);
var eventList = testEventList.Select(evt => new crds_angular.Models.Crossroads.Events.Event()
{
name = evt.EventTitle,
EventId = evt.EventId,
EndDate = evt.EventEndDate,
StartDate = evt.EventStartDate,
EventType = evt.EventType,
location = evt.Congregation,
PrimaryContactEmailAddress = evt.PrimaryContact.EmailAddress,
PrimaryContactId = evt.PrimaryContact.ContactId
});
eventList.ForEach(evt =>
{
var mergeData = new Dictionary <string, object>
{
{ "Event_ID", evt.EventId },
{ "Event_Title", evt.name },
{ "Event_Start_Date", evt.StartDate.ToShortDateString() },
{ "Event_Start_Time", evt.StartDate.ToShortTimeString() }
};
var contact = new MpContact()
{
ContactId = defaultContact.Contact_ID, EmailAddress = defaultContact.Email_Address
};
var fakeCommunication = new MpCommunication()
{
AuthorUserId = defaultContact.Contact_ID,
DomainId = 1,
EmailBody = "Test event email stuff",
EmailSubject = "Test Event Reminder",
FromContact = contact,
MergeData = mergeData,
ReplyToContact = contact,
TemplateId = 14909,
ToContacts = new List <MpContact>()
{
contact
}
};
var testContact = new MpMyContact()
{
Contact_ID = 9876,
Email_Address = "*****@*****.**"
};
_contactService.Setup(m => m.GetContactById(9876)).Returns(testContact);
_communicationService.Setup(m => m.GetTemplateAsCommunication(14909,
testContact.Contact_ID,
testContact.Email_Address,
evt.PrimaryContactId,
evt.PrimaryContactEmailAddress,
evt.PrimaryContactId,
evt.PrimaryContactEmailAddress,
mergeData)).Returns(fakeCommunication);
_communicationService.Setup(m => m.SendMessage(fakeCommunication, false));
_communicationService.Verify();
});
_fixture.EventsReadyForPrimaryContactReminder(apiToken);
_eventService.Verify();
}
