public void GetQueueCountTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
int expected = emailService.GetQueueCount();
// Create a message
string subject = RandomString(),
text = LorumIpsum();
var sender = new UserModel {
EMail = RandomEMail()
};
var message = new EMailMessage(sender, testUser, subject, text);
var result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
int actual = emailService.GetQueueCount();
expected++;
Assert.IsTrue(actual == expected, $"Error: SendEMail returned error code {result} when 0 was expected");
// Delete the email
emailService.DeleteEMailQueue(result.Id);
actual = emailService.GetQueueCount();
expected--;
Assert.IsTrue(actual == expected, $"Error: SendEMail returned error code {result} when 0 was expected");
}
public void AddUserDetailsTest()
{
var testUser = GetTestUser(true, false);
Dictionary <string, string> dict = new Dictionary <string, string>();
int expected = 0,
actual = dict.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
EMailService.EMailService emailService = new EMailService.EMailService(db);
emailService.AddUserDetails(testUser, dict);
expected = 2;
actual = dict.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were found when {expected} were expected");
string keyName = "USERNAME";
try {
var test = dict[keyName].ToString();
Assert.IsTrue(testUser.FullName == test, $"Error: {test} was returned when {testUser.FullName} was expected");
} catch {
Assert.Fail($"Error: Item '{keyName}' was not found in the dictionary");
}
keyName = "EMAIL";
try {
var test = dict[keyName].ToString();
Assert.IsTrue(testUser.EMail == test, $"Error: {test} was returned when {testUser.EMail} was expected");
} catch {
Assert.Fail($"Error: Item '{keyName}' was not found in the dictionary");
}
}
protected Error SendMessage(CompanyModel company,
UserModel sender,
MessageTemplateType templateId,
TaskType notificationType,
List <UserModel> recipients,
Dictionary <string, string> dict,
List <string> attachments = null)
{
// Send as email
var message = new EMailMessage(sender, templateId);
message.AddRecipients(recipients);
message.AddProperties(dict);
message.AddAttachments(attachments);
EMailService.EMailService es = new EMailService.EMailService(_db, company);
var error = es.SendEMail(message);
//if (!error.IsError) {
// Now send as a notification
// TaskManagerService.TaskManagerService ts = new TaskManagerService.TaskManagerService(_db, company);
// error = ts.SendTask(templateId, notificationType, recipients, dict);
//}
return(error);
}
public void SendMSQOverrideEMailTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser, true);
var testCustomer = GetTestCustomer(testCompany, testUser);
var soh = GetTestSalesOrderHeader(testCompany, testCustomer, testUser, RandomInt(5, 50));
EMailService.EMailService EMailService = GetEMailService(testCompany);
TaskManagerService.TaskManagerService TaskManagerService = GetTaskManagerService(testCompany);
int emailQBefore = EMailService.GetQueueCount(),
notificationsBefore = TaskManagerService.GetTaskCount();
var testUser2 = GetTestUser();
var error = SalesService.SendMSQOverrideEMail(testCompany, testUser, testUser2, soh);
int emailQAfter = EMailService.GetQueueCount(),
notificationsAfter = TaskManagerService.GetTaskCount();
int actual = emailQAfter - emailQBefore,
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} EMail items were returned when {expected} were expected");
actual = notificationsAfter - notificationsBefore;
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} Notifications were returned when {expected} were expected");
}
protected EMailService.EMailService EMailService(CompanyModel company = null)
{
if (_emailService == null)
{
_emailService = new EMailService.EMailService(db, company);
}
return(_emailService);
}
public void CheckCompanyForPassedUnpackDatesTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
EMailService.EMailService service = new EMailService.EMailService(db);
service.EmptyEMailQueue();
var task = new NotificationTask(db);
// Check email queue - should be 0 added
var expected = 0;
task.CheckCompanyForPassedUnpackDates(testCompany);
var actual = service.GetQueueCount();
Assert.IsTrue(actual == expected, $"Error: Email Count returned {actual} when {expected} was expected");
// Call email queue = 0 = actual
// Create POs with Data > now
var poStatuses = Enum.GetValues(typeof(PurchaseOrderStatus));
var names = Enum.GetNames(typeof(PurchaseOrderStatus));
foreach (var value in Enum.GetValues(typeof(PurchaseOrderStatus)))
{
var po = GetTestPurchaseOrderHeader(testCompany, testUser);
po.RealisticRequiredDate = DateTime.Now.AddDays((int)value);
po.POStatus = (int)value;
PurchasingService.InsertOrUpdatePurchaseOrderHeader(po, testUser, PurchasingService.LockPurchaseOrderHeader(po));
}
task.CheckCompanyForPassedUnpackDates(testCompany);
actual = service.GetQueueCount();
Assert.IsTrue(actual == expected, $"Error: Email Count returned {actual} when {expected} was expected");
// Create POs with Data < now
foreach (var value in Enum.GetValues(typeof(PurchaseOrderStatus)))
{
var po = GetTestPurchaseOrderHeader(testCompany, testUser);
po.RealisticRequiredDate = DateTime.Now.AddDays((int)value - 100);
po.POStatus = (int)value;
PurchasingService.InsertOrUpdatePurchaseOrderHeader(po, testUser, PurchasingService.LockPurchaseOrderHeader(po));
}
expected = 9;
task.CheckCompanyForPassedUnpackDates(testCompany);
actual = service.GetQueueCount();
Assert.IsTrue(actual == expected, $"Error: Email Count returned {actual} when {expected} was expected");
}
public void EmptyEMailQueueTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
var sender = new UserModel {
EMail = GetAppSetting("SenderAddress", "")
};
UserModel recipient = new UserModel {
EMail = GetAppSetting("RecipientAddress", "")
};
// Create messages
int numMsgs = 10;
for (int i = 0; i < numMsgs; i++)
{
var error = new Error();
var message = new EMailMessage(sender, recipient, MessageTemplateType.TestMessage);
message.AddProperty("MESSAGECONTENT", $"This message is {i + 1} of {numMsgs} and has been sent by an Evolution outomated test - please ignore.");
error = emailService.SendEMail(message);
Assert.IsTrue(!error.IsError, error.Message);
}
// Get the queue count
int expected = 10,
actual = emailService.GetQueueCount();
Assert.IsTrue(actual >= expected, $"Error: {actual} queue messages were found when {expected} were expected");
// Clean the queue
emailService.EmptyEMailQueue();
// Chekc it again
expected = 0;
actual = emailService.GetQueueCount();
Assert.IsTrue(actual == expected, $"Error: {actual} queue messages were found when {expected} were expected");
}
public void FindEMailQueueListModelTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompanyAU();
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
// Now create an email and try to search for it
string subject = RandomString(),
text = LorumIpsum();
var sender = new UserModel {
EMail = RandomEMail()
};
var message = new EMailMessage(sender, testUser, subject, text);
var result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
// Perform a global test which should bring back the first page
var emailList = emailService.FindEMailQueueListModel(0, 1, PageSize, "");
int actual = emailList.Items
.Where(e => e.MessageSubject == subject)
.Count();
int expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} was expected");
// Delete and check again
emailService.DeleteEMailQueue(result.Id);
emailList = emailService.FindEMailQueueListModel(0, 1, PageSize, "");
actual = emailList.Items
.Where(e => e.MessageSubject == subject)
.Count();
expected = 0;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} was expected");
}
public void SendEMailTest()
{
// Get some test users and test company
List <UserModel> users = new List <UserModel>();
for (int i = 0; i < 10; i++)
{
users.Add(GetTestUser());
}
var testCompany = GetTestCompany(users[0]);
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
// Tests using email templates
var sender = new UserModel {
EMail = RandomEMail()
};
var message = new EMailMessage(sender, MessageTemplateType.TestMessage);
// Single user
var recipient = new UserModel {
EMail = RandomEMail()
};
message.AddRecipient(users[0]);
var result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
var msgs = getMessages(sender);
int actual = msgs.Count(),
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} were expected");
var emailTemplate = LookupService.FindMessageTemplateModel(testCompany.Id, MessageTemplateType.TestMessage);
checkEMailContent(msgs, sender, emailTemplate.Subject);
// Multiple users
sender = new UserModel {
EMail = RandomEMail()
};
message = new EMailMessage(sender, MessageTemplateType.TestMessage);
message.AddRecipients(users);
result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
msgs = getMessages(sender);
actual = msgs.Count();
expected = 1; // One message is sent to all recipients/cc;s/bcc's
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} were expected");
emailTemplate = LookupService.FindMessageTemplateModel(testCompany.Id, MessageTemplateType.TestMessage);
checkEMailContent(msgs, sender, emailTemplate.Subject);
// Tests using straight text
string subject = RandomString(),
text = LorumIpsum();
// Single user
sender = new UserModel {
EMail = RandomEMail()
};
message = new EMailMessage(sender, subject, text);
message.AddRecipient(users[0]);
var result2 = emailService.SendEMail(message);
Assert.IsTrue(!result2.IsError, result.Message);
msgs = getMessages(sender);
actual = msgs.Count();
expected = 1;
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} were expected");
checkEMailContent(msgs, sender, subject);
// Multiple users
sender = new UserModel {
EMail = RandomEMail()
};
message = new EMailMessage(sender, subject, text);
message.AddRecipients(users);
result = emailService.SendEMail(message);
Assert.IsTrue(!result.IsError, result.Message);
msgs = getMessages(sender);
actual = msgs.Count();
expected = 1; // One message is sent to all recipients/cc;s/bcc's
Assert.IsTrue(actual == expected, $"Error: {actual} records were found when {expected} were expected");
checkEMailContent(msgs, sender, subject);
}
public void SendEMailThroughTaskServiceTest()
{
// Get a test user and test company
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
EMailService.EMailService emailService = new EMailService.EMailService(db, testCompany);
MediaService.MediaService mediaService = new Evolution.MediaService.MediaService(db);
var sender = new UserModel {
EMail = GetAppSetting("SenderAddress", "")
};
UserModel recipient = new UserModel {
EMail = GetAppSetting("RecipientAddress", "")
};
// Create messages, the first 10 without attachments, the rest with attachments
int numMsgs = 20;
for (int i = 0; i < numMsgs; i++)
{
var error = new Error();
var message = new EMailMessage(sender, recipient, MessageTemplateType.TestMessage);
if (i >= 10)
{
message.AddProperty("MESSAGECONTENT", $"This message is {i + 1} of {numMsgs} and has been sent with an attachment by an Evolution outomated test - please ignore.");
string tempFile = MediaService.MediaService.GetTempFile(".txt");
db.LogTestFile(tempFile);
message.AddAttachment(tempFile, FileCopyType.Move);
using (StreamWriter sw = new StreamWriter(tempFile)) {
sw.WriteLine("Attachment " + (i - 9).ToString());
sw.WriteLine("");
sw.WriteLine(LorumIpsum());
}
error = emailService.SendEMail(message);
}
else
{
message.AddProperty("MESSAGECONTENT", $"This message is {i + 1} of {numMsgs} and has been sent by an Evolution outomated test - please ignore.");
error = emailService.SendEMail(message);
}
Assert.IsTrue(!error.IsError, error.Message);
}
if (GetAppSetting("EMailSendingServiceInTests", false))
{
TaskService.TaskService ts = new TaskService.TaskService(db);
var mailSender = ts.FindScheduledTaskModel(TaskName.MailSenderTask);
Assert.IsTrue(mailSender != null, "Error: MailSender Scheduled Task not found");
var enabled = mailSender.Enabled;
if (!enabled)
{
ts.EnableTask(mailSender, true);
}
//ts.RunTask(mailSender.Id, true);
var mailSenderTask = new MailSenderTask(db);
string[] args = null;
mailSenderTask.Run(args);
mailSender = ts.FindScheduledTaskModel(TaskName.MailSenderTask);
Assert.IsTrue(mailSender != null, "Error: MailSender Scheduled Task not found");
ts.EnableTask(mailSender, enabled);
}
}
void ScanLogsForErrors()
{
LogSeverity severity = (LogSeverity)GetTaskParameter("ReportErrorsAboveSeverity", (int)LogSeverity.Severe);
DateTime lastRun = GetTaskParameter("LastRun", DateTime.Now);
SetTaskParameter("LastRun", DateTime.Now);
string systemErrors = "",
taskErrors = "";
foreach (var logRecord in _db.FindLogsAfter(lastRun, severity))
{
systemErrors += "<tr><td style=\"width:120px\">Date:</td><td style=\"width:auto\">" + logRecord.LogDate.ToString() + "</td></tr>\r\n";
systemErrors += "<tr><td style=\"vertical-align:top\">URL:</td><td>" + logRecord.Url + "</td></tr>\r\n";
systemErrors += "<tr><td style=\"vertical-align:top\">Error:</td><td>" + logRecord.Message + "</td></tr>\r\n";
systemErrors += "<tr><td style=\"vertical-align:top\">Stack Trace:</td><td>" + logRecord.StackTrace + "</td></tr>\r\n";
}
foreach (var logRecord in _db.FindScheduledTaskLogsAfter(lastRun, severity))
{
taskErrors += "<tr>";
taskErrors += "<td style=\"width:120px\">" + logRecord.LogDate.ToString() + "</td>";
taskErrors += "<td style=\"vertical-align:top\">" + logRecord.ScheduledTask.TaskName + "</td>";
taskErrors += "<td style=\"vertical-align:top\">" + logRecord.Message;
if (!string.IsNullOrEmpty(logRecord.StackTrace))
{
taskErrors += "<br/><br/>" + logRecord.StackTrace;
}
taskErrors += "</td>";
taskErrors += "</tr>\r\n";
}
if (!string.IsNullOrEmpty(systemErrors) || !string.IsNullOrEmpty(taskErrors))
{
if (string.IsNullOrEmpty(systemErrors))
{
systemErrors = "<tr><td>None></td><td></td></tr>";
}
if (string.IsNullOrEmpty(taskErrors))
{
taskErrors = "<tr><td>None></td><td></td><td></td></tr>";
}
string groupName = GetTaskParameter("SendErrorsToGroup", "");
UserGroup userGroup = _db.FindUserGroup(groupName);
if (userGroup == null)
{
WriteTaskLog($"Error: User group '{groupName}' could not be found!");
}
else
{
var sender = new UserModel {
EMail = GetTaskParameter("SenderEMail", "*****@*****.**")
};
var message = new EMailMessage(sender, MessageTemplateType.SystemError);
message.AddProperty("SYSTEMERRORS", systemErrors);
message.AddProperty("TASKERRORS", taskErrors);
foreach (var user in _db.FindUserGroupUsers(userGroup))
{
var userModel = Mapper.Map <User, UserModel>(user);
message.AddRecipient(userModel);
}
EMailService.EMailService emailService = new EMailService.EMailService(_db);
emailService.SendEMail(message);
}
}
}
