public void ShouldGetContactByUserRecordId()
{
string tableName = "Contacts";
const int userRecordId = 1234567;
Dictionary <string, object> expectedFilter = new Dictionary <string, object>()
{
{ "User_Account", userRecordId }
};
MpMyContact contact = new MpMyContact()
{
Contact_ID = 2,
First_Name = "Testy",
Email_Address = "*****@*****.**",
Age = 30,
Mobile_Phone = "1234567890"
};
List <MpMyContact> mockResults = new List <MpMyContact>
{
contact
};
_ministryPlatformRest.Setup(m => m.UsingAuthenticationToken(It.IsAny <string>())).Returns(_ministryPlatformRest.Object);
_ministryPlatformRest.Setup(m => m.Get <MpMyContact>(tableName, expectedFilter))
.Returns(mockResults);
var result = _fixture.GetContactByUserRecordId(userRecordId);
Assert.AreEqual(contact, result);
}
private static MpCommunication FormatCommunication(int authorUserId,
int domainId,
MpMessageTemplate template,
MpMyContact fromContact,
MpMyContact replyToContact,
int participantContactId,
string participantEmail,
Dictionary <string, object> mergeData)
{
var communication = new MpCommunication
{
AuthorUserId = authorUserId,
DomainId = domainId,
EmailBody = template.Body,
EmailSubject = template.Subject,
FromContact = new MpContact {
ContactId = fromContact.Contact_ID, EmailAddress = fromContact.Email_Address
},
ReplyToContact = new MpContact {
ContactId = replyToContact.Contact_ID, EmailAddress = replyToContact.Email_Address
},
ToContacts = new List <MpContact> {
new MpContact {
ContactId = participantContactId, EmailAddress = participantEmail
}
},
MergeData = mergeData
};
return(communication);
}
public IHttpActionResult Get(string username)
{
return(Authorized(token =>
{
try
{
int userid = _userRepository.GetUserIdByUsername(username);
MpUser user = _userRepository.GetUserByRecordId(userid);
var userRoles = _userRepository.GetUserRoles(userid);
MpMyContact contact = _contactRepository.GetContactByUserRecordId(user.UserRecordId);
var r = new LoginReturn
{
userToken = token,
userTokenExp = "",
refreshToken = "",
userId = contact.Contact_ID,
username = contact.First_Name,
userEmail = contact.Email_Address,
roles = userRoles,
age = contact.Age,
userPhone = contact.Mobile_Phone,
canImpersonate = user.CanImpersonate
};
return Ok(r);
}
catch (Exception e)
{
var apiError = new ApiErrorDto($"{e.Message}");
throw new HttpResponseException(apiError.HttpResponseMessage);
}
}));
}
private Dictionary <string, object> SetupMergeData(int contactId,
int opportunityId,
MpOpportunity previousOpportunity,
MpOpportunity currentOpportunity,
DateTime startDate,
DateTime endDate,
MpMyContact groupContact,
String htmlTable)
{
MpMyContact volunteer = _contactService.GetContactById(contactId);
return(new Dictionary <string, object>
{
{ "Opportunity_Name", opportunityId == 0 ? "Not Available" : currentOpportunity.OpportunityName },
{ "Start_Date", startDate.ToShortDateString() },
{ "End_Date", endDate.ToShortDateString() },
{ "Shift_Start", currentOpportunity.ShiftStart.FormatAsString() ?? string.Empty },
{ "Shift_End", currentOpportunity.ShiftEnd.FormatAsString() ?? string.Empty },
{ "Room", currentOpportunity.Room ?? string.Empty },
{ "Group_Contact", groupContact.Nickname + " " + groupContact.Last_Name },
{ "Group_Name", currentOpportunity.GroupName },
{
"Previous_Opportunity_Name",
previousOpportunity != null ? previousOpportunity.OpportunityName : @"Not Available"
},
{ "Volunteer_Name", volunteer.Nickname + " " + volunteer.Last_Name },
{ "Html_Table", htmlTable }
});
}
private MpCommunication SetupCommunication(int templateId, MpMyContact groupContact, MpMyContact toContact, Dictionary <string, object> mergeData)
{
var template = _communicationService.GetTemplate(templateId);
var defaultContact = _contactService.GetContactById(_configurationWrapper.GetConfigIntValue("DefaultContactEmailId"));
return(new MpCommunication
{
AuthorUserId = 5,
DomainId = 1,
EmailBody = template.Body,
EmailSubject = template.Subject,
FromContact = new MpContact {
ContactId = defaultContact.Contact_ID, EmailAddress = defaultContact.Email_Address
},
ReplyToContact = new MpContact {
ContactId = groupContact.Contact_ID, EmailAddress = groupContact.Email_Address
},
ToContacts = new List <MpContact> {
new MpContact {
ContactId = toContact.Contact_ID, EmailAddress = toContact.Email_Address
}
},
MergeData = mergeData
});
}
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 GetContactByParticipantId()
{
const int participantId = 99999;
var expectedContact = new MpMyContact
{
Contact_ID = 11111,
Email_Address = "*****@*****.**",
Last_Name = "Dalton",
First_Name = "Andy"
};
var mockContactDictionary = new List <Dictionary <string, object> >
{
new Dictionary <string, object>
{
{ "Contact_ID", expectedContact.Contact_ID },
{ "Email_Address", expectedContact.Email_Address },
{ "First_Name", expectedContact.First_Name },
{ "Last_Name", expectedContact.Last_Name }
}
};
var searchString = participantId + ",";
_ministryPlatformService.Setup(m => m.GetPageViewRecords("ContactByParticipantId", It.IsAny <string>(), searchString, "", 0)).Returns(mockContactDictionary);
var returnedContact = _fixture.GetContactByParticipantId(participantId);
_ministryPlatformService.VerifyAll();
Assert.AreEqual(expectedContact.Contact_ID, returnedContact.Contact_ID);
Assert.AreEqual(expectedContact.Email_Address, returnedContact.Email_Address);
Assert.AreEqual(expectedContact.First_Name, returnedContact.First_Name);
Assert.AreEqual(expectedContact.Last_Name, returnedContact.Last_Name);
}
private Dictionary <string, object> SetupGenericEmailMergeData(MpMyContact applicant)
{
return(new Dictionary <string, object>
{
{ "First_Name", applicant.Nickname ?? applicant.First_Name },
{ "Last_Name", applicant.Last_Name },
{ "Email_Address", applicant.Email_Address }
});
}
private static MpMyContact ReplyToContact(MpEvent childEvent)
{
var contact = childEvent.PrimaryContact;
var replyToContact = new MpMyContact
{
Contact_ID = contact.ContactId,
Email_Address = contact.EmailAddress
};
return(replyToContact);
}
private static MpMyContact ParseProfileRecord(Dictionary <string, object> recordsDict)
{
var contact = new MpMyContact
{
Address_ID = recordsDict.ToNullableInt("Address_ID"),
Address_Line_1 = recordsDict.ToString("Address_Line_1"),
Address_Line_2 = recordsDict.ToString("Address_Line_2"),
Congregation_ID = recordsDict.ToNullableInt("Congregation_ID"),
Household_ID = recordsDict.ToInt("Household_ID"),
Household_Name = recordsDict.ToString("Household_Name"),
City = recordsDict.ToString("City"),
State = recordsDict.ToString("State"),
County = recordsDict.ToString("County"),
Postal_Code = recordsDict.ToString("Postal_Code"),
Contact_ID = recordsDict.ToInt("Contact_ID"),
Date_Of_Birth = recordsDict.ToDateAsString("Date_of_Birth"),
Email_Address = recordsDict.ToString("Email_Address"),
Employer_Name = recordsDict.ToString("Employer_Name"),
First_Name = recordsDict.ToString("First_Name"),
Foreign_Country = recordsDict.ToString("Foreign_Country"),
Gender_ID = recordsDict.ToNullableInt("Gender_ID"),
Home_Phone = recordsDict.ToString("Home_Phone"),
Current_School = recordsDict.ToString("Current_School"),
Last_Name = recordsDict.ToString("Last_Name"),
Maiden_Name = recordsDict.ToString("Maiden_Name"),
Marital_Status_ID = recordsDict.ToNullableInt("Marital_Status_ID"),
Middle_Name = recordsDict.ToString("Middle_Name"),
Mobile_Carrier = recordsDict.ToNullableInt("Mobile_Carrier_ID"),
Mobile_Phone = recordsDict.ToString("Mobile_Phone"),
Nickname = recordsDict.ToString("Nickname"),
Age = recordsDict.ToInt("Age"),
Passport_Number = recordsDict.ToString("Passport_Number"),
Passport_Country = recordsDict.ToString("Passport_Country"),
Passport_Expiration = ParseExpirationDate(recordsDict.ToNullableDate("Passport_Expiration")),
Passport_Firstname = recordsDict.ToString("Passport_Firstname"),
Passport_Lastname = recordsDict.ToString("Passport_Lastname"),
Passport_Middlename = recordsDict.ToString("Passport_Middlename")
};
if (recordsDict.ContainsKey("Participant_Start_Date"))
{
contact.Participant_Start_Date = recordsDict.ToDate("Participant_Start_Date");
}
if (recordsDict.ContainsKey("Attendance_Start_Date"))
{
contact.Attendance_Start_Date = recordsDict.ToNullableDate("Attendance_Start_Date");
}
if (recordsDict.ContainsKey("ID_Card"))
{
contact.ID_Number = recordsDict.ToString("ID_Card");
}
return(contact);
}
private Dictionary <string, object> SetupReferenceEmailMergeData(MpMyContact reference, MpMyContact applicant, int participant_Id)
{
return(new Dictionary <string, object>
{
{ "Recipient_First_Name", reference.Nickname ?? reference.First_Name },
{ "First_Name", applicant.Nickname ?? applicant.First_Name },
{ "Last_Name", applicant.Last_Name },
{ "Participant_ID", participant_Id },
{ "Base_Url", _configWrapper.GetConfigValue("BaseMPUrl") }
});
}
private Dictionary <string, object> HandleNoRsvp(MpParticipant participant,
MpEvent e,
List <int> opportunityIds,
string token,
MpMyContact groupLeader)
{
int templateId;
MpOpportunity previousOpportunity = null;
try
{
templateId = AppSetting("RsvpNoTemplate");
//opportunityId = opportunityIds.First();
_eventService.UnregisterParticipantForEvent(participant.ParticipantId, e.EventId);
}
catch (ApplicationException ex)
{
logger.Debug(ex.Message + ": There is no need to remove the event participant because there is not one.");
templateId = AppSetting("RsvpNoTemplate");
}
// Responding no means that we are saying no to all opportunities for this group for this event
foreach (var oid in opportunityIds)
{
var comments = string.Empty; //anything of value to put in comments?
var updatedOpp = _opportunityService.RespondToOpportunity(participant.ParticipantId,
oid,
comments,
e.EventId,
false);
if (updatedOpp > 0)
{
previousOpportunity = _opportunityService.GetOpportunityById(oid, token);
}
}
if (previousOpportunity != null)
{
var emailName = participant.DisplayName;
var emailEmail = participant.EmailAddress;
var emailTeamName = previousOpportunity.GroupName;
var emailOpportunityName = previousOpportunity.OpportunityName;
var emailEventDateTime = e.EventStartDate.ToString();
SendCancellationMessage(groupLeader, emailName, emailEmail, emailTeamName, emailOpportunityName, emailEventDateTime);
}
return(new Dictionary <string, object>()
{
{ "templateId", templateId },
{ "previousOpportunity", previousOpportunity },
{ "rsvp", false }
});
}
public void ShouldGetUserByName()
{
var username = "******";
MpUser mpUser = new MpUser()
{
CanImpersonate = true,
DisplayName = "Testy McTestface",
Guid = "123123123123123",
UserEmail = "*****@*****.**",
UserId = "test",
UserRecordId = 1
};
MpMyContact mpMyContact = new MpMyContact()
{
Contact_ID = 2,
First_Name = "Testy",
Email_Address = mpUser.UserEmail,
Age = 30,
Mobile_Phone = "1234567890"
};
List <MpRoleDto> roles = new List <MpRoleDto>();
LoginReturn dto = new LoginReturn()
{
userToken = _authType + " " + _authToken,
userTokenExp = "",
refreshToken = "",
userId = mpMyContact.Contact_ID,
username = mpMyContact.First_Name,
userEmail = mpMyContact.Email_Address,
roles = roles,
age = mpMyContact.Age,
userPhone = mpMyContact.Mobile_Phone,
canImpersonate = mpUser.CanImpersonate
};
_userRepository.Setup(mocked => mocked.GetUserIdByUsername(username)).Returns(mpUser.UserRecordId);
_userRepository.Setup(mocked => mocked.GetUserByRecordId(mpUser.UserRecordId)).Returns(mpUser);
_userRepository.Setup(mocked => mocked.GetUserRoles(mpUser.UserRecordId)).Returns(roles);
_contactRepository.Setup(mocked => mocked.GetContactByUserRecordId(mpUser.UserRecordId)).Returns(mpMyContact);
var response = _fixture.Get(username);
_userRepository.VerifyAll();
_contactRepository.VerifyAll();
Assert.IsNotNull(response);
Assert.IsInstanceOf <OkNegotiatedContentResult <LoginReturn> >(response);
var r = (OkNegotiatedContentResult <LoginReturn>)response;
Assert.IsNotNull(r.Content);
Assert.AreEqual(JsonConvert.SerializeObject(dto), JsonConvert.SerializeObject(r.Content));
}
private MpParticipant MockParticipant(MpMyContact contact)
{
return(new MpParticipant
{
ContactId = contact.Contact_ID,
ParticipantId = 129876,
EmailAddress = contact.Email_Address,
DisplayName = contact.Display_Name,
Nickname = contact.Nickname,
Age = contact.Age,
PreferredName = contact.Nickname
});
}
public void SetUp()
{
_objectAttributeService = new Mock <IObjectAttributeService>();
var allAttributesDto = new ObjectAllAttributesDTO();
_objectAttributeService.Setup(mocked => mocked.GetObjectAttributes(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <MpObjectAttributeConfiguration>())).Returns(allAttributesDto);
_contactService = new Mock <MPInterfaces.IContactRepository>();
_authenticationService = new Mock <MPInterfaces.IAuthenticationRepository>();
_participantService = new Mock <MPInterfaces.IParticipantRepository>();
_userService = new Mock <MPInterfaces.IUserRepository>();
_apiUserService = new Mock <MPInterfaces.IApiUserRepository>();
_apiUserService.Setup(m => m.GetToken()).Returns("something");
_authenticationService.Setup(mocked => mocked.GetContactId(It.IsAny <string>())).Returns(123456);
_myContact = new MpMyContact
{
Contact_ID = 123456,
Email_Address = "*****@*****.**",
Last_Name = "last-name",
Nickname = "nickname",
First_Name = "first-name",
Middle_Name = "middle-name",
Maiden_Name = "maiden-name",
Mobile_Phone = "mobile-phone",
Mobile_Carrier = 999,
Date_Of_Birth = "date-of-birth",
Marital_Status_ID = 5,
Gender_ID = 2,
Employer_Name = "employer-name",
Address_Line_1 = "address-line-1",
Address_Line_2 = "address-line-2",
City = "city",
State = "state",
Postal_Code = "postal-code",
Foreign_Country = "foreign-country",
Home_Phone = "home-phone",
Congregation_ID = 8,
Household_ID = 7,
Household_Name = "hh name",
Address_ID = 6,
Attendance_Start_Date = startDate
};
_householdMembers = new List <MpHouseholdMember>();
_fixture = new PersonService(_contactService.Object, _objectAttributeService.Object, _apiUserService.Object, _participantService.Object, _userService.Object, _authenticationService.Object);
//force AutoMapper to register
AutoMapperConfig.RegisterMappings();
}
private Dictionary <string, object> CreateRsvp(string token,
int opportunityId,
List <int> opportunityIds,
bool signUp,
MpParticipant participant,
MpEvent @event,
MpMyContact groupLeader)
{
var response = signUp
? HandleYesRsvp(participant, @event, opportunityId, opportunityIds, token)
: HandleNoRsvp(participant, @event, opportunityIds, token, groupLeader);
return(response);
}
public int CreateContactForSponsoredChild(string firstName, string lastName, string town, string idCard)
{
var householdId = CreateAddressHouseholdForSponsoredChild(town, lastName);
var contact = new MpMyContact
{
First_Name = firstName,
Last_Name = lastName,
ID_Number = idCard,
Household_ID = householdId
};
return(CreateContact(contact));
}
public void TestRequestToBeHost()
{
var token = "faketoken";
var hostRequestDto = new HostRequestDto
{
ContactId = 123,
GroupDescription = "fake group description",
IsHomeAddress = false,
ContactNumber = "555-123-4567",
Address = new AddressDTO
{
AddressID = 1,
AddressLine1 = "123 Main St",
City = "Cincinnati",
State = "OH",
PostalCode = "45249"
}
};
var contact = new MpMyContact
{
Contact_ID = 123,
Email_Address = "*****@*****.**",
Nickname = "Bob",
Last_Name = "Bobert"
};
var participant = new MpParticipant {
ParticipantId = 999
};
var group = new GroupDTO();
group.GroupId = 555;
_mpContactRepository.Setup(m => m.GetContactById(It.IsAny <int>())).Returns(contact);
_mpParticipantRepository.Setup(m => m.GetParticipant(It.IsAny <int>())).Returns(participant);
_groupService.Setup(m => m.CreateGroup(It.IsAny <GroupDTO>())).Returns(group);
_groupService.Setup(m => m.addParticipantToGroupNoEvents(It.IsAny <int>(), It.IsAny <ParticipantSignup>()));
_addressService.Setup(m => m.CreateAddress(It.IsAny <AddressDTO>())).Returns(57);
_mpGroupRepository.Setup(m => m.GetGroupsByGroupType(It.IsAny <int>())).Returns(new List <MpGroup>());
_fixture.RequestToBeHost(token, hostRequestDto);
_groupService.Verify(x => x.addParticipantToGroupNoEvents(It.IsAny <int>(), It.IsAny <ParticipantSignup>()), Times.Once);
_mpContactRepository.Verify(x => x.SetHouseholdAddress(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()), Times.Never);
}
private Person MockPerson(MpMyContact contact)
{
return(new Person
{
AddressId = contact.Address_ID,
AddressLine1 = contact.Address_Line_1,
AddressLine2 = contact.Address_Line_2,
Age = contact.Age,
CongregationId = contact.Congregation_ID,
ContactId = contact.Contact_ID,
DateOfBirth = contact.Date_Of_Birth,
EmailAddress = contact.Email_Address,
FirstName = contact.First_Name,
LastName = contact.Last_Name,
NickName = contact.Nickname
});
}
private void SendCancellationMessage(MpMyContact groupLeader, string volunteerName, string volunteerEmail, string teamName, string opportunityName, string eventDateTime)
{
var templateId = AppSetting("RsvpYesToNo");
var mergeData = new Dictionary <string, object>
{
{ "VolunteerName", volunteerName },
{ "VolunteerEmail", volunteerEmail },
{ "TeamName", teamName },
{ "OpportunityName", opportunityName },
{ "EventDateTime", eventDateTime }
};
var communication = SetupCommunication(templateId, groupLeader, groupLeader, mergeData);
_communicationService.SendMessage(communication);
}
public static MpMyContact MyContact(int contactId = 0)
{
var contact = new MpMyContact()
{
Address_ID = 12,
Address_Line_1 = "123 Sesme Street",
Age = 23,
City = "Cincinnati",
Contact_ID = 123445,
County = "USA"
};
if (contactId != 0)
{
contact.Contact_ID = contactId;
}
return(contact);
}
public void ShouldSendNoReferenceEmail()
{
const int templateId = 5;
const int applicantContactId = 9987654;
const int groupsContactId = 1123456;
const string groupsEmail = "*****@*****.**";
const int messageId = 7;
var applicantContact = ContactMock(applicantContactId);
var groupsContact = new MpMyContact
{
Contact_ID = groupsContactId,
Email_Address = groupsEmail
};
var mergeData = new Dictionary <string, object>
{
{ "First_Name", applicantContact.Nickname },
{ "Last_Name", applicantContact.Last_Name },
{ "Email_Address", applicantContact.Email_Address }
};
var communication = NoReferenceCommunication(templateId, mergeData, groupsContact);
var referenceData = new Dictionary <string, object>
{
{ "contact", applicantContact },
{ "participant", ParticipantMock() },
{ "referenceContactId", "0" }
};
_configWrapper.Setup(m => m.GetConfigIntValue("GroupLeaderNoReferenceEmailTemplate")).Returns(templateId);
_configWrapper.Setup(m => m.GetConfigIntValue("DefaultGroupContactEmailId")).Returns(groupsContactId);
_contactMock.Setup(m => m.GetContactEmail(groupsContactId)).Returns(groupsEmail);
_communicationRepository.Setup(m => m.GetTemplateAsCommunication(templateId, groupsContactId, groupsEmail, mergeData)).Returns(communication);
_communicationRepository.Setup(m => m.SendMessage(communication, false)).Returns(messageId);
var response = _fixture.SendNoReferenceEmail(referenceData);
response.Subscribe((n) =>
{
Assert.AreEqual(messageId, response);
},
(err) =>
{
Assert.Fail(err.ToString());
});
}
public void ShouldCallAnalyticsWhenAcceptingAnInvite()
{
var hostPin = GetAPin(2);
var invitedContact = new MpMyContact()
{
Contact_ID = 42,
Email_Address = "*****@*****.**"
};
const int groupId = 42;
const string invitationGuid = "ILIKEICECREAM";
const string token = "IAMAUTHENTICATEDMAN";
_mpGroupToolService.Setup(m => m.AcceptDenyGroupInvitation(
It.Is <string>(toke => toke.Equals(token)),
It.Is <int>(GroupID => GroupID == groupId),
It.Is <string>(invite => invite.Equals(invitationGuid)),
It.Is <Boolean>(t => t == true)
));
_groupService.Setup(m => m.GetPrimaryContactParticipantId(It.Is <int>(GroupID => GroupID == groupId))).Returns(42);
_mpFinderRepository.Setup(m => m.GetPinDetails(It.Is <int>(partId => partId == 42))).Returns(convertPinDtoToFinderPinDto(hostPin));
_mpContactRepository.Setup(m => m.GetContactById(It.Is <int>(id => id == invitedContact.Contact_ID))).Returns(invitedContact);
_authenticationRepository.Setup(m => m.GetContactId(It.Is <string>(Token => Token.Equals(token)))).Returns(invitedContact.Contact_ID);
_mpFinderRepository.Setup(m => m.RecordConnection(It.IsAny <MpConnectCommunication>()));
_communicationRepository.Setup(m => m.GetTemplate(It.IsAny <int>())).Returns(new MpMessageTemplate());
_communicationRepository.Setup(m => m.SendMessage(It.IsAny <MinistryPlatform.Translation.Models.MpCommunication>(), false));
_analyticsService.Setup(m => m.Track(
It.Is <string>(hostId => hostId.Equals(hostPin.Contact_ID.ToString())),
It.Is <string>(eventName => eventName.Equals("HostInvitationAccepted")),
It.Is <EventProperties>(props => props["InvitationTo"].Equals(invitedContact.Contact_ID) &&
props["InvitationToEmail"].Equals(invitedContact.Email_Address))
));
_analyticsService.Setup(m => m.Track(
It.Is <string>(invitedId => invitedId.Equals(invitedContact.Contact_ID.ToString())),
It.Is <string>(eventName => eventName.Equals("InviteeAcceptedInvitation")),
It.Is <EventProperties>(props => props["InvitationFrom"].Equals(hostPin.Contact_ID) &&
props["InvitationFromEmail"].Equals(hostPin.EmailAddress))
));
_fixture.AcceptDenyGroupInvitation(token, groupId, invitationGuid, true);
_analyticsService.VerifyAll();
_groupService.VerifyAll();
}
private int CreateContact(MpMyContact contact)
{
var contactDictionary = new Dictionary <string, object>
{
{ "Company", false },
{ "Last_Name", contact.Last_Name },
{ "First_Name", contact.First_Name },
{ "Email_Address", contact.Email_Address },
{ "Display_Name", contact.Last_Name + ", " + contact.First_Name },
{ "Nickname", contact.First_Name },
{ "ID_Card", contact.ID_Number }
};
if (contact.Household_ID > 0)
{
contactDictionary.Add("HouseHold_ID", contact.Household_ID);
contactDictionary.Add("Household_Position_ID", _householdPositionDefaultId);
}
if (contact.Mobile_Phone != string.Empty)
{
contactDictionary.Add("Mobile_Phone", contact.Mobile_Phone);
}
if (contact.Date_Of_Birth != string.Empty)
{
contactDictionary.Add("Date_Of_Birth", contact.Date_Of_Birth);
}
try
{
var token = ApiLogin();
return(_ministryPlatformService.CreateRecord(_contactsPageId, contactDictionary, token, false));
}
catch (Exception e)
{
var msg = string.Format("Error creating Contact, firstName: {0} lastName: {1} idCard: {2}",
contact.First_Name,
contact.Last_Name,
contact.ID_Number);
_logger.Error(msg, e);
throw (new ApplicationException(msg, e));
}
}
public static MpCommunication Communication(MpMyContact sender, MpMyContact sendee, int templateId)
{
return(new MpCommunication()
{
AuthorUserId = RandomInt(),
DomainId = RandomInt(),
EmailBody = Gen.Sample(100, 100, Gen.OneOf(Arb.Generate <string>())).HeadOrDefault,
EmailSubject = Gen.Sample(100, 100, Gen.OneOf(Arb.Generate <string>())).HeadOrDefault,
FromContact = new MpContact()
{
ContactId = sender.Contact_ID, EmailAddress = sender.Email_Address
},
MergeData = new Dictionary <string, object>(),
ReplyToContact = new MpContact()
{
ContactId = sendee.Contact_ID, EmailAddress = sendee.Email_Address
},
TemplateId = templateId
});
}
public void ShouldGetChildcareReminderMergeData()
{
var email1 = new MpContact()
{
EmailAddress = "*****@*****.**", ContactId = 2186211
};
var date = new DateTime(2016, 2, 21);
var personObj = new MpMyContact()
{
Contact_ID = 2186211,
Nickname = "Matt"
};
_contactService.Setup(m => m.GetContactById(email1.ContactId)).Returns(personObj);
_configurationWrapper.Setup(m => m.GetConfigValue("BaseUrl")).Returns("http://blah/");
var data = _fixture.SetMergeDataForChildcareReminder(email1, date);
Assert.AreEqual("Sunday, February 21", data["Childcare_Day"]);
Assert.AreEqual("02/21/2016", data["Childcare_Date"]);
Assert.AreEqual("Matt", data["Nickname"]);
}
public MpMyContact GetContactByParticipantId(int participantId)
{
var token = ApiLogin();
var searchString = string.Format("{0},", participantId);
var contacts = _ministryPlatformService.GetPageViewRecords("ContactByParticipantId", token, searchString);
var c = contacts.SingleOrDefault();
if (c == null)
{
return(null);
}
var contact = new MpMyContact
{
Contact_ID = c.ToInt("Contact_ID"),
Email_Address = c.ToString("Email_Address"),
Last_Name = c.ToString("Last_Name"),
First_Name = c.ToString("First_Name")
};
return(contact);
}
public PaymentDetailDTO GetPaymentDetails(int paymentId, int invoiceId, string token, bool useInvoiceContact = false)
{
var invoice = _invoiceRepository.GetInvoice(invoiceId);
var me = new MpMyContact();
if (useInvoiceContact)
{
me = _contactRepository.GetContactById(invoice.PurchaserContactId);
}
else
{
me = _contactRepository.GetMyProfile(token);
}
var payments = _paymentRepository.GetPaymentsForInvoice(invoiceId);
var currentPayment = payments.Where(p => p.PaymentId == paymentId && p.ContactId == me.Contact_ID).ToList();
if (currentPayment.Any() || paymentId == 0)
{
var totalPaymentsMade = payments.Sum(p => p.PaymentTotal);
var leftToPay = invoice.InvoiceTotal - totalPaymentsMade;
StripeCharge charge = null;
if (payments.Count > 0)
{
charge = _paymentProcessorService.GetCharge(payments.First().TransactionCode);
}
return(new PaymentDetailDTO()
{
PaymentAmount = currentPayment.Any() ? currentPayment.First().PaymentTotal : 0M,
RecipientEmail = me.Email_Address,
TotalToPay = leftToPay,
InvoiceTotal = invoice.InvoiceTotal,
RecentPaymentId = payments.Any() ? payments.First().PaymentId : 0,
RecentPaymentAmount = payments.Any() ? payments.First().PaymentTotal : 0,
RecentPaymentLastFour = charge != null ? charge.Source?.AccountNumberLast4 : ""
});
}
throw new Exception("No Payment found for " + me.Email_Address + " with id " + paymentId);
}
public void SendTwoRsvpEmails()
{
const int daysBefore = 999;
const int emailTemplateId = 77;
var participants = new List <MpEventParticipant>
{
new MpEventParticipant
{
ParticipantId = 1,
EventId = 123,
ContactId = 987654
},
new MpEventParticipant
{
ParticipantId = 2,
EventId = 456,
ContactId = 456123
}
};
var mockPrimaryContact = new MpContact
{
ContactId = 98765,
EmailAddress = "*****@*****.**"
};
var defaultContact = new MpMyContact
{
Contact_ID = 123456,
Email_Address = "*****@*****.**"
};
var mockEvent1 = new MpEvent {
EventType = "Childcare", PrimaryContact = mockPrimaryContact
};
var mockEvent2 = new MpEvent {
EventType = "DoggieDaycare", PrimaryContact = mockPrimaryContact
};
var mockEvents = new List <MpEvent> {
mockEvent1, mockEvent2
};
_configurationWrapper.Setup(m => m.GetConfigIntValue("NumberOfDaysBeforeEventToSend")).Returns(daysBefore);
_configurationWrapper.Setup(m => m.GetConfigIntValue("ChildcareRequestTemplate")).Returns(emailTemplateId);
_communicationService.Setup(m => m.GetTemplate(emailTemplateId)).Returns(new MpMessageTemplate());
_eventParticipantService.Setup(m => m.GetChildCareParticipants(daysBefore)).Returns(participants);
_communicationService.Setup(m => m.SendMessage(It.IsAny <MpCommunication>(), false)).Verifiable();
var kids = new List <Participant> {
new Participant {
ContactId = 456321987
}
};
_crdsEventService.Setup(m => m.EventParticpants(987654321, It.IsAny <string>())).Returns(kids);
var mockChildcareEvent = new MpEvent {
EventId = 987654321
};
var mockContact = new MpContact
{
ContactId = 8888888,
EmailAddress = "*****@*****.**"
};
mockChildcareEvent.PrimaryContact = mockContact;
_crdsEventService.Setup(m => m.GetChildcareEvent(participants[0].EventId)).Returns(mockChildcareEvent);
_crdsEventService.Setup(m => m.GetChildcareEvent(participants[1].EventId)).Returns(mockChildcareEvent);
_configurationWrapper.Setup(m => m.GetConfigIntValue("DefaultContactEmailId")).Returns(1234);
_contactService.Setup(mocked => mocked.GetContactById(1234)).Returns(defaultContact);
var myKids = new List <Participant>();
_crdsEventService.Setup(m => m.MyChildrenParticipants(987654, kids, It.IsAny <string>())).Returns(myKids);
_fixture.SendRequestForRsvp();
_configurationWrapper.VerifyAll();
_communicationService.VerifyAll();
_contactService.VerifyAll();
_eventParticipantService.VerifyAll();
_communicationService.VerifyAll();
_communicationService.Verify(m => m.SendMessage(It.IsAny <MpCommunication>(), false), Times.Exactly(2));
_eventService.VerifyAll();
}
public void CanCreateInvitationsForGroups()
{
const string token = "dude";
var invitation = new Invitation()
{
EmailAddress = "*****@*****.**",
GroupRoleId = GroupRoleLeader,
InvitationType = GroupInvitationType,
RecipientName = "Dudley Doright",
RequestDate = new DateTime(2016, 7, 6),
SourceId = 33
};
var mpInvitation = new MpInvitation
{
InvitationType = invitation.InvitationType,
EmailAddress = invitation.EmailAddress,
GroupRoleId = invitation.GroupRoleId,
RecipientName = invitation.RecipientName,
RequestDate = invitation.RequestDate,
SourceId = invitation.SourceId,
InvitationGuid = "guid123",
InvitationId = 11
};
_invitationRepository.Setup(
m =>
m.CreateInvitation(
It.Is <MpInvitation>(
i =>
i.InvitationType == invitation.InvitationType && i.EmailAddress.Equals(invitation.EmailAddress) && i.GroupRoleId == invitation.GroupRoleId &&
i.RecipientName.Equals(invitation.RecipientName) && i.RequestDate.Equals(invitation.RequestDate) && i.SourceId == invitation.SourceId))).Returns(mpInvitation);
var testGroup = new MpGroup
{
GroupId = 33,
Name = "TestGroup"
};
_groupRepository.Setup(mocked => mocked.getGroupDetails(invitation.SourceId)).Returns(testGroup);
var testLeaderParticipant = new MpParticipant
{
DisplayName = "TestLeaderName",
ContactId = 123,
EmailAddress = "*****@*****.**"
};
var leaderContact = new MpMyContact
{
Last_Name = "TestLast",
Nickname = "TestNick"
};
_contactRespository.Setup(mocked => mocked.GetContactById(testLeaderParticipant.ContactId)).Returns(leaderContact);
_participantRepository.Setup(mocked => mocked.GetParticipantRecord(token)).Returns(testLeaderParticipant);
var template = new MpMessageTemplate
{
Body = "body",
FromContactId = 12,
FromEmailAddress = "*****@*****.**",
ReplyToContactId = 34,
ReplyToEmailAddress = "*****@*****.**",
Subject = "subject"
};
_communicationService.Setup(mocked => mocked.GetTemplate(GroupInvitationEmailTemplate)).Returns(template);
//_communicationService.Setup(
// mocked =>
// mocked.SendMessage(
// It.Is<MpCommunication>(
// c =>
// c.AuthorUserId == 5 && c.DomainId == DomainId && c.EmailBody.Equals(template.Body) && c.EmailSubject.Equals(template.Subject) &&
// c.FromContact.ContactId == template.FromContactId && c.FromContact.EmailAddress.Equals(template.FromEmailAddress) &&
// c.ReplyToContact.ContactId == template.ReplyToContactId && c.ReplyToContact.EmailAddress.Equals(template.ReplyToEmailAddress) &&
// c.ToContacts.Count == 1 && c.ToContacts[0].EmailAddress.Equals(invitation.EmailAddress) &&
// c.MergeData["Invitation_GUID"].ToString().Equals(mpInvitation.InvitationGuid) &&
// c.MergeData["Recipient_Name"].ToString().Equals(mpInvitation.RecipientName) &&
// c.MergeData["Leader_Name"].ToString().Equals(testLeaderParticipant.DisplayName) &&
// c.MergeData["Group_Name"].ToString().Equals(testGroup.Name)),
// false)).Returns(77);
_communicationService.Setup(
mocked =>
mocked.SendMessage(
It.Is <MpCommunication>(
c =>
c.AuthorUserId == 5 && c.DomainId == DomainId && c.EmailBody.Equals(template.Body) && c.EmailSubject.Equals(template.Subject) &&
c.FromContact.ContactId == template.FromContactId && c.FromContact.EmailAddress.Equals(template.FromEmailAddress) &&
c.ReplyToContact.ContactId == testLeaderParticipant.ContactId && c.ReplyToContact.EmailAddress.Equals(template.ReplyToEmailAddress) &&
c.ToContacts.Count == 1 && c.ToContacts[0].EmailAddress.Equals(invitation.EmailAddress) &&
c.MergeData["Invitation_GUID"].ToString().Equals(mpInvitation.InvitationGuid) &&
c.MergeData["Recipient_Name"].ToString().Equals(mpInvitation.RecipientName) &&
c.MergeData["Leader_Name"].ToString().Equals(leaderContact.Nickname + " " + leaderContact.Last_Name) &&
c.MergeData["Group_Name"].ToString().Equals(testGroup.Name)),
false)).Returns(77);
var created = _fixture.CreateInvitation(invitation, token);
_invitationRepository.VerifyAll();
_communicationService.VerifyAll();
Assert.AreSame(invitation, created);
Assert.AreEqual(mpInvitation.InvitationId, created.InvitationId);
Assert.AreEqual(mpInvitation.InvitationGuid, created.InvitationGuid);
}
