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(); }