public EmailSettingsManager()
{
EmailSettingsViewModel _ESVM = new EmailSettingsViewModel();
this.DataContext = _ESVM;
InitializeComponent();
}
public IActionResult EmailSettings(EmailSettingsViewModel model)
{
if (ModelState.IsValid)
{
var ec = _blogConfig.EmailConfiguration;
ec.AdminEmail = model.AdminEmail;
ec.BannedMailDomain = model.BannedMailDomain;
ec.EmailDisplayName = model.EmailDisplayName;
ec.EnableEmailSending = model.EnableEmailSending;
ec.EnableSsl = model.EnableSsl;
ec.SendEmailOnCommentReply = model.SendEmailOnCommentReply;
ec.SendEmailOnNewComment = model.SendEmailOnNewComment;
ec.SmtpServer = model.SmtpServer;
ec.SmtpServerPort = model.SmtpServerPort;
ec.SmtpUserName = model.SmtpUserName;
if (!string.IsNullOrWhiteSpace(model.SmtpClearPassword))
{
ec.SmtpPassword = _blogConfigurationService.EncryptPassword(model.SmtpClearPassword);
}
var response = _blogConfigurationService.SaveConfiguration(ec);
_blogConfig.RequireRefresh();
return(Json(response));
}
return(Json(new FailedResponse((int)ResponseFailureCode.InvalidModelState, "Invalid ModelState")));
}
public async Task <IActionResult> EmailConfigUpdate([FromBody] EmailSettingsViewModel model)
{
if (model == null)
{
return(BadRequest(ModelState));
}
AppSetting oldSetting = null;
var setting = await Db.AppSettings.GetEmailSettingsAsync();
if (setting == null)
{
setting = new AppSetting {
Name = EMAIL_SETTINGS_NAME
};
await Db.AppSettings.AddAsync(setting);
}
else
{
oldSetting = setting.Clone();
}
setting.Value = Newtonsoft.Json.JsonConvert.SerializeObject(model);
await Db.SaveChangesAsync();
await EventLogger.LogAsync(SysEventType.EmailConfigUpdated, await FindUserAsync(), setting, oldSetting);
return(Ok());
}
public override async Task <IViewProviderResult> BuildUpdateAsync(EmailSettings settings, IViewProviderContext context)
{
var model = new EmailSettingsViewModel();
// Validate model
if (!await context.Updater.TryUpdateModelAsync(model))
{
return(await BuildEditAsync(settings, context));
}
// Update settings
if (context.Updater.ModelState.IsValid)
{
// Encrypt the password
var username = model.SmtpSettings.UserName;
var password = string.Empty;
if (!string.IsNullOrWhiteSpace(model.SmtpSettings.Password))
{
try
{
password = _encrypter.Encrypt(model.SmtpSettings.Password);
}
catch (Exception e)
{
if (_logger.IsEnabled(LogLevel.Error))
{
_logger.LogError($"There was a problem encrypting the SMTP server password. {e.Message}");
}
}
}
settings = new EmailSettings()
{
SmtpSettings = new SmtpSettings()
{
DefaultFrom = model.SmtpSettings.DefaultFrom,
Host = model.SmtpSettings.Host,
Port = model.SmtpSettings.Port,
UserName = username,
Password = password,
RequireCredentials = model.SmtpSettings.RequireCredentials,
EnableSsl = model.SmtpSettings.EnableSsl,
PollingInterval = model.SmtpSettings.PollInterval,
BatchSize = model.SmtpSettings.BatchSize,
SendAttempts = model.SmtpSettings.SendAttempts,
EnablePolling = model.SmtpSettings.EnablePolling
}
};
var result = await _emailSettingsStore.SaveAsync(settings);
if (result != null)
{
// Recycle shell context to ensure changes take effect
_platoHost.RecycleShellContext(_shellSettings);
}
}
return(await BuildEditAsync(settings, context));
}
public IViewComponentResult Invoke()
{
var model = new EmailSettingsViewModel();
var emailTemplates = _emailData.GetEmailTemplateByUserAsync().Result;
model.EmailTemplates = emailTemplates;
return(View("EmailSettings", model));
}
public IActionResult EmailSettings(EmailSettingsViewModel model)
{
var result = _emailSender.ChangeSettings(model);
if (result.IsSuccess)
{
return(View());
}
ModelState.AppendResultModelErrors(result.Errors);
return(View(model));
}
public ActionResult EmailSettingsSave(EmailSettingsViewModel viewModel)
{
SessionKontrol();
if (_users != null)
{
_EmailSettingsServices.Update(viewModel);
_unitOfWork.SaveChanges();
return(RedirectToAction("EmailSettings", "Email"));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public ActionResult Email(EmailSettingsViewModel model)
{
Settings.Instance.EmailEnabled = model.EmailEnabled;
Settings.Instance.EmailFromAddress = model.EmailFromAddress;
Settings.Instance.EmailHost = model.EmailHost;
Settings.Instance.EmailHostPort = model.EmailHostPort;
Settings.Instance.EmailEnableSsl = model.EnableSsl;
Settings.Instance.EmailUsername = model.UserName;
Settings.Instance.EmailPassword = model.Password;
Settings.Instance.EmailSubjectPrefix = model.SubjectPrefix;
Settings.SaveSettings(Settings.Instance);
return(this.View(model));
}
public ActionResult Email()
{
var model = new EmailSettingsViewModel {
EmailEnabled = Settings.Instance.EmailEnabled,
EmailFromAddress = Settings.Instance.EmailFromAddress,
EmailHost = Settings.Instance.EmailHost,
EmailHostPort = Settings.Instance.EmailHostPort,
EnableSsl = Settings.Instance.EmailEnableSsl,
UserName = Settings.Instance.EmailUsername,
Password = Settings.Instance.EmailPassword,
SubjectPrefix = Settings.Instance.EmailSubjectPrefix
};
return(this.View(model));
}
public void Add(EmailSettingsViewModel viewModel)
{
_repository.Add(new EmailSettings
{
CreationDate = DateTime.Now,
IsItDeleted = false,
Status = true,
Username = viewModel.Username,
Password = viewModel.Password,
Host = viewModel.Host,
Port = viewModel.Port,
Mail = viewModel.Mail
});
}
public IActionResult EmailSettings()
{
var settings = _blogConfig.EmailSettings;
var vm = new EmailSettingsViewModel
{
AdminEmail = settings.AdminEmail,
BannedMailDomain = settings.BannedMailDomain,
EmailDisplayName = settings.EmailDisplayName,
EnableEmailSending = settings.EnableEmailSending,
SendEmailOnCommentReply = settings.SendEmailOnCommentReply,
SendEmailOnNewComment = settings.SendEmailOnNewComment
};
return(View(vm));
}
public async Task <IActionResult> IndexPost(EmailSettingsViewModel viewModel)
{
// Ensure we have permission
if (!await _authorizationService.AuthorizeAsync(User, Permissions.ManageEmailSettings))
{
return(Unauthorized());
}
// Execute view providers ProvideUpdateAsync method
await _viewProvider.ProvideUpdateAsync(new EmailSettings(), this);
// Add alert
_alerter.Success(T["Settings Updated Successfully!"]);
return(RedirectToAction(nameof(Index)));
}
/// <inheritdoc />
/// <summary>
/// Update email settings
/// </summary>
/// <param name="newSettings"></param>
/// <returns></returns>
public virtual ResultModel ChangeSettings(EmailSettingsViewModel newSettings)
{
var result = new ResultModel();
_options.Update(options =>
{
options.NetworkCredential = newSettings.NetworkCredential;
options.Enabled = newSettings.Enabled;
options.Host = newSettings.Host;
options.Port = newSettings.Port;
options.Timeout = newSettings.Timeout;
options.EnableSsl = newSettings.EnableSsl;
});
result.IsSuccess = true;
return(result);
}
public async Task <IActionResult> EmailConfig()
{
var setting = await Db.AppSettings.GetEmailSettingsAsync();
EmailSettingsViewModel config = null;
if (setting?.Value == null)
{
config = new EmailSettingsViewModel();
}
else
{
config = setting.Value.Deserialize <EmailSettingsViewModel>();
}
return(new OkObjectResult(config));
}
public void Update(EmailSettingsViewModel viewModel)
{
var emailsettings = _repository.Get(x => x.Id == viewModel.Id);
emailsettings.Status = viewModel.Status;
emailsettings.DateOfUpdate = DateTime.Now;
emailsettings.IsItDeleted = viewModel.IsItDeleted;
emailsettings.Username = viewModel.Username;
emailsettings.Password = viewModel.Password;
emailsettings.Host = viewModel.Host;
emailsettings.Port = viewModel.Port;
emailsettings.Mail = viewModel.Mail;
_repository.Update(emailsettings);
}
public async Task <IEmailClientConfiguration> GetConfigurationAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var setting = await _repository.GetAsync(q => q.GetEmailSettings(), cancellationToken);
EmailSettingsViewModel config = null;
if (setting?.Value == null)
{
config = new EmailSettingsViewModel();
}
else
{
config = setting.Value.Deserialize <EmailSettingsViewModel>();
}
return(config.Smtp);
}
public async Task <IActionResult> EmailSettings(EmailSettingsViewModel model)
{
if (ModelState.IsValid)
{
var ec = _blogConfig.EmailSettings;
ec.AdminEmail = model.AdminEmail;
ec.BannedMailDomain = model.BannedMailDomain;
ec.EmailDisplayName = model.EmailDisplayName;
ec.EnableEmailSending = model.EnableEmailSending;
ec.SendEmailOnCommentReply = model.SendEmailOnCommentReply;
ec.SendEmailOnNewComment = model.SendEmailOnNewComment;
var response = await _blogConfig.SaveConfigurationAsync(ec);
_blogConfig.RequireRefresh();
return(Json(response));
}
return(Json(new FailedResponse((int)ResponseFailureCode.InvalidModelState, "Invalid ModelState")));
}
public IActionResult EmailSettings()
{
var ec = _blogConfig.EmailConfiguration;
var vm = new EmailSettingsViewModel
{
AdminEmail = ec.AdminEmail,
BannedMailDomain = ec.BannedMailDomain,
EmailDisplayName = ec.EmailDisplayName,
EnableEmailSending = ec.EnableEmailSending,
EnableSsl = ec.EnableSsl,
SendEmailOnCommentReply = ec.SendEmailOnCommentReply,
SendEmailOnNewComment = ec.SendEmailOnNewComment,
SmtpServer = ec.SmtpServer,
SmtpServerPort = ec.SmtpServerPort,
SmtpUserName = ec.SmtpUserName
};
return(View(vm));
}
public async Task <IActionResult> EmailSettings(EmailSettingsViewModel model)
{
if (ModelState.IsValid)
{
var settings = _blogConfig.EmailSettings;
settings.AdminEmail = model.AdminEmail;
settings.BannedMailDomain = model.BannedMailDomain;
settings.EmailDisplayName = model.EmailDisplayName;
settings.EnableEmailSending = model.EnableEmailSending;
settings.SendEmailOnCommentReply = model.SendEmailOnCommentReply;
settings.SendEmailOnNewComment = model.SendEmailOnNewComment;
var response = await _blogConfig.SaveConfigurationAsync(settings);
_blogConfig.RequireRefresh();
Logger.LogInformation($"User '{User.Identity.Name}' updated EmailSettings");
return(Json(response));
}
return(Json(new FailedResponse((int)ResponseFailureCode.InvalidModelState, "Invalid ModelState")));
}
async Task SyncEmailSettings()
{
_updatingEmailSettings = true;
try
{
_appSettingsRepo.DiscardChanges();
var emailSettings = await _appSettingsRepo.GetAsync(q => q.GetEmailSettings());
if (emailSettings != null)
{
_emailSettings = emailSettings.Value.Deserialize <EmailSettingsViewModel>();
_emailClient.Configuration = _emailSettings.Smtp;
}
}
catch
{
}
finally
{
_updatingEmailSettings = false;
}
}
public EmailSettingsView()
{
InitializeComponent();
DataContext = _viewModel = new EmailSettingsViewModel();
}
