/// <summary>
/// Sends a newsletter subscription activation message
/// </summary>
/// <param name="subscription">Newsletter subscription</param>
/// <param name="languageId">Language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewsLetterSubscriptionActivationMessage(NewsLetterSubscription subscription, int languageId)
{
if (subscription == null)
{
throw new ArgumentNullException("subscription");
}
languageId = EnsureLanguageIsActive(languageId);
var messageTemplate = GetLocalizedActiveMessageTemplate("NewsLetterSubscription.ActivationMessage", languageId);
if (messageTemplate == null)
{
return(0);
}
//tokens
var tokens = new List <Token>();
_messageTokenProvider.AddSiteTokens(tokens);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, tokens);
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
var toEmail = subscription.Email;
var toName = "";
return(SendNotification(messageTemplate, emailAccount, languageId, tokens, toEmail, toName));
}
/// <summary>
/// Sends a newsletter subscription activation message
/// </summary>
/// <param name="subscription">Newsletter subscription</param>
/// <param name="languageId">Language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewsLetterSubscriptionActivationMessage(NewsLetterSubscription subscription, int languageId)
{
if (subscription == null)
{
throw new ArgumentNullException("subscription");
}
var application = _sysContext.CurrentApplication;
languageId = EnsureLanguageIsActive(languageId, application.Id);
var messageTemplate = GetActiveMessageTemplate(MessageTemplateSystemNames.NewsletterSubscriptionActivationMessage, application.Id);
if (messageTemplate == null)
{
return(0);
}
//email account
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
//tokens
var tokens = new List <Token>();
_messageTokenProvider.AddApplicationTokens(tokens, application, emailAccount);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, tokens);
return(SendNotification(messageTemplate, emailAccount, languageId, tokens, subscription.Email, string.Empty));
}
/// <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");
}
if (subscriptions == null || subscriptions.Count() <= 0)
{
return(0);
}
int totalEmailsSent = 0;
var subscriptionData = subscriptions
.Where(x => _storeMappingService.Authorize <Campaign>(campaign, x.StoreId))
.GroupBy(x => x.Email);
foreach (var group in subscriptionData)
{
var subscription = group.First(); // only one email per email address
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);
}
private IList <Token> GenerateTokens(NewsLetterSubscription subscription)
{
var tokens = new List <Token>();
_messageTokenProvider.AddStoreTokens(tokens);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
return(tokens);
}
/// <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(nameof(campaign));
}
if (emailAccount == null)
{
throw new ArgumentNullException(nameof(emailAccount));
}
var totalEmailsSent = 0;
foreach (var subscription in subscriptions)
{
var customer = _customerService.GetCustomerByEmail(subscription.Email);
//ignore deleted or inactive customers when sending newsletter campaigns
if (customer != null && (!customer.Active || customer.Deleted))
{
continue;
}
var tokens = new List <Token>();
_messageTokenProvider.AddStoreTokens(tokens, _storeContext.CurrentStore, emailAccount);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
if (customer != null)
{
_messageTokenProvider.AddCustomerTokens(tokens, customer);
}
var subject = _tokenizer.Replace(campaign.Subject, tokens, false);
var body = _tokenizer.Replace(campaign.Body, tokens, true);
var email = new QueuedEmail
{
Priority = QueuedEmailPriority.Low,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = subscription.Email,
Subject = subject,
Body = body,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id,
DontSendBeforeDateUtc = campaign.DontSendBeforeDateUtc
};
_queuedEmailService.InsertQueuedEmail(email);
totalEmailsSent++;
}
return(totalEmailsSent);
}
/// <summary>
/// Sends a newsletter subscription activation message
/// </summary>
/// <param name="subscription">Newsletter subscription</param>
/// <param name="languageId">Language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual IList <int> SendNewsLetterSubscriptionActivationMessage(NewsLetterSubscription subscription, int languageId)
{
if (subscription == null)
{
throw new ArgumentNullException(nameof(subscription));
}
var store = _storeContext.CurrentStore;
languageId = EnsureLanguageIsActive(languageId, store.Id);
var messageTemplates = GetActiveMessageTemplates(MessageTemplateSystemNames.NewsletterSubscriptionActivationMessage, store.Id);
if (!messageTemplates.Any())
{
return(new List <int>());
}
//tokens
var commonTokens = new List <Token>();
_messageTokenProvider.AddNewsLetterSubscriptionTokens(commonTokens, subscription);
return(messageTemplates.Select(messageTemplate =>
{
//email account
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
var tokens = new List <Token>(commonTokens);
_messageTokenProvider.AddStoreTokens(tokens, store, emailAccount);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, tokens);
return SendNotification(messageTemplate, emailAccount, languageId, tokens, subscription.Email, string.Empty);
}).ToList());
}
/// <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);
_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);
}
/// <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)
{
Customer customer = null;
if (!String.IsNullOrEmpty(subscription.CustomerId))
{
customer = _customerService.GetCustomerById(subscription.CustomerId);
}
if (customer == null)
{
customer = _customerService.GetCustomerByEmail(subscription.Email);
}
//ignore deleted or inactive customers when sending newsletter campaigns
if (customer != null && (!customer.Active || customer.Deleted))
{
continue;
}
var tokens = new List <Token>();
_messageTokenProvider.AddStoreTokens(tokens, _storeContext.CurrentStore, emailAccount);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
if (customer != null)
{
_messageTokenProvider.AddCustomerTokens(tokens, customer);
_messageTokenProvider.AddShoppingCartTokens(tokens, customer);
_messageTokenProvider.AddRecommendedProductsTokens(tokens, customer);
_messageTokenProvider.AddRecentlyViewedProductsTokens(tokens, customer);
}
string subject = _tokenizer.Replace(campaign.Subject, tokens, false);
string body = _tokenizer.Replace(campaign.Body, tokens, true);
var email = new QueuedEmail
{
Priority = QueuedEmailPriority.Low,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = subscription.Email,
Subject = subject,
Body = body,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
_queuedEmailService.InsertQueuedEmail(email);
InsertCampaignHistory(new CampaignHistory()
{
CampaignId = campaign.Id, CustomerId = subscription.CustomerId, Email = subscription.Email, CreatedDateUtc = DateTime.UtcNow, StoreId = campaign.StoreId
});
//activity log
if (customer != null)
{
_customerActivityService.InsertActivity("CustomerReminder.SendCampaign", campaign.Id, _localizationService.GetResource("ActivityLog.SendCampaign"), customer, campaign.Name);
}
else
{
_customerActivityService.InsertActivity("CustomerReminder.SendCampaign", campaign.Id, _localizationService.GetResource("ActivityLog.SendCampaign"), campaign.Name + " - " + subscription.Email);
}
totalEmailsSent++;
}
return(totalEmailsSent);
}
/// <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 async Task <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;
var language = await _languageService.GetLanguageById(campaign.LanguageId);
if (language == null)
{
language = (await _languageService.GetAllLanguages()).FirstOrDefault();
}
foreach (var subscription in subscriptions)
{
Customer customer = null;
if (!String.IsNullOrEmpty(subscription.CustomerId))
{
customer = await _customerService.GetCustomerById(subscription.CustomerId);
}
if (customer == null)
{
customer = await _customerService.GetCustomerByEmail(subscription.Email);
}
//ignore deleted or inactive customers when sending newsletter campaigns
if (customer != null && (!customer.Active || customer.Deleted))
{
continue;
}
var liquidObject = new LiquidObject();
var store = await _storeService.GetStoreById(campaign.StoreId);
if (store == null)
{
store = (await _storeService.GetAllStores()).FirstOrDefault();
}
await _messageTokenProvider.AddStoreTokens(liquidObject, store, language, emailAccount);
await _messageTokenProvider.AddNewsLetterSubscriptionTokens(liquidObject, subscription, store);
if (customer != null)
{
await _messageTokenProvider.AddCustomerTokens(liquidObject, customer, store, language);
await _messageTokenProvider.AddShoppingCartTokens(liquidObject, customer, store, language);
}
var body = LiquidExtensions.Render(liquidObject, campaign.Body);
var subject = LiquidExtensions.Render(liquidObject, campaign.Subject);
var email = new QueuedEmail {
Priority = QueuedEmailPriority.Low,
From = emailAccount.Email,
FromName = emailAccount.DisplayName,
To = subscription.Email,
Subject = subject,
Body = body,
CreatedOnUtc = DateTime.UtcNow,
EmailAccountId = emailAccount.Id
};
await _queuedEmailService.InsertQueuedEmail(email);
await InsertCampaignHistory(new CampaignHistory()
{
CampaignId = campaign.Id, CustomerId = subscription.CustomerId, Email = subscription.Email, CreatedDateUtc = DateTime.UtcNow, StoreId = campaign.StoreId
});
//activity log
if (customer != null)
{
await _customerActivityService.InsertActivity("CustomerReminder.SendCampaign", campaign.Id, _localizationService.GetResource("ActivityLog.SendCampaign"), customer, campaign.Name);
}
else
{
await _customerActivityService.InsertActivity("CustomerReminder.SendCampaign", campaign.Id, _localizationService.GetResource("ActivityLog.SendCampaign"), campaign.Name + " - " + subscription.Email);
}
totalEmailsSent++;
}
return(totalEmailsSent);
}
/// <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, int languageId, List <int> Categories, DateTime startDate, DateTime?endDate, int itemCount)
{
if (campaign == null)
{
throw new ArgumentNullException("campaign");
}
if (emailAccount == null)
{
throw new ArgumentNullException("emailAccount");
}
int totalEmailsSent = 0;
bool hasProductsToken = campaign.Body.IndexOf("%Store.RecentProducts%") > 0;
bool hasBuyingRequests = campaign.Body.IndexOf("%Store.RecentProductBuyingRequests%") > 0;
var productDates = new NewsletterDates();
var buyingRequestDates = new NewsletterDates();
var tokens = new List <Token>();
if (hasProductsToken)
{
productDates = _newsletterDatesService.GetAllNewsletterDates().Where(x => x.LanguageId == languageId && x.IsProduct).FirstOrDefault();
if (endDate == null)
{
startDate = productDates.LastSubmit;
}
_messageTokenProvider.AddRecentProductsToken(tokens, languageId, Categories, startDate, endDate, itemCount);
}
if (hasBuyingRequests)
{
buyingRequestDates = _newsletterDatesService.GetAllNewsletterDates().Where(x => x.LanguageId == languageId && !x.IsProduct).FirstOrDefault();
if (endDate == null)
{
startDate = buyingRequestDates.LastSubmit;
}
_messageTokenProvider.AddRecentBuyingRequestsToken(tokens, languageId, Categories, startDate, endDate, itemCount);
}
foreach (var subscription in subscriptions.Where(x => x.LanguageId == languageId))
{
var tokensTemp = new List <Token>();
tokensTemp.AddRange(tokens);
_messageTokenProvider.AddStoreTokens(tokensTemp);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokensTemp, subscription);
var customer = _customerService.GetCustomerByEmail(subscription.Email);
if (customer != null)
{
_messageTokenProvider.AddCustomerTokens(tokensTemp, customer);
}
string subject = _tokenizer.Replace(campaign.Subject, tokensTemp, false);
string body = _tokenizer.Replace(campaign.Body, tokensTemp, 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++;
}
if (hasProductsToken)
{
productDates.LastSubmit = DateTime.UtcNow;
_newsletterDatesService.UpdateNewsletterDates(productDates);
}
if (hasBuyingRequests)
{
buyingRequestDates.LastSubmit = DateTime.UtcNow;
_newsletterDatesService.UpdateNewsletterDates(buyingRequestDates);
}
return(totalEmailsSent);
}
