private void SendEmail()
{
EmailMessage msg = new CMS.EmailEngine.EmailMessage();
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Membership.ChangedPassword", CMSContext.CurrentSiteID);
string pswd = passStrength.Text.Trim();
ui = UserInfoProvider.GetUserInfo(CurrentUser.UserName);
if (ui != null)
{
if (eti != null)
{
MacroResolver mcr = new MacroResolver();
// Macros
string[,] macros = new string[5, 2];
macros[0, 0] = "UserName";
macros[0, 1] = ui.UserName;
macros[1, 0] = "Password";
macros[1, 1] = pswd;
ContextResolver resolver = MacroContext.CurrentResolver;
resolver.SourceParameters = macros;
resolver.EncodeResolvedValues = true;
msg.EmailFormat = EmailFormatEnum.Both;
msg.From = "*****@*****.**";
msg.Recipients = CurrentUser.Email;
msg.Subject = "Changement de mot de passe - Servranx";
EmailSender.SendEmailWithTemplateText(SiteContext.CurrentSiteName, msg, eti, resolver, true);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
editElem.SiteId = SiteID;
editElem.SelectedSiteId = SelectedSiteID;
if (isDialog)
{
string templateName = QueryHelper.GetString("name", String.Empty);
EmailTemplateInfo emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, SiteID);
if (emailTemplate != null)
{
EditedObject = emailTemplate;
}
RegisterEscScript();
RegisterModalPageScripts();
var master = CurrentMaster as ICMSModalMasterPage;
if (master != null)
{
// Register the Save and close button as the form submit button
HeaderActions.Visible = false;
editElem.EditForm.SubmitButton.Visible = false;
master.Save += (s, ea) => editElem.EditForm.SaveData(null);
master.ShowSaveAndCloseButton();
master.SetSaveResourceString("general.create");
}
}
}
public override async Task <AddLibraryRequest> HandleAsync(AddLibraryRequest command, CancellationToken cancellationToken = new CancellationToken())
{
command.Result = await _libraryRepository.AddLibrary(command.Library, cancellationToken);
var account = await _accountRepository.GetAccountByEmail(command.Library.OwnerEmail, cancellationToken);
if (account != null)
{
await _libraryRepository.AddAccountToLibrary(command.Result.Id, account.Id, Role.LibraryAdmin, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
var invitationCode = Guid.NewGuid().ToString("N");
await _accountRepository.AddInvitedAccount(
command.Library.Name,
command.Library.OwnerEmail,
Role.LibraryAdmin,
invitationCode,
DateTime.Today.AddDays(7),
command.Result.Id,
cancellationToken);
await _emailService.SendAsync(command.Library.OwnerEmail,
$"Welcome to {command.Result.Name}",
EmailTemplateProvider.GetLibraryAdminInvitationEmail(command.Result.Name, new Uri(new Uri(_settings.FrontEndUrl), _settings.RegisterPagePath + invitationCode).ToString()),
_settings.EmailFrom,
cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
/// <summary>
/// Sends notification email to the administrator.
/// </summary>
private void SendAdminNotification(UserInfo ui)
{
if (NotifyAdministrator && (FromAddress != String.Empty) && (ToAddress != String.Empty))
{
var resolver = MembershipResolvers.GetRegistrationResolver(ui);
var emailTemplate = EmailTemplateProvider.GetEmailTemplate(AdminApprovalRequired ? "Registration.Approve" : "Registration.New", CurrentSiteName);
if (emailTemplate == null)
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.From = FromAddress;
message.Recipients = ToAddress;
message.Subject = GetString("RegistrationForm.EmailSubject");
try
{
EmailSender.SendEmailWithTemplateText(CurrentSiteName, message, emailTemplate, resolver, false);
}
catch
{
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationEmail");
}
}
}
}
protected override void OnPreInit(EventArgs e)
{
isDialog = QueryHelper.GetBoolean("editonlycode", false);
if (isDialog)
{
// Check hash
var settings = new HashSettings("")
{
Redirect = false
};
if (!QueryHelper.ValidateHash("hash", "saved;name;templateid;selectorid;tabmode;siteid;selectedsiteid", settings, true))
{
URLHelper.Redirect(AdministrationUrlHelper.GetErrorPageUrl("dialogs.badhashtitle", "dialogs.badhashtext"));
}
string templateName = QueryHelper.GetString("name", String.Empty);
EmailTemplateInfo templateInfo = EmailTemplateProvider.GetEmailTemplate(templateName, SiteID);
if (templateInfo != null)
{
EditedObject = templateInfo;
}
MasterPageFile = "~/CMSMasterPages/UI/Dialogs/ModalDialogPage.master";
}
base.OnPreInit(e);
}
/// <summary>
/// Sending the emails to users for campaign open/close
/// </summary>
/// <param name="campaignName"></param>
/// <param name="reciepientEmail"></param>
/// <param name="templateName"></param>
public static void CampaignEmail(string campaignName, string recipientEmail, string templateName, string programName = "")
{
try
{
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
var email = EmailTemplateProvider.GetEmailTemplate(templateName, SiteContext.CurrentSite.SiteName);
EmailMessage msg = new EmailMessage();
if (email != null)
{
MacroResolver resolver = MacroResolver.GetInstance();
resolver.SetNamedSourceData("CampaignName", campaignName);
resolver.SetNamedSourceData("programName", programName);
msg.From = resolver.ResolveMacros(email.TemplateFrom);
msg.Recipients = recipientEmail;
msg.EmailFormat = EmailFormatEnum.Default;
msg.ReplyTo = resolver.ResolveMacros(email.TemplateReplyTo);
msg.Subject = resolver.ResolveMacros(email.TemplateSubject);
msg.Body = resolver.ResolveMacros(email.TemplateText);
EmailSender.SendEmail(SiteContext.CurrentSite.SiteName, msg, true);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("ProductEmailNotifications", "CampaignEmail", ex, SiteContext.CurrentSite.SiteID, ex.Message);
}
}
public override async Task <ResendInvitationCodeCommand> HandleAsync(ResendInvitationCodeCommand command, CancellationToken cancellationToken = default)
{
var account = await _accountRepository.GetAccountByEmail(command.Email, cancellationToken);
if (account != null && !string.IsNullOrWhiteSpace(account.InvitationCode))
{
var library = await _libraryRepository.GetLibrariesByAccountId(account.Id, cancellationToken);
// TODO : Read app name from settings
var libraryName = library.FirstOrDefault()?.Name ?? "Nawishta";
var invitationCode = Guid.NewGuid();
await _accountRepository.UpdateInvitationCode(
command.Email,
invitationCode.ToString("N"),
DateTime.Today.AddDays(+7),
cancellationToken);
await _emailService.SendAsync(account.Email,
$"Welcome to {libraryName}",
EmailTemplateProvider.GetLibraryUserInvitationEmail(account.Name, libraryName, new Uri(new Uri(_settings.FrontEndUrl), _settings.ResetPasswordPagePath).ToString()),
_settings.EmailFrom,
cancellationToken);
}
return(await base.HandleAsync(command, cancellationToken));
}
public bool SendEmailWithModel <T>(string templateName, T viewModel) where T : BaseEmailData
{
if (String.IsNullOrEmpty(viewModel.ContactEmails))
{
return(false);
}
var emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, SiteContext.CurrentSiteID);
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Both;
email.From = emailTemplate.TemplateFrom;
email.Recipients = viewModel.ContactEmails;
emailTemplate.TemplateSubject = email.Subject = viewModel.Subject;
var emailBody = BindEmailBody(emailTemplate, viewModel);
if (String.IsNullOrEmpty(emailBody))
{
return(false);
}
email.Body = emailBody;
EmailSender.SendEmailWithTemplateText(SiteContext.CurrentSiteName, email, emailTemplate, MacroContext.CurrentResolver, true);
return(true);
}
public override async Task <InviteUserCommand> HandleAsync(InviteUserCommand command, CancellationToken cancellationToken = default)
{
var library = await _libraryRepository.GetLibraryById(command.LibraryId, cancellationToken);
if (command.Role != Role.Admin && library == null)
{
throw new UnauthorizedException();
}
var account = await _accountRepository.GetAccountByEmail(command.Email, cancellationToken);
if (account != null)
{
var accountLibraries = await _libraryRepository.GetLibrariesByAccountId(account.Id, cancellationToken);
if (string.IsNullOrWhiteSpace(account.InvitationCode) &&
accountLibraries.Any(t => t.Id == command.LibraryId))
{
return(await base.HandleAsync(command, cancellationToken));
}
else
{
await _libraryRepository.AddAccountToLibrary(command.LibraryId, account.Id, command.Role, cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
}
var invitationCode = Guid.NewGuid();
await _accountRepository.AddInvitedAccount(
command.Name,
command.Email,
command.Role,
invitationCode.ToString("N"),
DateTime.Today.AddDays(7),
library?.Id,
cancellationToken);
if (command.Role == Role.Admin)
{
await _emailService.SendAsync(command.Email,
$"Welcome to Dashboards",
EmailTemplateProvider.GetSuperAdminInvitationEmail(command.Name, new Uri(new Uri(_settings.FrontEndUrl), _settings.ResetPasswordPagePath).ToString()),
_settings.EmailFrom,
cancellationToken);
}
else
{
await _emailService.SendAsync(command.Email,
$"Welcome to {library.Name}",
EmailTemplateProvider.GetLibraryUserInvitationEmail(command.Name, library.Name, new Uri(new Uri(_settings.FrontEndUrl), _settings.ResetPasswordPagePath).ToString()),
_settings.EmailFrom,
cancellationToken);
}
return(await base.HandleAsync(command, cancellationToken));
}
/// <summary>
/// Sends the emails.
/// </summary>
protected void Send()
{
// Check "modify" permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Users", "Modify"))
{
RedirectToAccessDenied("CMS.Users", "Modify");
}
// Check template name
var templateName = usBlankPasswords.Value.ToString();
if (string.IsNullOrWhiteSpace(templateName))
{
ShowError(GetString("Kadena.Email.TemplateNotSelected"));
return;
}
var emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, _siteId);
// Validate From field
if (string.IsNullOrEmpty(emailTemplate.TemplateFrom))
{
ShowError(GetString("Kadena.Email.CorrectFromField"));
return;
}
// Selecting users for emails
var users = UserInfoProvider.GetUsers().WhereEmpty("UserPassword")
.And()
.WhereNotEmpty("Email");
if (_siteId > 0)
{
users = users
.And()
.WhereIn("UserID", UserSiteInfoProvider.GetUserSites()
.WhereEquals("SiteID", _siteId)
.Column("UserID"))
.Columns("UserID", "Email", "UserGUID");
}
if (users.Count == 0)
{
ShowInformation(GetString("Kadena.Email.NoUsersToSend"));
return;
}
// Creating and sending email message.
var resolver = MacroResolver.GetInstance();
var emailService = new EmailService();
foreach (var ui in users)
{
emailService.SendResetPasswordEmail(ui, emailTemplate, _siteId > 0 ? siteSelector.SiteName : null, resolver);
}
ShowConfirmation(GetString("system_email.emailsent"));
}
public void HtmlEncodeWhenPassedTrue()
{
// Act
var actual = EmailTemplateProvider.Replace("<td>{param}</td>", new Dictionary <string, string> {
{ "param", "</>" }
}, true);
// Assert
Assert.AreEqual("<td></></td>", actual);
}
public void NotHtmlEncodeWhenPassedFalse()
{
// Act
var actual = EmailTemplateProvider.Replace("<td>{param}</td>", new Dictionary <string, string> {
{ "param", "</>" }
}, false);
// Assert
Assert.AreEqual("<td></></td>", actual);
}
public AccountController(
PersonProvider personProvider,
SecurityProvider securityProvider,
EmailTemplateProvider emailTemplateProvider,
Mailer mailer)
{
this.personProvider = personProvider;
this.securityProvider = securityProvider;
this.emailTemplateProvider = emailTemplateProvider;
this.mailer = mailer;
}
private void SendMail(string mail, IEnumerable <ProductBookModel> list)
{
SiteInfo currentSite = SiteContext.CurrentSite;
ContextResolver resolver = MacroContext.CurrentResolver;
string emailSubject = null;
EmailTemplateInfo template = null;
template = EmailTemplateProvider.GetEmailTemplate("SendProductLinkDownload", currentSite.SiteName);
emailSubject = EmailHelper.GetSubject(template, "Demande de contact");
//mail type
if (template != null)
{
ev.LogEvent("I", DateTime.Now, "Template!=null ", (template != null).ToString());
resolver.SourceParameters = null;
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
email.From =
EmailHelper.GetSender(template,
SettingsKeyInfoProvider.GetStringValue(currentSite.SiteName + ".CMSAdminEmailAddress"));
email.Recipients = mail;
StringBuilder sb = new StringBuilder();
foreach (var produit in list)
{
string str = "<br/> <b>" + produit.productname + "</b> (" + produit.fileUrl + ")";
sb = sb.AppendLine(str);
}
ev.LogEvent("I", DateTime.Now, "Template ", sb.ToString());
string templatetext =
template.TemplateText.Replace("#Product", sb.ToString());
email.Body = resolver.ResolveMacros(templatetext);
resolver.EncodeResolvedValues = false;
email.PlainTextBody = resolver.ResolveMacros(template.TemplatePlainText);
email.Subject = resolver.ResolveMacros(emailSubject);
email.CcRecipients = template.TemplateCc;
email.BccRecipients = template.TemplateBcc;
try
{
MetaFileInfoProvider.ResolveMetaFileImages(email, template.TemplateID, EmailObjectType.EMAILTEMPLATE,
MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(currentSite.SiteName, email, true);
}
catch (Exception ex)
{
ev.LogEvent("E", DateTime.Now, "SendMail ", ex.Message);
}
}
}
public void SendResetPasswordEmail(UserInfo user, string templateName, string siteName, MacroResolver resolver = null)
{
EmailTemplateInfo template;
var templateKey = siteName + templateName;
if (!templateCache.TryGetValue(templateKey, out template))
{
template = EmailTemplateProvider.GetEmailTemplate(templateName, siteName);
templateCache[templateKey] = template;
}
SendResetPasswordEmail(user, template, siteName, resolver);
}
/// <summary>
/// Sends new registration notification e-mail to administrator.
/// </summary>
private void SendRegistrationNotification(UserInfo ui)
{
var currentSiteName = SiteContext.CurrentSiteName;
// Notify administrator
if ((ui != null) && !String.IsNullOrEmpty(currentSiteName) && (ShoppingCartControl.SendNewRegistrationNotificationToAddress != ""))
{
EmailTemplateInfo mEmailTemplate = null;
MacroResolver resolver = MembershipResolvers.GetRegistrationResolver(ui);
if (SettingsKeyInfoProvider.GetBoolValue(currentSiteName + ".CMSRegistrationAdministratorApproval"))
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.Approve", currentSiteName);
}
else
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.New", currentSiteName);
}
if (mEmailTemplate == null)
{
// Email template not exist
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
// Initialize email message
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.From = EmailHelper.GetSender(mEmailTemplate, ECommerceSettings.SendEmailsFrom(currentSiteName));
message.Subject = GetString("RegistrationForm.EmailSubject");
message.Recipients = ShoppingCartControl.SendNewRegistrationNotificationToAddress;
message.Body = mEmailTemplate.TemplateText;
try
{
// Add template metafiles to e-mail
EmailHelper.ResolveMetaFileImages(message, mEmailTemplate.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
// Send e-mail
EmailSender.SendEmailWithTemplateText(currentSiteName, message, mEmailTemplate, resolver, false);
}
catch
{
// Email sending failed
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationEmail");
}
}
}
}
public HomeController(
SecurityProvider securityProvider,
ShowcaseProvider showcaseProvider,
AreaProvider areaProvider,
CartManager cartManager,
EmailTemplateProvider emailTemplateProvider,
Mailer mailer)
{
this.securityProvider = securityProvider;
this.showcaseProvider = showcaseProvider;
this.areaProvider = areaProvider;
this.cartManager = cartManager;
this.emailTemplateProvider = emailTemplateProvider;
this.mailer = mailer;
}
private void SendEmail(string templateName, MacroResolver resolver, string emailTo)
{
CMS.EmailEngine.EmailMessage msg = new CMS.EmailEngine.EmailMessage();
EmailTemplateInfo emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, SiteContext.CurrentSiteID);
msg.EmailFormat = EmailFormatEnum.Both;
msg.From = emailTemplate.TemplateFrom;
msg.Recipients = emailTo;
if (resolver != null)
{
msg.Body = resolver.ResolveMacros(emailTemplate.TemplateText);
}
EmailSender.SendEmailWithTemplateText(SiteContext.CurrentSiteName, msg, emailTemplate, null, true);
}
protected void btnUnsubscribe_click(object sender, EventArgs ea)
{
// Validate email
if (String.IsNullOrEmpty(email) || !ValidationHelper.IsEmail(email))
{
ShowError(GetString("om.contact.enteremail"));
return;
}
// Delete subscription if email is valid
if (rsi != null)
{
if (rsi.ReportSubscriptionEmail.Trim() != email)
{
ShowError(GetString("reportsubscription.emailnotmatch"));
return;
}
ReportSubscriptionInfoProvider.DeleteReportSubscriptionInfo(rsi.ReportSubscriptionID);
ShowInformation(GetString("reportsubscription.unsubscription.success"));
btnUnsubscribe.Visible = false;
pnlInfo.Visible = false;
// Send info about successful unsubscription to set email
String siteName = SiteContext.CurrentSiteName;
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Reporting_Unsubscription_template", siteName);
if (eti != null)
{
// Create email
EmailMessage em = new EmailMessage();
em.EmailFormat = EmailFormatEnum.Default;
em.From = String.IsNullOrEmpty(eti.TemplateFrom) ? EmailHelper.Settings.NotificationsSenderAdress(siteName) : eti.TemplateFrom;;
em.Recipients = rsi.ReportSubscriptionEmail;
em.Subject = eti.TemplateSubject;
em.BccRecipients = eti.TemplateBcc;
em.CcRecipients = eti.TemplateCc;
MacroResolver resolver = ReportSubscriptionSender.CreateSubscriptionMacroResolver(ri, rsi, SiteContext.CurrentSite, em.Recipients);
em.Body = resolver.ResolveMacros(eti.TemplateText);
em.PlainTextBody = resolver.ResolveMacros(eti.TemplatePlainText);
EmailHelper.ResolveMetaFileImages(em, eti.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(siteName, em);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (isDialog)
{
string templateName = QueryHelper.GetString("name", String.Empty);
EmailTemplateInfo emailTemplate = EmailTemplateProvider.GetEmailTemplate(templateName, SiteID);
if (emailTemplate != null)
{
EditedObject = emailTemplate;
}
RegisterEscScript();
RegisterModalPageScripts();
}
SetTab(0, GetString("general.general"), "Tab_General.aspx" + RequestContext.CurrentQueryString, String.Empty);
}
/// <summary>
/// Processes the stylesheet.
/// </summary>
protected void ProcessStylesheet()
{
// Newsletter template stylesheet
if (!string.IsNullOrEmpty(newsletterTemplateName))
{
// Get the template
et = EmailTemplateProvider.GetEmailTemplate(newsletterTemplateName, CMSContext.CurrentSiteID);
if (et != null)
{
// Create the output file
outputFile = new CMSOutputResource()
{
Name = URLHelper.Url.ToString(),
Data = HTMLHelper.ResolveCSSUrls(et.TemplateStylesheetText, URLHelper.ApplicationPath),
Etag = et.TemplateName
};
}
}
}
/// <summary>
/// Sends notification email to the administrator.
/// </summary>
private void SendAdminNotification(UserInfo ui)
{
if (NotifyAdministrator && (FromAddress != String.Empty) && (ToAddress != String.Empty))
{
var resolver = MembershipResolvers.GetRegistrationResolver(ui);
var emailTemplate = EmailTemplateProvider.GetEmailTemplate(AdminApprovalRequired ? "Registration.Approve" : "Registration.New", CurrentSiteName);
if (emailTemplate == null)
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.From = EmailHelper.GetSender(emailTemplate, FromAddress);
message.Recipients = ToAddress;
// Enable macro encoding for body
resolver.Settings.EncodeResolvedValues = true;
message.Body = resolver.ResolveMacros(emailTemplate.TemplateText);
// Disable macro encoding for plaintext body and subject
resolver.Settings.EncodeResolvedValues = false;
message.Subject = resolver.ResolveMacros(EmailHelper.GetSubject(emailTemplate, GetString("RegistrationForm.EmailSubject")));
message.PlainTextBody = resolver.ResolveMacros(emailTemplate.TemplatePlainText);
message.CcRecipients = emailTemplate.TemplateCc;
message.BccRecipients = emailTemplate.TemplateBcc;
try
{
// Attach template meta-files to e-mail
EmailHelper.ResolveMetaFileImages(message, emailTemplate.TemplateID, EmailTemplateInfo.OBJECT_TYPE, ObjectAttachmentsCategories.TEMPLATE);
EmailSender.SendEmail(CurrentSiteName, message);
}
catch
{
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationEmail");
}
}
}
}
public MailTemplate GetMailTemplate(int siteId, string templateName, string cultureCode = null)
{
var template = EmailTemplateProvider.GetEmailTemplate(templateName, siteId);
var localizeToCulture = string.IsNullOrWhiteSpace(cultureCode) ?
LocalizationContext.CurrentCulture.CultureCode
: cultureCode;
return(template == null ? null : new MailTemplate()
{
From = template.TemplateFrom,
Cc = template.TemplateCc,
Bcc = template.TemplateBcc,
ReplyTo = template.TemplateReplyTo,
BodyHtml = Convert.ToBase64String(Encoding.UTF8.GetBytes(ResHelper.LocalizeString(template.TemplateText ?? string.Empty, localizeToCulture))),
BodyPlain = ResHelper.LocalizeString(template.TemplatePlainText, localizeToCulture),
Subject = ResHelper.LocalizeString(template.TemplateSubject, localizeToCulture)
});
}
private void SendMail(string customerEmail, string invoicenumber)
{
SiteInfo currentSite = SiteContext.CurrentSite;
ContextResolver resolver = MacroContext.CurrentResolver;
EmailTemplateInfo template = null;
// string currentCultureCode = CMSContext.CurrentDocument.DocumentCulture;
const string currentCultureCode = "en-US";
template = EmailTemplateProvider.GetEmailTemplate("Ecommerce.OrderStatusToCustomer" + currentCultureCode, currentSite.SiteName);
string emailSubject = EmailHelper.GetSubject(template, "Votre commande n� " + invoicenumber);
//mail type
if (template != null)
{
resolver.SourceParameters = null;
var email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
email.From =
EmailHelper.GetSender(template,
SettingsKeyInfoProvider.GetStringValue(currentSite.SiteName + ".CMSAdminEmailAddress"));
email.Recipients = customerEmail;
string templatetext =
template.TemplateText.Replace("#InvoiceNumber", invoicenumber);
email.Body = resolver.ResolveMacros(templatetext);
resolver.EncodeResolvedValues = false;
email.Subject = resolver.ResolveMacros(emailSubject);
try
{
MetaFileInfoProvider.ResolveMetaFileImages(email, template.TemplateID, EmailObjectType.EMAILTEMPLATE,
MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
// Send the e-mail immediately
EmailSender.SendEmail(currentSite.SiteName, email, true);
}
catch (Exception ex)
{
ev.LogEvent("E", DateTime.Now, "SendMail ", ex.Message);
}
}
}
protected void btnUnsubscribe_click(object sender, EventArgs ea)
{
// Validate email
if (String.IsNullOrEmpty(mEmail) || !ValidationHelper.IsEmail(mEmail))
{
ShowError(GetString("om.contact.enteremail"));
return;
}
// Delete subscription if email is valid
if (mReportSubscriptionInfo != null)
{
if (mReportSubscriptionInfo.ReportSubscriptionEmail.Trim() != mEmail)
{
ShowError(GetString("reportsubscription.emailnotmatch"));
return;
}
ReportSubscriptionInfoProvider.DeleteReportSubscriptionInfo(mReportSubscriptionInfo.ReportSubscriptionID);
ShowInformation(GetString("reportsubscription.unsubscription.success"));
btnUnsubscribe.Visible = false;
pnlInfo.Visible = false;
// Send info about successful unsubscription to set email
String siteName = SiteContext.CurrentSiteName;
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Reporting_Unsubscription_template", siteName);
if (eti != null)
{
// Create email
EmailMessage em = new EmailMessage();
em.EmailFormat = EmailFormatEnum.Default;
em.From = EmailHelper.Settings.NotificationsSenderAddress(siteName);
em.Recipients = mReportSubscriptionInfo.ReportSubscriptionEmail;
MacroResolver resolver = ReportSubscriptionSender.CreateSubscriptionMacroResolver(mReportInfo, mReportSubscriptionInfo, SiteContext.CurrentSite, em.Recipients);
EmailSender.SendEmailWithTemplateText(siteName, em, eti, resolver, false);
}
}
}
/// <summary>
/// Send e-mail to administrator about new registration.
/// </summary>
/// <param name="administrationApproval">Indicates if administration approval is required</param>
private void SendEmailToAdministrator(bool administrationApproval)
{
MacroResolver resolver = MembershipResolvers.GetRegistrationResolver(RegisteredUser);
string currentSiteName = SiteContext.CurrentSiteName;
var template = EmailTemplateProvider.GetEmailTemplate(administrationApproval ? "Registration.Approve" : "Registration.New", currentSiteName);
if (template == null)
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationForm", "GetEmailTemplate", eventUrl: RequestContext.RawURL);
}
else
{
// E-mail template ok
string from = EmailHelper.GetSender(template, (!String.IsNullOrEmpty(FromAddress)) ? FromAddress : SettingsKeyInfoProvider.GetValue(currentSiteName + ".CMSNoreplyEmailAddress"));
if (!String.IsNullOrEmpty(from))
{
// Email message
EmailMessage email = new EmailMessage();
email.EmailFormat = EmailFormatEnum.Default;
email.Recipients = AdministratorEmail;
email.From = from;
email.Subject = GetString("RegistrationForm.EmailSubject");
try
{
EmailSender.SendEmailWithTemplateText(currentSiteName, email, template, resolver, true);
}
catch
{
EventLogProvider.LogEvent(EventType.ERROR, "Membership", "RegistrationApprovalEmail");
}
}
else
{
EventLogProvider.LogEvent(EventType.ERROR, "RegistrationApproval", "EmailSenderNotSpecified");
}
}
}
protected override void OnPreInit(EventArgs e)
{
isDialog = QueryHelper.GetBoolean("editonlycode", false);
if (isDialog)
{
// Check hash
if (!QueryHelper.ValidateHash("hash", "saved;name;templateid;selectorid;tabmode;siteid;selectedsiteid", true, false, true))
{
URLHelper.Redirect(ResolveUrl(String.Format("~/CMSMessages/Error.aspx?title={0}&text={1}", GetString("dialogs.badhashtitle"), GetString("dialogs.badhashtext"))));
}
string templateName = QueryHelper.GetString("name", String.Empty);
EmailTemplateInfo templateInfo = EmailTemplateProvider.GetEmailTemplate(templateName, SiteID);
if (templateInfo != null)
{
EditedObject = templateInfo;
}
MasterPageFile = "~/CMSMasterPages/UI/Dialogs/ModalDialogPage.master";
}
base.OnPreInit(e);
}
/// <summary>
/// Handles the UniGrid's OnAction event.
/// </summary>
/// <param name="actionName">Name of item (button) that throws event</param>
/// <param name="actionArgument">ID (value of Primary key) of corresponding data row</param>
protected void gridElem_OnAction(string actionName, object actionArgument)
{
switch (actionName.ToLowerCSafe())
{
case "edit":
SelectedItemID = ValidationHelper.GetInteger(actionArgument, 0);
RaiseOnEdit();
break;
case "delete":
if (!CheckPermissions("CMS.EmailTemplates", PERMISSION_MODIFY))
{
return;
}
// Get TemplateID
int templateId = ValidationHelper.GetInteger(actionArgument, 0);
EmailTemplateProvider.DeleteEmailTemplate(templateId);
break;
}
RaiseOnAction(actionName, actionArgument);
}
public override async Task <PasswordResetCommand> HandleAsync(PasswordResetCommand command, CancellationToken cancellationToken = default)
{
var account = await _accountRepository.GetAccountByEmail(command.Email, cancellationToken);
if (account == null)
{
return(await base.HandleAsync(command, cancellationToken));
}
var resetToken = _tokenGenerator.GenerateResetToken();
account.ResetToken = resetToken;
account.ResetTokenExpires = DateTime.UtcNow.AddDays(_settings.ResetTokenTTLInDays);
await _accountRepository.UpdateAccount(account, cancellationToken);
await _emailService.SendAsync(account.Email,
$"Reset your Password",
EmailTemplateProvider.GetResetPasswordEmail(account.Name, new Uri(new Uri(_settings.FrontEndUrl), _settings.ResetPasswordPagePath).ToString()),
_settings.EmailFrom,
cancellationToken);
return(await base.HandleAsync(command, cancellationToken));
}
/// <summary>
/// Sends new registration notification e-mail to administrator.
/// </summary>
private void SendRegistrationNotification(UserInfo ui)
{
SiteInfo currentSite = SiteContext.CurrentSite;
// Notify administrator
if ((ui != null) && (currentSite != null) && (ShoppingCartControl.SendNewRegistrationNotificationToAddress != ""))
{
EmailTemplateInfo mEmailTemplate = null;
if (!ui.UserEnabled)
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.Approve", currentSite.SiteName);
}
else
{
mEmailTemplate = EmailTemplateProvider.GetEmailTemplate("Registration.New", currentSite.SiteName);
}
EventLogProvider ev = new EventLogProvider();
if (mEmailTemplate == null)
{
// Email template not exist
ev.LogEvent("E", DateTime.Now, "RegistrationForm", "GetEmailTemplate", HTTPHelper.GetAbsoluteUri());
}
else
{
// Initialize email message
EmailMessage message = new EmailMessage();
message.EmailFormat = EmailFormatEnum.Default;
message.From = EmailHelper.GetSender(mEmailTemplate, ECommerceSettings.SendEmailsFrom(currentSite.SiteName));
message.Subject = GetString("RegistrationForm.EmailSubject");
message.Recipients = ShoppingCartControl.SendNewRegistrationNotificationToAddress;
message.Body = mEmailTemplate.TemplateText;
// Init macro resolving
string[,] replacements = new string[4, 2];
replacements[0, 0] = "firstname";
replacements[0, 1] = ui.FirstName;
replacements[1, 0] = "lastname";
replacements[1, 1] = ui.LastName;
replacements[2, 0] = "email";
replacements[2, 1] = ui.Email;
replacements[3, 0] = "username";
replacements[3, 1] = ui.UserName;
ContextResolver resolver = MacroContext.CurrentResolver;
resolver.SourceParameters = replacements;
try
{
// Add template metafiles to e-mail
MetaFileInfoProvider.ResolveMetaFileImages(message, mEmailTemplate.TemplateID, EmailObjectType.EMAILTEMPLATE, MetaFileInfoProvider.OBJECT_CATEGORY_TEMPLATE);
// Send e-mail
EmailSender.SendEmailWithTemplateText(currentSite.SiteName, message, mEmailTemplate, resolver, false);
}
catch
{
// Email sending failed
ev.LogEvent("E", DateTime.Now, "Membership", "RegistrationEmail", SiteContext.CurrentSite.SiteID);
}
}
}
}
