/// <summary>
/// Deletes a newsletter subscription
/// </summary>
/// <param name="newsLetterSubscription">NewsLetter subscription</param>
/// <param name="publishSubscriptionEvents">if set to <c>true</c> [publish subscription events].</param>
public virtual void DeleteNewsLetterSubscription(NewsLetterSubscription newsLetterSubscription, bool publishSubscriptionEvents = true)
{
if (newsLetterSubscription == null) throw new ArgumentNullException("newsLetterSubscription");
_subscriptionRepository.Delete(newsLetterSubscription);
//Publish the unsubscribe event
PublishSubscriptionEvent(newsLetterSubscription.Email, false, publishSubscriptionEvents);
//event notification
_eventPublisher.EntityDeleted(newsLetterSubscription);
}
public void VerifyDeleteTriggersUnsubscribeEvent()
{
var eventPublisher = MockRepository.GenerateStub<IEventPublisher>();
var repo = MockRepository.GenerateStub<IRepository<NewsLetterSubscription>>();
var context = MockRepository.GenerateStub<IDbContext>();
var subscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
var service = new NewsLetterSubscriptionService(context, repo, eventPublisher);
service.DeleteNewsLetterSubscription(subscription, true);
eventPublisher.AssertWasCalled(x => x.Publish(new EmailUnsubscribedEvent(subscription.Email)));
}
public void VerifyEmailUpdateTriggersUnsubscribeAndSubscribeEvent()
{
var eventPublisher = MockRepository.GenerateStub<IEventPublisher>();
var repo = MockRepository.GenerateStub<IRepository<NewsLetterSubscription>>();
var context = MockRepository.GenerateStub<IDbContext>();
//Prepare the original result
var originalSubscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
repo.Stub(m => m.GetById(Arg<object>.Is.Anything)).Return(originalSubscription);
var subscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
var service = new NewsLetterSubscriptionService(context, repo, eventPublisher);
service.UpdateNewsLetterSubscription(subscription, true);
eventPublisher.AssertWasCalled(x => x.Publish(new EmailUnsubscribedEvent(originalSubscription.Email)));
eventPublisher.AssertWasCalled(x => x.Publish(new EmailSubscribedEvent(subscription.Email)));
}
public ActionResult SubscribeNewsletter(string email)
{
string result;
bool success = false;
if (!CommonHelper.IsValidEmail(email))
result = _localizationService.GetResource("Newsletter.Email.Wrong");
else
{
//subscribe/unsubscribe
email = email.Trim();
var subscription = _newsLetterSubscriptionService.GetNewsLetterSubscriptionByEmail(email);
if (subscription != null)
{
if (!subscription.Active)
{
_workflowMessageService.SendNewsLetterSubscriptionActivationMessage(subscription, _workContext.WorkingLanguage.Id);
}
result = _localizationService.GetResource("Newsletter.SubscribeEmailSent");
}
else
{
subscription = new NewsLetterSubscription()
{
NewsLetterSubscriptionGuid = Guid.NewGuid(),
Email = email,
Active = false,
CreatedOnUtc = DateTime.UtcNow
};
_newsLetterSubscriptionService.InsertNewsLetterSubscription(subscription);
_workflowMessageService.SendNewsLetterSubscriptionActivationMessage(subscription, _workContext.WorkingLanguage.Id);
result = _localizationService.GetResource("Newsletter.SubscribeEmailSent");
}
success = true;
}
return Json(new
{
Success = success,
Result = result,
});
}
public void Can_save_and_load_nls()
{
var newGuid = Guid.NewGuid();
var now = new DateTime(2010, 01, 01);
var nls = new NewsLetterSubscription
{
Email = "*****@*****.**",
NewsLetterSubscriptionGuid = newGuid,
CreatedOnUtc = now,
Active = true
};
var fromDb = SaveAndLoadEntity(nls);
fromDb.ShouldNotBeNull();
fromDb.Email.ShouldEqual("*****@*****.**");
fromDb.NewsLetterSubscriptionGuid.ShouldEqual(newGuid);
fromDb.CreatedOnUtc.ShouldEqual(now);
fromDb.Active.ShouldBeTrue();
}
/// <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 store = _storeContext.CurrentStore;
languageId = EnsureLanguageIsActive(languageId, store.Id);
var messageTemplate = GetLocalizedActiveMessageTemplate("NewsLetterSubscription.ActivationMessage", languageId, store.Id);
if (messageTemplate == null)
return 0;
//tokens
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens, store);
_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);
}
public virtual void AddNewsLetterSubscriptionTokens(IList<Token> tokens, NewsLetterSubscription subscription)
{
tokens.Add(new Token("NewsLetterSubscription.Email", subscription.Email));
const string urlFormat = "{0}newsletter/subscriptionactivation/{1}/{2}";
var activationUrl = String.Format(urlFormat, _webHelper.GetStoreLocation(false), subscription.NewsLetterSubscriptionGuid, "true");
tokens.Add(new Token("NewsLetterSubscription.ActivationUrl", activationUrl, true));
var deActivationUrl = String.Format(urlFormat, _webHelper.GetStoreLocation(false), subscription.NewsLetterSubscriptionGuid, "false");
tokens.Add(new Token("NewsLetterSubscription.DeactivationUrl", deActivationUrl, true));
//event notification
_eventPublisher.EntityTokensAdded(subscription, tokens);
}
public ActionResult ImportCsv(FormCollection form)
{
if (!_permissionService.Authorize(StandardPermissionProvider.ManageNewsletterSubscribers))
return AccessDeniedView();
try
{
var file = Request.Files["importcsvfile"];
if (file != null && file.ContentLength > 0)
{
int count = 0;
using (var reader = new StreamReader(file.InputStream))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (String.IsNullOrWhiteSpace(line))
continue;
string[] tmp = line.Split(',');
var email = "";
bool isActive = true;
//parse
if (tmp.Length == 1)
{
//"email" only
email = tmp[0].Trim();
}
else if (tmp.Length == 2)
{
//"email" and "active" fields specified
email = tmp[0].Trim();
isActive = Boolean.Parse(tmp[1].Trim());
}
else
throw new NasException("Wrong file format");
//import
var subscription = _newsLetterSubscriptionService.GetNewsLetterSubscriptionByEmail(email);
if (subscription != null)
{
subscription.Email = email;
subscription.Active = isActive;
_newsLetterSubscriptionService.UpdateNewsLetterSubscription(subscription);
}
else
{
subscription = new NewsLetterSubscription()
{
Active = isActive,
CreatedOnUtc = DateTime.UtcNow,
Email = email,
NewsLetterSubscriptionGuid = Guid.NewGuid()
};
_newsLetterSubscriptionService.InsertNewsLetterSubscription(subscription);
}
count++;
}
SuccessNotification(String.Format(_localizationService.GetResource("Admin.Promotions.NewsLetterSubscriptions.ImportEmailsSuccess"), count));
return RedirectToAction("List");
}
}
ErrorNotification(_localizationService.GetResource("Admin.Common.UploadFile"));
return RedirectToAction("List");
}
catch (Exception exc)
{
ErrorNotification(exc);
return RedirectToAction("List");
}
}
public static NewsLetterSubscription ToEntity(this NewsLetterSubscriptionModel model, NewsLetterSubscription destination)
{
return Mapper.Map(model, destination);
}
public void VerifyUpdateEventIsFired()
{
var eventPublisher = MockRepository.GenerateStub<IEventPublisher>();
var repo = MockRepository.GenerateStub<IRepository<NewsLetterSubscription>>();
var context = MockRepository.GenerateStub<IDbContext>();
//Prepare the original result
var originalSubscription = new NewsLetterSubscription { Active = false, Email = "*****@*****.**" };
repo.Stub(m => m.GetById(Arg<object>.Is.Anything)).Return(originalSubscription);
var service = new NewsLetterSubscriptionService(context, repo, eventPublisher);
service.UpdateNewsLetterSubscription(new NewsLetterSubscription { Email = "*****@*****.**" });
eventPublisher.AssertWasCalled(x => x.EntityUpdated(Arg<NewsLetterSubscription>.Is.Anything));
}
/// <summary>
/// Updates a newsletter subscription
/// </summary>
/// <param name="newsLetterSubscription">NewsLetter subscription</param>
/// <param name="publishSubscriptionEvents">if set to <c>true</c> [publish subscription events].</param>
public void UpdateNewsLetterSubscription(NewsLetterSubscription newsLetterSubscription, bool publishSubscriptionEvents = true)
{
if (newsLetterSubscription == null)
{
throw new ArgumentNullException("newsLetterSubscription");
}
//Handle e-mail
newsLetterSubscription.Email = CommonHelper.EnsureSubscriberEmailOrThrow(newsLetterSubscription.Email);
//Get original subscription record
NewsLetterSubscription originalSubscription = _context.LoadOriginalCopy(newsLetterSubscription);
//Persist
_subscriptionRepository.Update(newsLetterSubscription);
//Publish the subscription event
if ((originalSubscription.Active == false && newsLetterSubscription.Active) ||
(newsLetterSubscription.Active && (originalSubscription.Email != newsLetterSubscription.Email)))
{
//If the previous entry was false, but this one is true, publish a subscribe.
PublishSubscriptionEvent(newsLetterSubscription.Email, true, publishSubscriptionEvents);
}
if ((originalSubscription.Active && newsLetterSubscription.Active) &&
(originalSubscription.Email != newsLetterSubscription.Email))
{
//If the two emails are different publish an unsubscribe.
PublishSubscriptionEvent(originalSubscription.Email, false, publishSubscriptionEvents);
}
if ((originalSubscription.Active && !newsLetterSubscription.Active))
{
//If the previous entry was true, but this one is false
PublishSubscriptionEvent(originalSubscription.Email, false, publishSubscriptionEvents);
}
//Publish event
_eventPublisher.EntityUpdated(newsLetterSubscription);
}
/// <summary>
/// Inserts a newsletter subscription
/// </summary>
/// <param name="newsLetterSubscription">NewsLetter subscription</param>
/// <param name="publishSubscriptionEvents">if set to <c>true</c> [publish subscription events].</param>
public void InsertNewsLetterSubscription(NewsLetterSubscription newsLetterSubscription, bool publishSubscriptionEvents = true)
{
if (newsLetterSubscription == null)
{
throw new ArgumentNullException("newsLetterSubscription");
}
//Handle e-mail
newsLetterSubscription.Email = CommonHelper.EnsureSubscriberEmailOrThrow(newsLetterSubscription.Email);
//Persist
_subscriptionRepository.Insert(newsLetterSubscription);
//Publish the subscription event
if (newsLetterSubscription.Active)
{
PublishSubscriptionEvent(newsLetterSubscription.Email, true, publishSubscriptionEvents);
}
//Publish event
_eventPublisher.EntityInserted(newsLetterSubscription);
}