/// <summary> /// Updates a newsletterto the newsletter passed in by it's id /// </summary> /// <param name="newsletter"></param> /// <returns>true if newsletter was updated successfully</returns> public bool UpdateNewsletter(NewsletterModel newsletter) { int rowsEffected = 0; try { SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@newsletterId", newsletter.NewsletterId), new SqlParameter("@createdDate", _sql.ConvertDateTimeForSQL(newsletter.CreatedDate)), new SqlParameter("@createdBy", newsletter.CreatedBy), new SqlParameter("@memo", newsletter.Memo), new SqlParameter("@displayDate", newsletter.DisplayDate), new SqlParameter("@publishedDate", _sql.ConvertDateTimeForSQL(newsletter.PublishedDate)), new SqlParameter("@isCurrent", newsletter.IsCurrent == true ? "1" : "0"), new SqlParameter("@eventsStartDate", _sql.ConvertDateTimeForSQL(newsletter.EventsStartDate)), new SqlParameter("@eventsEndDate", _sql.ConvertDateTimeForSQL(newsletter.EventsEndDate)) }; rowsEffected = _sql.GetReturnValueFromStoredProcedure("UpdateNewsletter", parameters); } catch (Exception ex) { _logger.LogError("There was an updating the newsletter in the Newsletter Service", ex); } return(rowsEffected > 0); }
public ActionResult SaveAndContinue(NewsletterModel model) { if (!CheckPermission(NewsletterPermissions.ManageNewsletters)) { return(new HttpUnauthorizedResult()); } Newsletter entity = null; if (model.Id != Guid.Empty) { entity = newsletterService.GetById(model.Id); } else { entity = new Newsletter { DateCreated = DateTime.UtcNow }; } entity.Title = model.Title; entity.BodyContent = model.BodyContent; entity.CultureCode = model.CultureCode; entity.RefId = model.RefId; newsletterService.Save(entity); return(null); }
/// <summary> /// Gets all the newsletters /// </summary> /// <returns>all the newsletters</returns> public List <NewsletterModel> GetAllNewsletters() { List <NewsletterModel> newslettersToReturn = new List <NewsletterModel>(); DataSet GetAllNewslettersResult = _sql.GetDatasetFromStoredProcedure("GetAllNewsletters"); if (GetAllNewslettersResult.Tables[0].Rows.Count > 0) { try { IEnumerable <DataRow> newsletterResults = GetAllNewslettersResult.Tables[0].AsEnumerable(); foreach (DataRow newsletterRow in newsletterResults) { NewsletterModel newsletterToAdd = new NewsletterModel(newsletterRow); newslettersToReturn.Add(newsletterToAdd); } } catch (Exception ex) { _logger.LogError("Unable to transcribe GetAllNewslettersResult to newsletters in NewsletterService/GetAllNewsletters", ex); } } return(newslettersToReturn); }
/// <summary> /// Gets a newsletter by it's id number /// </summary> /// <returns>the requested newsletter</returns> public NewsletterModel GetNewsletterById(int newsletterId) { NewsletterModel newsletter = new NewsletterModel(); SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@newsletterId", newsletterId) }; DataSet GetNewsletterByNewsletterIdResult = _sql.GetDatasetFromStoredProcedure("GetNewsletterByNewsletterId", parameters); if (GetNewsletterByNewsletterIdResult.Tables.Count > 0) { try { DataRow newsletterResult = GetNewsletterByNewsletterIdResult.Tables[0].AsEnumerable().FirstOrDefault(); newsletter = new NewsletterModel(newsletterResult); } catch (Exception ex) { _logger.LogError("Unable to transcribe GetNewsletterByNewsletterIdResult to newsletter in NewsletterService/GetNewsletterById with the Id: " + newsletterId, ex); } if (newsletter.CreatedDate != null) { newsletter.Articles = GetArticlesForNewsletter(newsletter.NewsletterId, "GetNewsletterById"); newsletter.Events = GetEventsForNewsletter(newsletter.EventsStartDate, newsletter.EventsEndDate, "GetNewsletterById"); } } return(newsletter); }
public ActionResult Translate(Guid id, string cultureCode) { if (!CheckPermission(NewsletterPermissions.ManageNewsletters)) { return(new HttpUnauthorizedResult()); } NewsletterModel model = newsletterService.GetByLanguage(id, cultureCode); WorkContext.Breadcrumbs.Add(T("Newsletters"), Url.Action("Index", new { area = Constants.Areas.Newsletters })); if (model != null) { WorkContext.Breadcrumbs.Add(model.Title); } WorkContext.Breadcrumbs.Add(T("Translate")); WorkContext.Breadcrumbs.Add(cultureCode); var showSaveAndContinue = false; if (model == null) { model = newsletterService.GetById(id); model.Id = Guid.Empty; model.CultureCode = cultureCode; model.RefId = id; ViewData.ModelState["Id"] = new ModelState { Value = new ValueProviderResult(Guid.Empty, Guid.Empty.ToString(), null) }; } else { ViewData.ModelState["Id"] = new ModelState { Value = new ValueProviderResult(model.Id, model.Id.ToString(), null) }; showSaveAndContinue = true; } var result = new ControlFormResult <NewsletterModel>(model) { Title = T("Translate Newsletter").Text, UpdateActionName = "Update", ShowBoxHeader = false, FormWrapperStartHtml = Constants.Form.FormWrapperStartHtml, FormWrapperEndHtml = Constants.Form.FormWrapperEndHtml }; result.AssignGridLayout(x => x.Id, 0, 0); result.AssignGridLayout(x => x.CultureCode, 0, 0); result.AssignGridLayout(x => x.RefId, 0, 0); result.AssignGridLayout(x => x.Title, 0, 0); result.AssignGridLayout(x => x.BodyContent, 0, 1, 2); if (showSaveAndContinue) { result.AddAction(true, true, false).HasText(T("Save & Continue")).HasName("SaveAndContinue").HasButtonStyle(ButtonStyle.Info); } return(result); }
public IActionResult Index() { NewsletterModel model = null; try { model = _newsletter.GetPublishedNewsletter(); // In case there are no newsletters in the database if (model.CreatedDate == DateTime.MinValue) { model = new NewsletterModel() { NewsletterId = -1, CreatedBy = -1, CreatedDate = DateTime.MinValue, DisplayDate = DateTime.MinValue.ToString("MMMM yyyy"), Memo = "This was an autogenerated newsletter.", IsCurrent = true, PublishedDate = DateTime.Now }; } } catch (Exception ex) { _logger.LogError("There was an error retrieving the newsletter model in the Home Controller", ex); } return(View(model)); }
public ActionResult Edit(Guid id) { if (!CheckPermission(NewsletterPermissions.ManageNewsletters)) { return(new HttpUnauthorizedResult()); } NewsletterModel model = newsletterService.GetById(id); WorkContext.Breadcrumbs.Add(T("Newsletters"), Url.Action("Index", new { area = Constants.Areas.Newsletters })); WorkContext.Breadcrumbs.Add(model.Title); WorkContext.Breadcrumbs.Add(T("Edit")); var result = new ControlFormResult <NewsletterModel>(model) { Title = T("Edit Newsletter").Text, UpdateActionName = "Update", ShowBoxHeader = false, FormWrapperStartHtml = Constants.Form.FormWrapperStartHtml, FormWrapperEndHtml = Constants.Form.FormWrapperEndHtml }; result.AddAction(true, true, false).HasText(T("Save & Continue")).HasName("SaveAndContinue").HasButtonStyle(ButtonStyle.Info); return(result); }
public IActionResult UpdateNewsletter(int newsletterId, string oldMemo, string memo, string oldDisplayDate, string displayDate) { // handle possible nulls. oldMemo = string.IsNullOrEmpty(oldMemo) ? "" : oldMemo.Trim(); memo = string.IsNullOrEmpty(memo) ? "" : memo.Trim(); oldDisplayDate = string.IsNullOrEmpty(oldDisplayDate) ? "" : oldDisplayDate.Trim(); displayDate = string.IsNullOrEmpty(displayDate) ? "" : displayDate.Trim(); bool memoChanged = (oldMemo.Equals(memo) == false); bool displayDateChanged = (oldDisplayDate.Equals(displayDate) == false); if (memoChanged || displayDateChanged) { NewsletterModel oldNewsletter = _newsletter.GetNewsletterById(newsletterId); if (memoChanged) { oldNewsletter.Memo = memo; } if (displayDateChanged) { oldNewsletter.DisplayDate = displayDate; } bool successfulUpdate = _newsletter.UpdateNewsletter(oldNewsletter); } return(RedirectToAction("EditNewsletter", new { newsletterId = newsletterId })); }
public async Task <IActionResult> Edit(int id, [Bind("ID,Email")] NewsletterModel newsletterModel) { if (id != newsletterModel.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(newsletterModel); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!NewsletterModelExists(newsletterModel.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(newsletterModel)); }
/// <summary> /// Gets the most recent published newsletter /// </summary> /// <returns>The most recent published newsletter</returns> public NewsletterModel GetPublishedNewsletter() { NewsletterModel newsletter = new NewsletterModel(); DataSet GetPublishedNewsletterResult = _sql.GetDatasetFromStoredProcedure("GetPublishedNewsletter"); if (GetPublishedNewsletterResult.Tables[0].Rows.Count > 0) { DataRow newsletterResult = GetPublishedNewsletterResult.Tables[0].AsEnumerable().FirstOrDefault(); if (newsletterResult != null) { try { newsletter = new NewsletterModel(newsletterResult); } catch (Exception ex) { _logger.LogError("Unable to transcribe newsletterResult to newsletter Model in NewsletterService/GetPublishedNewsletter", ex); } newsletter.Articles = GetArticlesForNewsletter(newsletter.NewsletterId, "GetPublishedNewsletter"); newsletter.Events = GetEventsForNewsletter(newsletter.EventsStartDate, newsletter.EventsEndDate, "GetPublishedNewsletter"); } else { _logger.LogWarning("newsletterResult was null in NewsletterService/GetPublishedNewsletter"); } } return(newsletter); }
public IActionResult EditNewsletter(int newsletterId) { NewsletterModel model = _newsletter.GetNewsletterById(newsletterId); model.IsEdit = true; return(View(model)); }
public ActionResult Create([Bind(Include = "email")] NewsletterModel newsletter) { if (ModelState.IsValid) { return(PartialView("_Newsletter", newsletter)); } return(PartialView("_Newsletter", newsletter)); }
static async Task <Uri> CreateNewsletterAsync(NewsletterModel news) { HttpResponseMessage response = await client.PostAsJsonAsync( "localhost:3400/sendEmail", news); response.EnsureSuccessStatusCode(); return(response.Headers.Location); }
public async Task <IActionResult> Index() { NewsletterModel newsletterModel = await NewsletterRepository.GetAsync(); List <ObjectNewsletter> newsletterList = new List <ObjectNewsletter>(newsletterModel.data.Capacity); newsletterList.AddRange(newsletterModel.data); return(PartialView(new NewsletterViewModel(newsletterList))); }
Models.Home.NewsletterModel INewsletterHelper.GetNewsletterModel() { var list = GetNewsList(_newsletterRepository.TypeOfNews); var model = new NewsletterModel(); model.TypeOfNews = list; return(model); }
public ActionResult NewsletterSubscription(NewsletterModel newsletter) { if (newsletter != null) { newsletter.Email = Sanitizer.GetSafeHtmlFragment(newsletter.Email); var response = _customerRepository.NewsletterSubscription(newsletter); return(JsonSuccess(response.Result, JsonRequestBehavior.AllowGet)); } return(JsonSuccess(false, JsonRequestBehavior.AllowGet)); }
public HttpResponseMessage GetNewsletters() { HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK); UserPrincipal loggedInUser = (UserPrincipal)HttpContext.Current.User; response.Content = new ObjectContent <List <NewsletterModel> > (NewsletterModel.MapNewsletterModels(NewsletterAdminBLL.GetNewsletters(loggedInUser.AccountSession.ClubId)), new JsonMediaTypeFormatter()); return(response); }
public HttpResponseMessage SaveNewsletter(NewsletterModel newsletter) { HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK); UserPrincipal loggedInUser = (UserPrincipal)HttpContext.Current.User; newsletter.CreatedBy = loggedInUser.AccountSession.AccountId; newsletter.ClubId = loggedInUser.AccountSession.ClubId; NewsletterAdminBLL.SaveNewsletter(NewsletterModel.MapDal(newsletter)); return(response); }
public async Task <IActionResult> Create([Bind("ID,Email")] NewsletterModel newsletterModel) { if (ModelState.IsValid) { _context.Add(newsletterModel); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(newsletterModel)); }
// GET: sendEmails public ActionResult Index(NewsletterModel newslettermodel) { var news = new NewsletterModel { subject = newslettermodel.subject, description = newslettermodel.description, emails = getAllEmails(), fileName = newslettermodel.fileName }; return(View(news)); }
public async Task GetSubscriptions(int page = 1) { var pager = new Pager(page); var items = await DataService.Newsletters.GetList(e => e.Id > 0, pager); Model = new NewsletterModel { Emails = items, Pager = pager }; StateHasChanged(); }
public static void SendNewsLetter(string AdminId, string CustomerIds, NewsletterModel model) { IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler(); scheduler.Start(); IJobDetail EmailJobs = JobBuilder.Create <NewsletterJob>().UsingJobData("AdminIs", AdminId).UsingJobData("CustomerIds", CustomerIds).UsingJobData("P1", model.P1).UsingJobData("P2", model.P2).UsingJobData("P3", model.P3).UsingJobData("P4", model.P4).UsingJobData("P5", model.P5).UsingJobData("P6", model.P6).UsingJobData("P7", model.P7).UsingJobData("PG1", model.PG1).UsingJobData("PG2", model.PG2).UsingJobData("PG3", model.PG3).UsingJobData("PG4", model.PG4).UsingJobData("PG5", model.PG5).UsingJobData("PG6", model.PG6).UsingJobData("PG7", model.PG7).UsingJobData("AdminLogo", model.AdminLogo).UsingJobData("PropertyPhoto", model.PropertyPhoto).UsingJobData("FirstContent", model.FirstContent).UsingJobData("SecondContent", model.SecondContent).UsingJobData("ThirdContent", model.ThirdContent).UsingJobData("TemplateType", model.TemplateType).UsingJobData("PP1", model.PP1).UsingJobData("PP2", model.PP2).UsingJobData("PP3", model.PP3).UsingJobData("PP4", model.PP4).UsingJobData("PP5", model.PP5).UsingJobData("PP6", model.PP6).UsingJobData("PPG1", model.PPG1).UsingJobData("PPG2", model.PPG2).UsingJobData("PPG3", model.PPG3).UsingJobData("PPG4", model.PPG4).UsingJobData("PPG5", model.PPG5).UsingJobData("PPG6", model.PPG6).Build(); ITrigger EmailTrigger = TriggerBuilder.Create() .WithSimpleSchedule(s => s.WithIntervalInSeconds(30)) //It will send with in 30 seconds .Build(); scheduler.ScheduleJob(EmailJobs, EmailTrigger); }
public IActionResult Post([FromForm] NewsletterModel newsletter) { // This fields must not have any value (robots detection). if (!string.IsNullOrEmpty(newsletter.Dummy) || !ModelState.IsValid) { var errors = string.Join("; ", ModelState.Values .SelectMany(x => x.Errors) .Select(x => x.ErrorMessage)); return(NotFound(errors)); } AzureStorageHelper.Store(newsletter); return(Ok(ApplicationSettings.Configuration["Email:Messages:Newsletter"])); }
public ActionResult LogoImage(NewsletterModel model, HttpPostedFileBase Logofile, HttpPostedFileBase Imgfile) { var logopath = ""; var Photopath = ""; if (Logofile != null) { //Save the photo in Folder var fileExt = Path.GetExtension(Logofile.FileName); string fileName = Guid.NewGuid() + fileExt; var subPath = Server.MapPath("~/NewsLetterImages"); //Check SubPath Exist or Not if (!Directory.Exists(subPath)) { Directory.CreateDirectory(subPath); } //End : Check SubPath Exist or Not var path = Path.Combine(subPath, fileName); Logofile.SaveAs(path); var URL = ConfigurationManager.AppSettings["LiveURL"].ToString(); logopath = URL + "/NewsLetterImages/" + fileName; } if (Imgfile != null) { //Save the photo in Folder var fileExt = Path.GetExtension(Imgfile.FileName); string fileName = Guid.NewGuid() + fileExt; var subPath = Server.MapPath("~/NewsLetterImages"); //Check SubPath Exist or Not if (!Directory.Exists(subPath)) { Directory.CreateDirectory(subPath); } //End : Check SubPath Exist or Not var path = Path.Combine(subPath, fileName); Imgfile.SaveAs(path); var URL = ConfigurationManager.AppSettings["LiveURL"].ToString(); Photopath = URL + "/NewsLetterImages/" + fileName; } SendMailToUser(logopath, Photopath, model); return(Json("success")); }
public async Task <ActionResult> AddNewsLetter() { try { StringValues data; if (!Request.Headers.TryGetValue("NewsLetter", out data)) { return(new JsonResult(ResponseModel.Error("Invalid access detect."))); } var dec = Barayand.Common.Services.CryptoJsService.DecryptStringAES(data); NewsLetter rm = JsonConvert.DeserializeObject <NewsLetter>(dec); NewsletterModel cm = (NewsletterModel)_mapper.Map <OutModels.Models.NewsLetter, NewsletterModel>(rm); return(new JsonResult(await this._newsletterrepository.Insert(cm))); } catch (Exception ex) { return(null); } }
public ActionResult SaveNewsletter(NewsletterModel newsletter) { if (ModelState.IsValid) { if (_newsletterHelper.TrySave(newsletter)) { ViewBag.Email = newsletter.Email; Alert.SetAlert(AlertStatus.Succes, "Poprawnie zapisano do newslettera!"); return(RedirectToAction("Index")); } else { return(View(_newsletterHelper.GetNewsletterModel())); } } else { return(View(_newsletterHelper.GetNewsletterModel())); } }
protected async Task SearchSubscriptions(int page) { if (string.IsNullOrEmpty(SearchTerm)) { await GetSubscriptions(1); } else { var pager = new Pager(page); IEnumerable <Newsletter> items; items = await DataService.Newsletters.GetList(e => e.Email.Contains(SearchTerm) || e.Ip.Contains(SearchTerm), pager); Model = new NewsletterModel { Emails = items, Pager = pager }; } }
public string ReplacePlaceholders(string mailContent, NewsletterModel productRequest) { string firstnamePlaceholder = "[FIRSTNAME]", lastnamePlaceholder = "[LASTNAME]", emailPlaceholder = "[EMAIL]", industryPlaceholder = "[INDUSTRY]", companyPlaceholder = "[COMPANY]", jobtitlePlaceholder = "[JOBTITLE]", datePlaceholder = "[DATE]", date = DateTime.Now.Date.ToString("dd MMM yyyy"); mailContent = mailContent.Replace(firstnamePlaceholder, productRequest.FirstName) .Replace(lastnamePlaceholder, productRequest.LastName) .Replace(industryPlaceholder, ((String.IsNullOrEmpty(productRequest.Industry)) ? String.Empty : ((Umbraco.TypedContent(productRequest.Industry) != null) ? Umbraco.TypedContent(productRequest.Industry).Name : productRequest.Industry))) .Replace(companyPlaceholder, productRequest.Company) .Replace(emailPlaceholder, productRequest.Email) .Replace(jobtitlePlaceholder, productRequest.JobTitle) .Replace(datePlaceholder, date); return(mailContent); }
public ActionResult Index() { NewsletterModel model = new NewsletterModel(); var Admin = _CustomerService.GetCustomer(Convert.ToInt32(Session["CustomerID"])); if (Admin != null) { model.AdminPhoto = Admin.PhotoPath; var AdminLogo = _CompanyService.GetCompany(Admin.CompanyID); if (AdminLogo != null) { model.AdminLogo = AdminLogo.LogoPath; } var AdminId = Convert.ToInt32(Session["CustomerID"]) == null ? 0 : Convert.ToInt32(Session["CustomerID"]); var CustomerList = _CustomerService.GetCustomers().Where(c => c.ParentId == AdminId); ViewBag.Customerlist = CustomerList.Select(x => new SelectListItem { Value = x.CustomerId.ToString(), Text = x.FirstName + " " + x.LastName }).AsEnumerable(); } return(View(model)); }
/// <summary> /// Adds a newsletter to the database along with all it's articles /// </summary> /// <param name="newsletter"></param> /// <returns>true if newsletter was added successfully</returns> public int AddNewsletter() { NewsletterModel newsletter = new NewsletterModel(); string currentUser = _httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier); int currentUserId = -1; if (string.IsNullOrEmpty(currentUser)) { _logger.LogError("CurrentUserId was unable to be acquired in NewsletterService/AddNewsletter", null); } else { currentUserId = string.IsNullOrEmpty(currentUser) ? -1 : Int32.Parse(currentUser); } int returnedNewsletterId = -1; try { SqlParameter[] parameters = new SqlParameter[] { new SqlParameter("@createdDate", _sql.ConvertDateTimeForSQL(DateTime.Now)), new SqlParameter("@createdBy", currentUserId), new SqlParameter("@memo", "Please Update"), new SqlParameter("@displayDate", DateTime.Now.ToString("yyyy-MM")), new SqlParameter("@newsletterId", returnedNewsletterId) }; returnedNewsletterId = _sql.GetReturnValueFromStoredProcedure("AddNewsletter", parameters); } catch (Exception ex) { _logger.LogError("There was an error Adding/Inserting the newsletter model in the Newsletter Service", ex); } return(returnedNewsletterId); }