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