/// <summary>
/// Deleted a queued email
/// </summary>
/// <param name="queuedEmail">Queued email</param>
public virtual void DeleteQueuedEmail(QueuedEmail queuedEmail)
{
if (queuedEmail == null)
throw new ArgumentNullException("queuedEmail");
_queuedEmailRepository.Delete(queuedEmail);
//event notification
_eventPublisher.EntityDeleted(queuedEmail);
}
public void Can_save_and_load_queuedEmail()
{
var qe = new QueuedEmail()
{
Priority = 1,
From = "From",
FromName = "FromName",
To = "To",
ToName = "ToName",
CC = "CC",
Bcc = "Bcc",
Subject = "Subject",
Body = "Body",
CreatedOnUtc = new DateTime(2010, 01, 01),
SentTries = 5,
SentOnUtc = new DateTime(2010, 02, 02),
EmailAccount = new EmailAccount
{
Email = "*****@*****.**",
DisplayName = "Administrator",
Host = "127.0.0.1",
Port = 125,
Username = "******",
Password = "******",
EnableSsl = true,
UseDefaultCredentials = true
}
};
var fromDb = SaveAndLoadEntity(qe);
fromDb.ShouldNotBeNull();
fromDb.Priority.ShouldEqual(1);
fromDb.From.ShouldEqual("From");
fromDb.FromName.ShouldEqual("FromName");
fromDb.To.ShouldEqual("To");
fromDb.ToName.ShouldEqual("ToName");
fromDb.CC.ShouldEqual("CC");
fromDb.Bcc.ShouldEqual("Bcc");
fromDb.Subject.ShouldEqual("Subject");
fromDb.Body.ShouldEqual("Body");
fromDb.CreatedOnUtc.ShouldEqual(new DateTime(2010, 01, 01));
fromDb.SentTries.ShouldEqual(5);
fromDb.SentOnUtc.Value.ShouldEqual(new DateTime(2010, 02, 02));
fromDb.EmailAccount.ShouldNotBeNull();
fromDb.EmailAccount.DisplayName.ShouldEqual("Administrator");
}
private int SendNotification(MessageTemplate messageTemplate,
EmailAccount emailAccount, int languageId, IEnumerable<Token> tokens,
string toEmailAddress, string toName)
{
//retrieve localized message template data
var bcc = messageTemplate.GetLocalized((mt) => mt.BccEmailAddresses, languageId);
var subject = messageTemplate.GetLocalized((mt) => mt.Subject, languageId);
var body = messageTemplate.GetLocalized((mt) => mt.Body, languageId);
//Replace subject and body tokens
var subjectReplaced = _tokenizer.Replace(subject, tokens, false);
var bodyReplaced = _tokenizer.Replace(body, tokens, true);
var email = new QueuedEmail()
{
Priority = 5,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = toEmailAddress,
ToName = toName,
CC = string.Empty,
Bcc = bcc,
Subject = subjectReplaced,
Body = bodyReplaced,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
_queuedEmailService.InsertQueuedEmail(email);
return email.Id;
}
/// <summary>
/// Sends a campaign to specified emails
/// </summary>
/// <param name="campaign">Campaign</param>
/// <param name="emailAccount">Email account</param>
/// <param name="subscriptions">Subscriptions</param>
/// <returns>Total emails sent</returns>
public virtual int SendCampaign(Campaign campaign, EmailAccount emailAccount,
IEnumerable<NewsLetterSubscription> subscriptions)
{
if (campaign == null)
throw new ArgumentNullException("campaign");
if (emailAccount == null)
throw new ArgumentNullException("emailAccount");
int totalEmailsSent = 0;
foreach (var subscription in subscriptions)
{
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens, _storeContext.CurrentStore);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
var customer = _customerService.GetCustomerByEmail(subscription.Email);
if (customer != null)
_messageTokenProvider.AddCustomerTokens(tokens, customer);
string subject = _tokenizer.Replace(campaign.Subject, tokens, false);
string body = _tokenizer.Replace(campaign.Body, tokens, true);
var email = new QueuedEmail()
{
Priority = 3,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = subscription.Email,
Subject = subject,
Body = body,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
_queuedEmailService.InsertQueuedEmail(email);
totalEmailsSent++;
}
return totalEmailsSent;
}
public ActionResult SendEmail(CustomerModel model)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageCustomers))
return AccessDeniedView();
var customer = _customerService.GetCustomerById(model.Id);
if (customer == null)
//No customer found with the specified id
return RedirectToAction("List");
try
{
if (String.IsNullOrWhiteSpace(customer.Email))
throw new NasException("Customer email is empty");
if (!CommonHelper.IsValidEmail(customer.Email))
throw new NasException("Customer email is not valid");
if (String.IsNullOrWhiteSpace(model.SendEmail.Subject))
throw new NasException("Email subject is empty");
if (String.IsNullOrWhiteSpace(model.SendEmail.Body))
throw new NasException("Email body is empty");
var emailAccount = _emailAccountService.GetEmailAccountById(_emailAccountSettings.DefaultEmailAccountId);
if (emailAccount == null)
emailAccount = _emailAccountService.GetAllEmailAccounts().FirstOrDefault();
if (emailAccount == null)
throw new NasException("Email account can't be loaded");
var email = new QueuedEmail()
{
EmailAccountId = emailAccount.Id,
FromName = emailAccount.DisplayName,
From = emailAccount.Email,
ToName = customer.GetFullName(),
To = customer.Email,
Subject = model.SendEmail.Subject,
Body = model.SendEmail.Body,
CreatedOnUtc = DateTime.UtcNow,
};
_queuedEmailService.InsertQueuedEmail(email);
SuccessNotification(_localizationService.GetResource("Admin.Customers.Customers.SendEmail.Queued"));
}
catch (Exception exc)
{
ErrorNotification(exc.Message);
}
return RedirectToAction("Edit", new { id = customer.Id });
}
public static QueuedEmail ToEntity(this QueuedEmailModel model, QueuedEmail destination)
{
return Mapper.Map(model, destination);
}
public ActionResult Requeue(QueuedEmailModel queuedEmailModel)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageMessageQueue))
return AccessDeniedView();
var queuedEmail = _queuedEmailService.GetQueuedEmailById(queuedEmailModel.Id);
if (queuedEmail == null)
//No email found with the specified id
return RedirectToAction("List");
var requeuedEmail = new QueuedEmail()
{
Priority = queuedEmail.Priority,
From = queuedEmail.From,
FromName = queuedEmail.FromName,
To = queuedEmail.To,
ToName = queuedEmail.ToName,
CC = queuedEmail.CC,
Bcc = queuedEmail.Bcc,
Subject = queuedEmail.Subject,
Body = queuedEmail.Body,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = queuedEmail.EmailAccountId
};
_queuedEmailService.InsertQueuedEmail(requeuedEmail);
SuccessNotification(_localizationService.GetResource("Admin.System.QueuedEmails.Requeued"));
return RedirectToAction("Edit", requeuedEmail.Id);
}
/// <summary>
/// Sends SMS
/// </summary>
/// <param name="text">SMS text</param>
/// <returns>Result</returns>
public bool SendSms(string text)
{
try
{
var emailAccount = _emailAccountService.GetEmailAccountById(_emailAccountSettings.DefaultEmailAccountId);
if (emailAccount == null)
emailAccount = _emailAccountService.GetAllEmailAccounts().FirstOrDefault();
if (emailAccount == null)
throw new Exception("No email account could be loaded");
var queuedEmail = new QueuedEmail()
{
Priority = 5,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = _verizonSettings.Email,
ToName = string.Empty,
Subject = _storeContext.CurrentStore.Name,
Body = text,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
_queuedEmailService.InsertQueuedEmail(queuedEmail);
return true;
}
catch (Exception ex)
{
_logger.Error(ex.Message, ex);
return false;
}
}