protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
// We don't care about culuture of store at this time.
// We simply need some non-localizable store settings to initialize thread culture.
var currentStore = HccRequestContext.Current.CurrentStore;
if (ForceWizardRedirect && currentStore == null && CurrentTab != AdminTabType.SetupWizard)
{
Response.Redirect(WizardPagePath);
}
HccRequestContextUtils.UpdateAdminContentCulture(HccRequestContext.Current);
// Redirect to HTTPS if ssl required
if (currentStore != null)
{
if (currentStore.Settings.ForceAdminSSL && !Request.IsSecureConnection)
{
SSL.SSLRedirect(SSL.SSLRedirectTo.SSL);
}
CultureSwitch.SetCulture(currentStore);
}
ValidateBasicAccess();
Localization = Factory.Instance.CreateLocalizationHelper(LocalResourceFile);
}
private void SendAbandonedCartEmail(HccRequestContext context, Order order)
{
try
{
var membershipServices = Factory.CreateService <MembershipServices>(context);
var customer = membershipServices.Customers.Find(order.UserID);
if (customer != null && !string.IsNullOrEmpty(customer.Email))
{
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context, order.UsedCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.AbandonedCart);
template = template.ReplaceTagsInTemplate(hccRequestContext, order, order.ItemsAsReplaceable());
var mailMessage = template.ConvertToMailMessage(customer.Email);
MailServices.SendMail(mailMessage, hccRequestContext.CurrentStore);
order.IsAbandonedEmailSent = true;
var orderService = Factory.CreateService <OrderService>(hccRequestContext);
orderService.Orders.Update(order);
}
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
}
public override void DoWork()
{
try
{
Progressing();
var context = new HccRequestContext();
var accountServices = Factory.CreateService <AccountService>(context);
var stores = accountServices.Stores.FindAllPaged(1, int.MaxValue);
foreach (var store in stores)
{
context.CurrentStore = store;
HccRequestContextUtils.UpdateUserContentCulture(context);
ProcessRecurringOrders(context);
}
//Show success
ScheduleHistoryItem.Succeeded = true;
}
catch (Exception ex)
{
ScheduleHistoryItem.Succeeded = false;
Errored(ref ex);
Exceptions.LogException(ex);
}
}
public override bool Execute(OrderTaskContext context)
{
try
{
if (context.Order.ApplyVATRules && !context.Order.IsRecurring)
{
var toEmail = context.Order.UserEmail;
if (!string.IsNullOrEmpty(toEmail))
{
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext,
context.Order.UsedCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var t = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.VATInvoice);
t = t.ReplaceTagsInTemplate(hccRequestContext, context.Order, context.Order.ItemsAsReplaceable());
var m = t.ConvertToMailMessage(toEmail);
MailServices.SendMail(m, hccRequestContext.CurrentStore);
}
}
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
return(true);
}
private bool SendEmail(OrderTaskContext context, VendorManufacturer vendorOrManufacturer, Order order)
{
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
var defaultCulture = storeSettingsProvider.GetDefaultLocale();
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext, defaultCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var toEmail = vendorOrManufacturer.EmailAddress;
HtmlTemplate t = null;
var templateBvin = vendorOrManufacturer.DropShipEmailTemplateId;
if (templateBvin != string.Empty)
{
long templateId = 0;
long.TryParse(templateBvin, out templateId);
t = contentService.HtmlTemplates.Find(templateId);
}
if (t == null)
{
t = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.DropShippingNotice);
}
if (!string.IsNullOrEmpty(toEmail))
{
var replacers = new List <IReplaceable>();
replacers.Add(order);
replacers.Add(vendorOrManufacturer);
t = t.ReplaceTagsInTemplate(hccRequestContext, replacers, order.ItemsAsReplaceable());
var m = t.ConvertToMailMessage(toEmail);
return(MailServices.SendMail(m, hccRequestContext.CurrentStore));
}
return(false);
}
public override bool Execute(OrderTaskContext context)
{
var u = context.HccApp.MembershipServices.Customers.FindByEmail(context.Order.UserEmail).FirstOrDefault();
if (u != null)
{
if (u.Bvin != string.Empty)
{
context.UserId = u.Bvin;
return(true);
}
}
var n = new CustomerAccount();
n.Email = context.Order.UserEmail;
var length = WebAppSettings.PasswordMinimumLength;
if (length < 8)
{
length = 8;
}
var newPassword = PasswordGenerator.GeneratePassword(length);
n.Password = newPassword;
n.FirstName = context.Order.ShippingAddress.FirstName;
n.LastName = context.Order.ShippingAddress.LastName;
if (context.HccApp.MembershipServices.CreateCustomer(n, n.Password))
{
// Update Addresses for Customer
context.Order.BillingAddress.CopyTo(n.BillingAddress);
context.Order.ShippingAddress.CopyTo(n.ShippingAddress);
context.HccApp.MembershipServices.UpdateCustomer(n);
context.Order.CustomProperties.Add("hcc", "allowpasswordreset", "1");
// Email Password to Customer
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext,
context.Order.UsedCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var t = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.ForgotPassword);
if (t != null)
{
var replacers = new List <IReplaceable>();
replacers.Add(n);
replacers.Add(new Replaceable("[[NewPassword]]", newPassword));
t = t.ReplaceTagsInTemplate(hccRequestContext, replacers);
var m = t.ConvertToMailMessage(n.Email);
if (!MailServices.SendMail(m, hccRequestContext.CurrentStore))
{
EventLog.LogEvent("Create Account During Checkout",
"Failed to send email to new customer " + n.Email, EventLogSeverity.Warning);
}
}
}
context.UserId = n.Bvin;
return(true);
}
protected void EmailPasswordToCustomer(OrderTaskContext context, CustomerAccount n)
{
try
{
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext,
context.Order.UsedCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var t = context.HccApp.ContentServices.GetHtmlTemplateOrDefault(HtmlTemplateType.ForgotPassword);
if (t != null)
{
var replacers = new List <IReplaceable>();
replacers.Add(n);
replacers.Add(new Replaceable("[[NewPassword]]", n.Password));
t = t.ReplaceTagsInTemplate(hccRequestContext, replacers);
var m = t.ConvertToMailMessage(n.Email);
if (!MailServices.SendMail(m, hccRequestContext.CurrentStore))
{
EventLog.LogEvent("Create Account During Checkout",
"Failed to send email to new customer " + n.Email, EventLogSeverity.Warning);
}
}
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
}
protected override void OnPreInit(EventArgs e)
{
base.OnPreInit(e);
HccRequestContextUtils.UpdateAdminContentCulture(HccRequestContext.Current);
CultureSwitch.SetCulture(HccRequestContext.Current.CurrentStore);
ValidatBasicAccess();
}
public override void InitHelpers()
{
base.InitHelpers();
var viewNamePos = VirtualPath.LastIndexOf('/');
var localResourceFile = VirtualPath.Insert(viewNamePos, "/App_LocalResources") + ".resx";
Localization = Factory.Instance.CreateLocalizationHelper(localResourceFile);
HccRequestContextUtils.UpdateUserContentCulture(HccRequestContext.Current);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
JavaScript.RegisterClientReference(Page, ClientAPI.ClientNamespaceReferences.dnn);
HccRequestContextUtils.UpdateUserContentCulture(HccRequestContext.Current);
_ltMiniProfiler = new LiteralControl();
Page.Form.Controls.Add(_ltMiniProfiler);
}
public override bool Execute(OrderTaskContext context)
{
string toEmail = null;
HtmlTemplate template = null;
var culture = "en-US";
switch (_emailTo)
{
case "Admin":
toEmail = context.HccApp.CurrentStore.Settings.MailServer.EmailForNewOrder;
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
culture = storeSettingsProvider.GetDefaultLocale();
break;
case "Customer":
toEmail = context.Order.UserEmail;
culture = context.Order.UsedCulture;
break;
}
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext, culture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
switch (_emailTo)
{
case "Admin":
template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.NewOrderForAdmin);
break;
case "Customer":
template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.NewOrder);
break;
}
try
{
if (!string.IsNullOrEmpty(toEmail))
{
template = template.ReplaceTagsInTemplateForOrder(hccRequestContext, context.Order);
var m = template.ConvertToMailMessage(toEmail);
MailServices.SendMail(m, hccRequestContext.CurrentStore);
}
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
return(true);
}
public void ProcessRequest(HttpContext context)
{
Localization = Factory.Instance.CreateLocalizationHelper(LocalResourceFile);
HccRequestContextUtils.UpdateAdminContentCulture(HccRequestContext.Current);
CultureSwitch.SetCulture(HccRequestContext.Current.CurrentStore);
var res = HandleAction(context, HotcakesApplication.Current);
context.Response.ContentType = "application/json";
context.Response.Write(res.ObjectToJson());
}
public void SendAffiliateReviewEmail(Affiliate aff)
{
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
var defaultCulture = storeSettingsProvider.GetDefaultLocale();
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(Context, defaultCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.AffiliateReview);
template = template.ReplaceTagsInTemplate(hccRequestContext, aff);
var storeAdmin = hccRequestContext.CurrentStore.Settings.MailServer.EmailForNewOrder;
var message = template.ConvertToMailMessage(storeAdmin);
MailServices.SendMail(message, hccRequestContext.CurrentStore);
}
public void SendGiftCardNotification(GiftCard giftCard, Order order, LineItem item)
{
var usedCulture = order != null ? order.UsedCulture : "en-US";
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(Context, usedCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var template = GetHtmlTemplateOrDefault(HtmlTemplateType.GiftCardNotification);
template = template.ReplaceTagsInTemplate(hccRequestContext, new List <IReplaceable> {
item, giftCard
});
var message = template.ConvertToMailMessage(giftCard.RecipientEmail);
MailServices.SendMail(message, hccRequestContext.CurrentStore);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
HccRequestContextUtils.UpdateUserContentCulture(HccRequestContext.Current);
var settings = Configuration.Formatters.JsonFormatter.SerializerSettings;
if (settings.NullValueHandling != NullValueHandling.Ignore)
{
settings.NullValueHandling = NullValueHandling.Ignore;
}
settings.ContractResolver = Resolver;
}
protected void btnSendStatusEmail_Click(object sender, EventArgs e)
{
long templateId = 0;
long.TryParse(lstEmailTemplate.SelectedValue, out templateId);
var t = HccApp.ContentServices.HtmlTemplates.Find(templateId);
if (t == null)
{
return;
}
var toEmail = CurrentOrder.UserEmail;
var culture = CurrentOrder.UsedCulture;
if (t.TemplateType == HtmlTemplateType.NewOrderForAdmin ||
t.TemplateType == HtmlTemplateType.DropShippingNotice ||
t.TemplateType == HtmlTemplateType.ContactFormToAdmin)
{
toEmail = HccApp.CurrentStore.Settings.MailServer.EmailForNewOrder;
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
culture = storeSettingsProvider.GetDefaultLocale();
}
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(HccRequestContext.Current, culture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
if (!string.IsNullOrWhiteSpace(toEmail))
{
// this time get template in correct culture
t = contentService.HtmlTemplates.Find(templateId);
t = t.ReplaceTagsInTemplateForOrder(hccRequestContext, CurrentOrder);
var m = t.ConvertToMailMessage(toEmail);
if (MailServices.SendMail(m, hccRequestContext.CurrentStore))
{
ucMessageBox.ShowOk("E-Mail Sent!");
}
else
{
ucMessageBox.ShowError("Message Send Failed.");
}
}
LoadOrder();
}
public override bool Execute(OrderTaskContext context)
{
var EmailSelection = string.Empty;
EmailSelection = _ToEmail;
var toEmail = string.Empty;
switch (EmailSelection)
{
case "Admin":
toEmail = context.HccApp.CurrentRequestContext.CurrentStore.Settings.MailServer.EmailForNewOrder;
break;
case "Customer":
toEmail = context.Order.UserEmail;
break;
default:
toEmail = context.Order.UserEmail;
EmailSelection = "Customer";
break;
}
try
{
if (toEmail.Trim().Length > 0)
{
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
var defaultCulture = context.Order.UsedCulture;
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(context.RequestContext,
defaultCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var t = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.OrderShipment);
t = t.ReplaceTagsInTemplateForOrder(hccRequestContext, context.Order);
var m = t.ConvertToMailMessage(toEmail);
MailServices.SendMail(m, hccRequestContext.CurrentStore);
}
}
catch (Exception ex)
{
EventLog.LogEvent(ex);
}
return(true);
}
public void SendAffiliateApprovementEmail(Affiliate aff, string culture = "")
{
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
if (string.IsNullOrEmpty(culture))
{
culture = storeSettingsProvider.GetDefaultLocale();
}
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(Context, culture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.AffiliateApprovement);
template = template.ReplaceTagsInTemplate(hccRequestContext, aff);
var message = template.ConvertToMailMessage(aff.Email);
MailServices.SendMail(message, hccRequestContext.CurrentStore);
}
public void SendNewRolesAssignment(CustomerAccount acc, string[] roles)
{
var roleTags = new Replaceable("[[User.NewRoles]]", string.Join(", ", roles));
var storeSettingsProvider = Factory.CreateStoreSettingsProvider();
var defaultCulture = storeSettingsProvider.GetDefaultLocale();
var hccRequestContext = HccRequestContextUtils.GetContextWithCulture(Context, defaultCulture);
var contentService = Factory.CreateService <ContentService>(hccRequestContext);
var template = contentService.GetHtmlTemplateOrDefault(HtmlTemplateType.NewRoleAssignment);
template = template.ReplaceTagsInTemplate(hccRequestContext, new List <IReplaceable> {
acc, roleTags
});
var message = template.ConvertToMailMessage(acc.Email);
MailServices.SendMail(message, hccRequestContext.CurrentStore);
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
var locales = Factory.Instance.CreateStoreSettingsProvider().GetLocales();
ddlLangs.DataTextField = "NativeName";
ddlLangs.DataValueField = "Code";
ddlLangs.DataSource = locales;
ddlLangs.DataBind();
var locale = HccRequestContextUtils.GetAdminContentCulture();
var listItem = ddlLangs.Items.FindByValue(locale.Code);
if (listItem != null)
{
listItem.Selected = true;
}
}
public override List <SitemapUrl> GetUrls(int portalId, PortalSettings ps, string version)
{
var productsRepo = Factory.CreateRepo <ProductRepository>();
var products = productsRepo.FindAllPagedWithCache(1, int.MaxValue);
var urls = new List <SitemapUrl>();
SitemapUrl pageUrl = null;
if (HccRequestContext.Current != null) // Localize HccRequestContext
{
HccRequestContext.Current = HccRequestContextUtils.GetContextWithCulture(HccRequestContext.Current, ps.CultureCode);
}
foreach (var product in products)
{
pageUrl = GetPageUrl(product);
urls.Add(pageUrl);
}
return(urls);
}
protected override void OnInit(EventArgs e)
{
base.OnInit(e);
HccRequestContextUtils.UpdateUserContentCulture(HccRequestContext.Current);
}
public static HccLocale GetAdminContentCulture()
{
return(HccRequestContextUtils.GetAdminContentCulture());
}
protected override void Initialize(RequestContext requestContext)
{
base.Initialize(requestContext);
HccRequestContextUtils.UpdateUserContentCulture(HccRequestContext.Current);
}
