public ActionResult NewEntry([Bind(Include="CustomerName,CustomerEmail,ProductId")]TrialTrackerRecord vm)
{
if (ModelState.IsValid)
{
var product = _productService.GetProductById(vm.ProductId);
vm.ProductName = product.Name;
vm.DownloadDate = DateTime.Now.ToString("MM/dd/yyyy");
// check if they should be auto added to mailing list
if (_settings.GetSettingByKey<bool>("AutoAddTrialEmail"))
{
vm.OnMailingList = true;
NewsLetterSubscription subscriber = new NewsLetterSubscription
{
Active = true,
CreatedOnUtc = DateTime.Now,
Email = vm.CustomerEmail
};
_mailingService.InsertNewsLetterSubscription(subscriber);
}
else
{
vm.OnMailingList = false;
}
_trialRepo.Insert(vm);
return View("_DownloadLink", vm);
}
else
{
return View();
}
}
public void VerifyDeleteTriggersUnsubscribeEvent()
{
var service = new NewsLetterSubscriptionService(_dbContext, _newsLetterSubscriptionRepository,
_customerRepository, _eventPublisher, _customerService);
var subscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
service.DeleteNewsLetterSubscription(subscription, true);
_eventPublisher.AssertWasCalled(x => x.Publish(new EmailUnsubscribedEvent(subscription.Email)));
}
/// <summary>
/// Deletes a newsletter subscription
/// </summary>
/// <param name="newsLetterSubscription">NewsLetter subscription</param>
public virtual void DeleteNewsLetterSubscription(NewsLetterSubscription newsLetterSubscription)
{
if (newsLetterSubscription == null)
throw new ArgumentNullException("newsLetterSubscription");
_newsLetterSubscriptionRepository.Delete(newsLetterSubscription);
//event notification
_eventPublisher.EntityDeleted(newsLetterSubscription);
}
/// <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()
{
//Prepare the original result
var originalSubscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
_newsLetterSubscriptionRepository.Stub(m => m.GetById(Arg<object>.Is.Anything)).Return(originalSubscription);
var service = new NewsLetterSubscriptionService(_dbContext, _newsLetterSubscriptionRepository,
_customerRepository, _eventPublisher, _customerService);
var subscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
service.UpdateNewsLetterSubscription(subscription, true);
_eventPublisher.AssertWasCalled(x => x.Publish(new EmailUnsubscribedEvent(originalSubscription.Email)));
_eventPublisher.AssertWasCalled(x => x.Publish(new EmailSubscribedEvent(subscription.Email)));
}
public void VerifyInactiveToActiveUpdateTriggersSubscribeEvent()
{
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 subscription = new NewsLetterSubscription { Active = true, Email = "*****@*****.**" };
var service = new NewsLetterSubscriptionService(context, repo, eventPublisher);
service.UpdateNewsLetterSubscription(subscription, true);
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.GetNewsLetterSubscriptionByEmailAndStoreId(email, _storeContext.CurrentStore.Id);
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,
StoreId = _storeContext.CurrentStore.Id,
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>
/// 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 virtual 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 virtual 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);
}
private IList<Token> GenerateTokens(NewsLetterSubscription subscription)
{
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
return tokens;
}
/// <summary>
/// Sends a newsletter subscription deactivation message
/// </summary>
/// <param name="subscription">Newsletter subscription</param>
/// <param name="languageId">Language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewsLetterSubscriptionDeactivationMessage(NewsLetterSubscription subscription,
int languageId)
{
if (subscription == null)
throw new ArgumentNullException("subscription");
languageId = EnsureLanguageIsActive(languageId);
var messageTemplate = GetLocalizedActiveMessageTemplate("NewsLetterSubscription.DeactivationMessage", languageId);
if (messageTemplate == null)
return 0;
var orderTokens = GenerateTokens(subscription);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, orderTokens);
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
var toEmail = subscription.Email;
var toName = "";
return SendNotification(messageTemplate, emailAccount,
languageId, orderTokens,
toEmail, toName);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="subscription">Subscription</param>
public EmailUnsubscribedEvent(NewsLetterSubscription subscription)
{
_subscription = subscription;
}
public void VerifyUpdateEventIsFired()
{
//Prepare the original result
var originalSubscription = new NewsLetterSubscription { Active = false, Email = "*****@*****.**" };
_newsLetterSubscriptionRepository.Stub(m => m.GetById(Arg<object>.Is.Anything)).Return(originalSubscription);
var service = new NewsLetterSubscriptionService(_dbContext, _newsLetterSubscriptionRepository,
_customerRepository, _eventPublisher, _customerService);
service.UpdateNewsLetterSubscription(new NewsLetterSubscription { Email = "*****@*****.**" });
_eventPublisher.AssertWasCalled(x => x.EntityUpdated(Arg<NewsLetterSubscription>.Is.Anything));
}
/// <summary>
/// Import newsletter subscribers from TXT file
/// </summary>
/// <param name="stream">Stream</param>
/// <returns>Number of imported subscribers</returns>
public virtual int ImportNewsletterSubscribersFromTxt(Stream stream)
{
int count = 0;
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (String.IsNullOrWhiteSpace(line))
continue;
string[] tmp = line.Split(',');
var email = "";
bool isActive = true;
int storeId = _storeContext.CurrentStore.Id;
//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 if (tmp.Length == 3)
{
//"email" and "active" and "storeId" fields specified
email = tmp[0].Trim();
isActive = Boolean.Parse(tmp[1].Trim());
storeId = Int32.Parse(tmp[2].Trim());
}
else
throw new NopException("Wrong file format");
//import
var subscription = _newsLetterSubscriptionService.GetNewsLetterSubscriptionByEmailAndStoreId(email, storeId);
if (subscription != null)
{
subscription.Email = email;
subscription.Active = isActive;
_newsLetterSubscriptionService.UpdateNewsLetterSubscription(subscription);
}
else
{
subscription = new NewsLetterSubscription
{
Active = isActive,
CreatedOnUtc = DateTime.UtcNow,
Email = email,
StoreId = storeId,
NewsLetterSubscriptionGuid = Guid.NewGuid()
};
_newsLetterSubscriptionService.InsertNewsLetterSubscription(subscription);
}
count++;
}
}
return count;
}
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));
}
public static NewsLetterSubscription ToEntity(this NewsLetterSubscriptionModel model, NewsLetterSubscription destination)
{
return Mapper.Map(model, destination);
}
/// <summary>
/// Sends a newsletter subscription deactivation message
/// </summary>
/// <param name="subscription">Newsletter subscription</param>
/// <param name="languageId">Language identifier</param>
/// <returns>Queued email identifier</returns>
public virtual int SendNewsLetterSubscriptionDeactivationMessage(NewsLetterSubscription subscription,
int languageId)
{
if (subscription == null)
throw new ArgumentNullException("subscription");
var store = _storeContext.CurrentStore;
languageId = EnsureLanguageIsActive(languageId, store.Id);
var messageTemplate = GetActiveMessageTemplate("NewsLetterSubscription.DeactivationMessage", store.Id);
if (messageTemplate == null)
return 0;
//email account
var emailAccount = GetEmailAccountOfMessageTemplate(messageTemplate, languageId);
//tokens
var tokens = new List<Token>();
_messageTokenProvider.AddStoreTokens(tokens, store, emailAccount);
_messageTokenProvider.AddNewsLetterSubscriptionTokens(tokens, subscription);
//event notification
_eventPublisher.MessageTokensAdded(messageTemplate, tokens);
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, GetStoreUrl(), subscription.NewsLetterSubscriptionGuid, "true");
tokens.Add(new Token("NewsLetterSubscription.ActivationUrl", activationUrl, true));
var deActivationUrl = String.Format(urlFormat, GetStoreUrl(), 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 NopException("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 ActionResult UpdateTrial(TrialTrackerRecord trialUpdate)
{
var trial = _trialRepository.GetById(trialUpdate.TrialTrackerId);
trial.ProductName = trialUpdate.ProductName;
trial.CustomerName = trialUpdate.CustomerName;
trial.CustomerEmail = trialUpdate.CustomerEmail;
trial.DownloadDate = trialUpdate.DownloadDate;
trial.OnMailingList = trialUpdate.OnMailingList;
if (trial.OnMailingList)
{
NewsLetterSubscription subscriber = new NewsLetterSubscription
{
Active = true,
CreatedOnUtc = DateTime.Now,
Email = trial.CustomerEmail
};
_mailingService.InsertNewsLetterSubscription(subscriber);
}
else
{
NewsLetterSubscription deleteSubscriber = _mailingService.GetAllNewsLetterSubscriptions().Where(x => x.Email == trial.CustomerEmail).FirstOrDefault();
if (deleteSubscriber != null)
{
_mailingService.DeleteNewsLetterSubscription(deleteSubscriber);
}
}
_trialRepository.Update(trial);
return new NullJsonResult();
}
/// <summary>
/// Updates a newsletter subscription
/// </summary>
/// <param name="newsLetterSubscription">NewsLetter subscription</param>
public virtual void UpdateNewsLetterSubscription(NewsLetterSubscription newsLetterSubscription)
{
if (newsLetterSubscription == null)
throw new ArgumentNullException("newsLetterSubscription");
newsLetterSubscription.Email = CommonHelper.EnsureNotNull(newsLetterSubscription.Email);
newsLetterSubscription.Email = newsLetterSubscription.Email.Trim();
newsLetterSubscription.Email = CommonHelper.EnsureMaximumLength(newsLetterSubscription.Email, 255);
if (!CommonHelper.IsValidEmail(newsLetterSubscription.Email))
{
throw new NopException("Email is not valid.");
}
_newsLetterSubscriptionRepository.Update(newsLetterSubscription);
//event notification
_eventPublisher.EntityUpdated(newsLetterSubscription);
}
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));
}