public ActionResult SendMail(NewsletterSubscription model)
{
UmbracoHelper h = ContentHelper.GetHelper();
string email = model.EmailAddress;
string apiKey =
h.TypedContent(model.PageId)
.AncestorOrSelf(1)
.Descendant <ConfigGlobalSettings>()
.MailChimpApikey;
string listId = h.TypedContent(model.PageId)
.AncestorOrSelf(1)
.Descendant <ConfigGlobalSettings>()
.MailChimpListID;
if (!ModelState.IsValid)
{
return(Json(new { Success = false }));
}
IMailChimpManager manager = new MailChimpManager(apiKey);
//var listId = listI" 0d3a461bf3";
var member = new MailChimp.Net.Models.Member {
EmailAddress = email, Status = Status.Subscribed
};
manager.Members.AddOrUpdateAsync(listId, member);
return(Json(new { Success = true }));
}
public IActionResult CreateUser(CreateUserVM createUser)
{
var user = new User
{
Id = PizzaDatabase.Users.Count + 1,
FirstName = createUser.FirstName,
LastName = createUser.LastName,
Phone = createUser.Phone
};
var address = new Address
{
Id = PizzaDatabase.Addresses.Count + 1,
Name = createUser.Address,
UserId = user.Id
};
var sub = new NewsletterSubscription
{
Id = PizzaDatabase.NewsletterSubscription.Count + 1,
IsSubscribed = createUser.IsSubscribed,
UserId = user.Id
};
user.AddressId = address.Id;
user.NewsletterId = sub.Id;
PizzaDatabase.Users.Add(user);
PizzaDatabase.Addresses.Add(address);
PizzaDatabase.NewsletterSubscription.Add(sub);
TempData["ProfileInfo"] = "Successfuly created profile";
return(RedirectToAction("GetProfile", new { id = user.Id }));
}
/// <summary>
/// Fetches an existing newsletter subscription for the given person and Arena
/// newsletter ID or creates a new one if it did not already exist.
/// </summary>
/// <param name="person">person for who the subscription is for</param>
/// <param name="newsletterID">Arena newsletter ID of the newsletter subscription</param>
/// <returns>An Arena NewsletterSubscription for the given args</returns>
private NewsletterSubscription FetchOrCreateNewsletterSubscription(Person person, int newsletterID)
{
NewsletterSubscription subscription;
NewsletterSubscriptionCollection subscriptionsArena = new NewsletterSubscriptionCollection();
subscriptionsArena.LoadNewsletterSubscriptionsByEmail(person.Emails.FirstActive);
var query =
(from existingSubscription in subscriptionsArena.OfType <NewsletterSubscription>()
where existingSubscription.NewsletterId == newsletterID
select existingSubscription).ToList();
if (query.Count > 0)
{
subscription = new NewsletterSubscription(query.First().SubscriptionId);
}
else
{
subscription = new NewsletterSubscription();
subscription.PersonId = person.PersonID;
subscription.NewsletterId = newsletterID;
subscription.Email = person.Emails.FirstActive;
subscription.FirstName = person.FirstName;
subscription.LastName = person.LastName;
subscription.Gender = person.Gender;
}
return(subscription);
}
/// <summary>
/// Initializes a new instance of the <see cref="NewsletterSubscriptionDTO"/> class.
/// </summary>
/// <param name="subscription">
/// The subscription.
/// </param>
public NewsletterSubscriptionDTO(NewsletterSubscription subscription)
{
this.newsletterSubscriptionId = subscription.Id;
this.email = subscription.Email;
this.isActive = subscription.IsActive;
this.dateSubscribed = subscription.DateSubscribed.With(x => x.ConvertToUnixTimestamp());
this.dateUnsubscribed = (subscription.DateUnsubscribed ?? DateTime.Today.AddYears(1)).With(x => x.ConvertToUnixTimestamp());
}
/// <summary>
/// Method used to unsubscribe a person from the MailChimp List (and Arena newsletter).
/// </summary>
/// <param name="person">person to subscribe</param>
/// <param name="listID">MailChimp list ID</param>
/// <param name="newsletterID">Arena's newsletter ID</param>
private void Unsubscribe(Person person, string listID, int newsletterID)
{
api.listUnsubscribe(listID, person.Emails.FirstActive);
NewsletterSubscription subscription = FetchOrCreateNewsletterSubscription(person, newsletterID);
subscription.Status = false;
subscription.Save(CurrentUser.Identity.Name);
}
/// <summary>
/// The validate email already exists.
/// </summary>
/// <param name="id">
/// The id.
/// </param>
/// <param name="email">
/// The email.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
public bool ValidateEmailAlreadyExists(int id, string email)
{
NewsletterSubscription newsletterSubscription = this.newsletterSubscriptionModel.GetOneByEmail(email).With(x => x.Value);
if (newsletterSubscription == null || newsletterSubscription.Id == id)
{
return(true);
}
return(false);
}
public NewsletterSubscription Add(NewsletterSubscriptionViewModel model)
{
NewsletterSubscription subscription = db.NewsletterSubscriptions.FirstOrDefault(a => a.Email == model.Email);
if (subscription == null)
{
subscription = Mapper.Map <NewsletterSubscription>(model);
subscription.DateSubscribed = DateTime.Now;
db.NewsletterSubscriptions.Add(subscription);
}
db.SaveChanges();
return(subscription);
}
public void Init()
{
_contact = new Contact()
{
Email = "*****@*****.**",
FirstName = "Test",
LastName = "Testerich"
};
_newsletterSubscription = new NewsletterSubscription()
{
ChannelName = "Test"
};
}
public bool SaveNewsletterSubscription(NewsletterSubscription newsletterSubscription)
{
var context = DataContextHelper.GetNewContext();
//check for an existing subscription.
var existingSubscription = context.NewsletterSubscriptions.FirstOrDefault(x => x.EmailAddress == newsletterSubscription.EmailAddress);
if (existingSubscription == null)
{
context.NewsletterSubscriptions.Add(newsletterSubscription);
}
return(context.SaveChanges() > 0);
}
private static dynamic ToDynamic(NewsletterSubscription subscription, DataExporterContext ctx)
{
if (subscription == null)
{
return(null);
}
dynamic result = new DynamicEntity(subscription);
result.Store = ctx.Stores.ContainsKey(subscription.StoreId)
? ToDynamic(ctx.Stores[subscription.StoreId], ctx)
: null;
return(result);
}
public void SubscribeToNewsletter(string email)
{
var subscription = DataContext.Current.NewsletterSubscriptions.FirstOrDefault(
x => x.Email.Equals(email, StringComparison.CurrentCultureIgnoreCase));
if (subscription == null)
{
subscription = new NewsletterSubscription {
Email = email
};
DataContext.Current.NewsletterSubscriptions.Add(subscription);
}
subscription.SubscribedToNewMeetingUpdates = true;
DataContext.Current.NewsletterSubscriptions.Update(subscription);
}
public async void ValidSubscribe()
{
var model = new NewsletterSubscription {
Email = "*****@*****.**"
};
var newsletterRepository = new Mock <INewsletterSubscriptionRepository>();
newsletterRepository.Setup(repo => repo.Subscribe(model))
.Returns(Task.FromResult(1));
var controller = new NewsletterSubscriptionController(newsletterRepository.Object);
var result = await controller.Subscribe(model);
Assert.IsType <OkResult>(result);
}
/// <summary>
/// Method used to subscribe a person to the MailChimp List (and Arena newsletter).
/// </summary>
/// <param name="person">person to subscribe</param>
/// <param name="listID">MailChimp list ID</param>
/// <param name="newsletterID">Arena's newsletter ID</param>
private void Subscribe(Person person, string listID, int newsletterID, ListItemCollection listItemCollection)
{
MCMergeVar[] merges = new MCMergeVar[5];
BuildMergeVars(person, merges, listItemCollection);
if (api.listSubscribe(listID, person.Emails.FirstActive, merges))
{
// Track the subscription locally too
NewsletterSubscription subscription = FetchOrCreateNewsletterSubscription(person, newsletterID);
subscription.Status = true;
subscription.Save(CurrentUser.Identity.Name);
}
else
{
AddMsg("An error prevented the person from being subscribed to the list.");
}
}
private async Task <IEnumerable <dynamic> > Convert(NewsletterSubscription subscription, DataExporterContext ctx)
{
var result = new List <dynamic>();
dynamic dynObject = ToDynamic(subscription, ctx);
result.Add(dynObject);
await _services.EventPublisher.PublishAsync(new RowExportingEvent
{
Row = dynObject,
EntityType = ExportEntityType.NewsLetterSubscription,
ExportRequest = ctx.Request,
ExecuteContext = ctx.ExecuteContext
});
return(result);
}
public async Task <IActionResult> Subscribe(NewsletterSubscription newsletterSubscription)
{
if (!ModelState.IsValid || string.IsNullOrWhiteSpace(newsletterSubscription.Email))
{
return(BadRequest());
}
try
{
await _newsletterSubscriptionRepository.Subscribe(newsletterSubscription);
return(Ok());
}
catch (DbUpdateException)
{
// Hide the fact the user is already subscribed.
return(Ok());
}
}
public async Task <IActionResult> Subscribe(bool subscribe, string email)
{
string result;
var success = false;
var customer = _workContext.CurrentCustomer;
var hasConsentedToGdpr = customer.GenericAttributes.HasConsentedToGdpr;
var hasConsented = ViewData["GdprConsent"] != null ? (bool)ViewData["GdprConsent"] : hasConsentedToGdpr;
if (!hasConsented && _privacySettings.DisplayGdprConsentOnForms)
{
return(Json(new
{
Success = success,
Result = string.Empty
}));
}
if (!email.IsEmail())
{
result = T("Newsletter.Email.Wrong");
}
else
{
// subscribe/unsubscribe
email = email.Trim();
var subscription = await _db.NewsletterSubscriptions
.AsNoTracking()
.ApplyMailAddressFilter(email, _storeContext.CurrentStore.Id)
.FirstOrDefaultAsync();
if (subscription != null)
{
if (subscribe)
{
if (!subscription.Active)
{
await _messageFactory.SendNewsletterSubscriptionActivationMessageAsync(subscription, _workContext.WorkingLanguage.Id);
}
result = T("Newsletter.SubscribeEmailSent");
}
else
{
if (subscription.Active)
{
await _messageFactory.SendNewsletterSubscriptionDeactivationMessageAsync(subscription, _workContext.WorkingLanguage.Id);
}
result = T("Newsletter.UnsubscribeEmailSent");
}
}
else if (subscribe)
{
subscription = new NewsletterSubscription
{
NewsletterSubscriptionGuid = Guid.NewGuid(),
Email = email,
Active = false,
CreatedOnUtc = DateTime.UtcNow,
StoreId = _storeContext.CurrentStore.Id,
WorkingLanguageId = _workContext.WorkingLanguage.Id
};
_db.NewsletterSubscriptions.Add(subscription);
await _db.SaveChangesAsync();
await _messageFactory.SendNewsletterSubscriptionActivationMessageAsync(subscription, _workContext.WorkingLanguage.Id);
result = T("Newsletter.SubscribeEmailSent");
}
else
{
result = T("Newsletter.UnsubscribeEmailSent");
}
success = true;
}
return(Json(new
{
Success = success,
Result = result
}));
}
private async Task MapRegisterModelToCustomerAsync(Customer customer, RegisterModel model)
{
// Properties
if (_dateTimeSettings.AllowCustomersToSetTimeZone)
{
customer.TimeZoneId = model.TimeZoneId;
}
// VAT number
if (_taxSettings.EuVatEnabled)
{
customer.GenericAttributes.VatNumber = model.VatNumber;
var vatCheckResult = await _taxService.GetVatNumberStatusAsync(model.VatNumber);
customer.VatNumberStatusId = (int)vatCheckResult.Status;
// Send VAT number admin notification.
if (model.VatNumber.HasValue() && _taxSettings.EuVatEmailAdminWhenNewVatSubmitted)
{
await _messageFactory.SendNewVatSubmittedStoreOwnerNotificationAsync(customer, model.VatNumber, vatCheckResult.Address, _localizationSettings.DefaultAdminLanguageId);
}
}
// Form fields
customer.FirstName = model.FirstName;
customer.LastName = model.LastName;
if (_customerSettings.CompanyEnabled)
{
customer.Company = model.Company;
}
if (_customerSettings.DateOfBirthEnabled)
{
try
{
customer.BirthDate = new DateTime(model.DateOfBirthYear.Value, model.DateOfBirthMonth.Value, model.DateOfBirthDay.Value);
}
catch
{
}
}
if (_customerSettings.CustomerNumberMethod == CustomerNumberMethod.AutomaticallySet && customer.CustomerNumber.IsEmpty())
{
customer.CustomerNumber = customer.Id.Convert <string>();
}
if (_customerSettings.GenderEnabled)
{
customer.Gender = model.Gender;
}
if (_customerSettings.ZipPostalCodeEnabled)
{
customer.GenericAttributes.ZipPostalCode = model.ZipPostalCode;
}
if (_customerSettings.CountryEnabled)
{
customer.GenericAttributes.CountryId = model.CountryId;
}
if (_customerSettings.StreetAddressEnabled)
{
customer.GenericAttributes.StreetAddress = model.StreetAddress;
}
if (_customerSettings.StreetAddress2Enabled)
{
customer.GenericAttributes.StreetAddress2 = model.StreetAddress2;
}
if (_customerSettings.CityEnabled)
{
customer.GenericAttributes.City = model.City;
}
if (_customerSettings.CountryEnabled && _customerSettings.StateProvinceEnabled)
{
customer.GenericAttributes.StateProvinceId = model.StateProvinceId;
}
if (_customerSettings.PhoneEnabled)
{
customer.GenericAttributes.Phone = model.Phone;
}
if (_customerSettings.FaxEnabled)
{
customer.GenericAttributes.Fax = model.Fax;
}
// Newsletter subscription
if (_customerSettings.NewsletterEnabled && model.Newsletter)
{
var subscription = await _db.NewsletterSubscriptions
.ApplyMailAddressFilter(customer.Email, Services.StoreContext.CurrentStore.Id)
.FirstOrDefaultAsync();
if (subscription != null)
{
subscription.Active = true;
}
else
{
subscription = new NewsletterSubscription
{
NewsletterSubscriptionGuid = Guid.NewGuid(),
Email = customer.Email,
Active = true,
CreatedOnUtc = DateTime.UtcNow,
StoreId = Services.StoreContext.CurrentStore.Id,
WorkingLanguageId = Services.WorkContext.WorkingLanguage.Id
};
_db.NewsletterSubscriptions.Add(subscription);
}
await _db.SaveChangesAsync();
}
// Insert default address (if possible).
var defaultAddress = new Address
{
Title = customer.Title,
FirstName = customer.FirstName,
LastName = customer.LastName,
Email = customer.Email,
Company = customer.Company,
CountryId = customer.GenericAttributes.CountryId,
ZipPostalCode = customer.GenericAttributes.ZipPostalCode,
StateProvinceId = customer.GenericAttributes.StateProvinceId,
City = customer.GenericAttributes.City,
Address1 = customer.GenericAttributes.StreetAddress,
Address2 = customer.GenericAttributes.StreetAddress2,
PhoneNumber = customer.GenericAttributes.Phone,
FaxNumber = customer.GenericAttributes.Fax,
CreatedOnUtc = customer.CreatedOnUtc
};
if (await _addressService.IsAddressValidAsync(defaultAddress))
{
// Set default addresses.
customer.Addresses.Add(defaultAddress);
customer.BillingAddress = defaultAddress;
customer.ShippingAddress = defaultAddress;
}
_db.TryUpdate(customer);
await _db.SaveChangesAsync();
}
public void NewsletterSubscription_NotThrowException_WhenEmailValid(string email)
{
var subscription = new NewsletterSubscription(email);
}
public async Task ExecuteAsync(ImportExecuteContext context, CancellationToken cancelToken)
{
var currentStoreId = _services.StoreContext.CurrentStore.Id;
var segmenter = context.DataSegmenter;
var batch = segmenter.GetCurrentBatch <NewsletterSubscription>();
using (var scope = new DbContextScope(_services.DbContext, autoDetectChanges: false, minHookImportance: HookImportance.Important, deferCommit: true))
{
await context.SetProgressAsync(segmenter.CurrentSegmentFirstRowIndex - 1, segmenter.TotalRows);
foreach (var row in batch)
{
try
{
NewsletterSubscription subscription = null;
var email = row.GetDataValue <string>("Email");
var storeId = row.GetDataValue <int>("StoreId");
if (storeId == 0)
{
storeId = currentStoreId;
}
if (row.HasDataValue("Active") && row.TryGetDataValue("Active", out bool active))
{
}
else
{
active = true; // Default.
}
if (email.IsEmpty())
{
context.Result.AddWarning("Skipped empty email address.", row.RowInfo, "Email");
continue;
}
if (email.Length > 255)
{
context.Result.AddWarning($"Skipped email address '{email}'. It exceeds the maximum allowed length of 255.", row.RowInfo, "Email");
continue;
}
if (!email.IsEmail())
{
context.Result.AddWarning($"Skipped invalid email address '{email}'.", row.RowInfo, "Email");
continue;
}
foreach (var keyName in context.KeyFieldNames)
{
switch (keyName)
{
case "Email":
subscription = await _services.DbContext.NewsletterSubscriptions
.OrderBy(x => x.Id)
.FirstOrDefaultAsync(x => x.Email == email && x.StoreId == storeId, cancelToken);
break;
}
if (subscription != null)
{
break;
}
}
if (subscription == null)
{
if (context.UpdateOnly)
{
++context.Result.SkippedRecords;
continue;
}
subscription = new NewsletterSubscription
{
Active = active,
CreatedOnUtc = context.UtcNow,
Email = email,
NewsletterSubscriptionGuid = Guid.NewGuid(),
StoreId = storeId
};
_services.DbContext.NewsletterSubscriptions.Add(subscription);
context.Result.NewRecords++;
}
else
{
subscription.Active = active;
context.Result.ModifiedRecords++;
}
}
catch (Exception ex)
{
context.Result.AddError(ex.ToAllMessages(), row.RowInfo);
}
}
await scope.CommitAsync(cancelToken);
}
await _services.EventPublisher.PublishAsync(new ImportBatchExecutedEvent <NewsletterSubscription>(context, batch), cancelToken);
}
public Task Subscribe(NewsletterSubscription newsletterSubscription)
{
_context.Add(newsletterSubscription);
return(_context.SaveChangesAsync());
}
/// <summary>
/// Fetches an existing newsletter subscription for the given person and Arena
/// newsletter ID or creates a new one if it did not already exist.
/// </summary>
/// <param name="person">person for who the subscription is for</param>
/// <param name="newsletterID">Arena newsletter ID of the newsletter subscription</param>
/// <returns>An Arena NewsletterSubscription for the given args</returns>
private NewsletterSubscription FetchOrCreateNewsletterSubscription( Person person, int newsletterID )
{
NewsletterSubscription subscription;
NewsletterSubscriptionCollection subscriptionsArena = new NewsletterSubscriptionCollection();
subscriptionsArena.LoadNewsletterSubscriptionsByEmail( person.Emails.FirstActive );
var query =
( from existingSubscription in subscriptionsArena.OfType<NewsletterSubscription>()
where existingSubscription.NewsletterId == newsletterID
select existingSubscription ).ToList();
if ( query.Count > 0 )
{
subscription = new NewsletterSubscription( query.First().SubscriptionId );
}
else
{
subscription = new NewsletterSubscription();
subscription.PersonId = person.PersonID;
subscription.NewsletterId = newsletterID;
subscription.Email = person.Emails.FirstActive;
subscription.FirstName = person.FirstName;
subscription.LastName = person.LastName;
subscription.Gender = person.Gender;
}
return subscription;
}
