public async Task <IActionResult> Edit(int id, [Bind("ID,Firstname,Email")] NewsletterViewModel newsletterViewModel)
{
if (id != newsletterViewModel.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(newsletterViewModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NewsletterViewModelExists(newsletterViewModel.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(newsletterViewModel));
}
public ActionResult Newsletter(NewsletterViewModel newsletterViewModel)
{
var gymMembers = db.GymMember.ToList();
if (ModelState.IsValid)
{
foreach (var x in gymMembers)
{
String toEmail = x.ApplicationUser.Email;
String subject = newsletterViewModel.News_title;
String contents = newsletterViewModel.News_content;
String contents1 = String.Empty;
using (StreamReader reader = new StreamReader(Server.MapPath("~/Email_Template/Newsletter_Contents.html")))
{
contents1 = reader.ReadToEnd();
}
contents1 = contents1.Replace("CONTENTS", contents);
//contents = contents1 + contents ;
EmailSender es = new EmailSender();
es.Send(toEmail, subject, contents1);
ViewBag.Result = "Newsletter has been send.";
}
ModelState.Clear();
return(View(new NewsletterViewModel()));
}
return(View());
}
public ActionResult Newsletter(string message)
{
var userId = User.Identity.GetUserId();
var newsletter = _newsletterService.GetSingle(i => i.UserId == userId);
var newsletterVm = _mapper.Map <NewsletterViewModel>(newsletter);
var categories = _categoryService.GetAll();
var categoriesVm = _mapper.Map <List <CategoryViewModel> >(categories);
if (newsletterVm == null)
{
newsletterVm = new NewsletterViewModel
{
Categories = categoriesVm
};
}
else
{
newsletterVm.Categories = categoriesVm;
}
if (!string.IsNullOrEmpty(message))
{
Warning(message);
}
return(View(ProfileControllerAction.Newsletter, newsletterVm));
}
//
// GET: /Newsletter/
public ActionResult Index(NewsletterPage currentPage, HomePage homePage)
{
var model = new NewsletterViewModel(currentPage);
var contentLoader = ServiceLocator.Current.GetInstance <IContentLoader>();
var homepage = contentLoader.Get <HomePage>(ContentReference.StartPage);
if (homepage != null && homepage.Settings.NewsletterUnsubscribePage != null)
{
model.UnsubscribeUrl = ServiceLocator.Current.GetInstance <UrlResolver>().GetUrl(homepage.Settings.NewsletterUnsubscribePage);
if (model.UnsubscribeUrl.Contains("?"))
{
model.UnsubscribeUrl += "&email=%recipient%";
}
else
{
model.UnsubscribeUrl += "?email=%recipient%";
}
}
return(View("Newsletter1", model));
//return View("Index", currentPage");
}
public ActionResult Newsletter(string[] selectedCategories)
{
if (selectedCategories == null || !selectedCategories.Any())
{
return(RedirectToAction("Newsletter", routeValues: new { message = Messages.NewsletterSubscription }));
}
var categories = string.Join(",", selectedCategories);
var newletterVm = new NewsletterViewModel
{
Active = true,
Subscription = categories,
UserId = User.Identity.GetUserId()
};
var newsletter = _mapper.Map <NewsletterExtend>(newletterVm);
var userId = User.Identity.GetUserId();
var newsletterValue = _newsletterService.GetSingle(i => i.UserId == userId);
if (newsletterValue != null)
{
newsletterValue.Subscription = newletterVm.Subscription;
newsletterValue.Active = newletterVm.Active;
_newsletterService.Update(newsletterValue);
}
else
{
_newsletterService.Create(newsletter);
}
return(RedirectToAction(ProfileControllerAction.Index, routeValues: new { message = Messages.NewsletterSubscriptionConfirmation }));
}
public async Task <IActionResult> Details(Guid?id)
{
if (id == null)
{
return(RecordNotFound());
}
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var vm = NewsletterViewModel.Parse(getOperation.Result);
ViewData["Title"] = "Newsletter";
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "New", Controller = "Newsletters", Icon = "fa-search", Text = "Detail"
});
ViewData["BreadCrumbs"] = crumbs;
return(View(vm));
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id, Title, Description")] NewsletterViewModel vm)
{
if (ModelState.IsValid)
{
var getOperation = await _bo.ReadAsync((Guid)id);
if (!getOperation.Success)
{
return(OperationErrorBackToIndex(getOperation.Exception));
}
if (getOperation.Result == null)
{
return(RecordNotFound());
}
var result = getOperation.Result;
result.Title = vm.Title;
result.Description = vm.Description;
var updateOperation = await _bo.UpdateAsync(result);
if (!updateOperation.Success)
{
return(OperationErrorBackToIndex(updateOperation.Exception));
}
else
{
return(OperationSuccess("The record was successfuly updated"));
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> RegisterInNewsLetter(NewsletterViewModel viewModel)
{
if (ModelState.IsValid)
{
var user = await _uw.BaseRepository <Newsletter>().FindByIdAsync(viewModel.Email);
if (user == null)
{
await _uw.BaseRepository <Newsletter>().CreateAsync(new Newsletter(viewModel.Email));
await _uw.Commit();
TempData["notification"] = RegisterSuccess;
}
else
{
if (user.IsActive == true)
{
ModelState.AddModelError(string.Empty, $"شما با ایمیل '{viewModel.Email}' قبلا عضو خبرنامه شده اید.");
}
else
{
user.IsActive = true;
await _uw.Commit();
TempData["notification"] = RegisterSuccess;
}
}
}
return(PartialView("_RegisterInNewsLetter"));
}
public IActionResult ViewAll()
{
var model = new NewsletterViewModel();
model.Newsletters = _newsletterRepository.GetNewsletters();
return(View(model));
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListAsync();
if (!listOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var nListOperation = await _nbo.ListAsync();
if (!nListOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var ipListOperation = await _ipbo.ListAsync();
if (!ipListOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var list = new List <InterestPointNewsletterViewModel>();
foreach (var item in listOperation.Result)
{
if (!item.IsDeleted)
{
list.Add(InterestPointNewsletterViewModel.Parse(item));
}
}
var nList = new List <NewsletterViewModel>();
foreach (var item in nListOperation.Result)
{
if (!item.IsDeleted)
{
nList.Add(NewsletterViewModel.Parse(item));
}
}
var ipList = new List <InterestPointViewModel>();
foreach (var item in ipListOperation.Result)
{
if (!item.IsDeleted)
{
ipList.Add(InterestPointViewModel.Parse(item));
}
}
ViewData["Title"] = "Interest Point Newsletter";
ViewData["BreadCrumbs"] = GetCrumbs();
ViewData["DeleteHref"] = GetDeleteRef();
ViewBag.Newsletters = nList;
ViewBag.InterestPoints = ipList;
return(View(list));
}
public async Task <IActionResult> Create([Bind("ID,Firstname,Email")] NewsletterViewModel newsletterViewModel)
{
if (ModelState.IsValid)
{
_context.Add(newsletterViewModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(newsletterViewModel));
}
public ActionResult SubmitEmail(NewsletterViewModel model)
{
string redirectUrl =
string.Format(
"{0}#{1}",
Url.Action("Index"),
"Newsletter");
_newsletterService.SubscribeNewsletter(model.Email, _settings.BackOfficeUrl);
TempData["Result"] = "Obrigado por subscrever.";
return(new RedirectResult(redirectUrl));
}
public async Task <IActionResult> Create()
{
var nListOperation = await _nbo.ListAsync();
if (!nListOperation.Success)
{
return(OperationErrorBackToIndex(nListOperation.Exception));
}
var nList = new List <NewsletterViewModel>();
foreach (var n in nListOperation.Result)
{
if (!n.IsDeleted)
{
var nvm = NewsletterViewModel.Parse(n);
nList.Add(nvm);
}
ViewBag.Newsletters = nList.Select(ip => new SelectListItem()
{
Text = ip.Title, Value = ip.Id.ToString()
});
}
var ipListOperation = await _ipbo.ListAsync();
if (!ipListOperation.Success)
{
return(OperationErrorBackToIndex(nListOperation.Exception));
}
var ipList = new List <InterestPointViewModel>();
foreach (var ip in ipListOperation.Result)
{
if (!ip.IsDeleted)
{
var ipvm = InterestPointViewModel.Parse(ip);
ipList.Add(ipvm);
}
ViewBag.InterestPoints = ipList.Select(ip => new SelectListItem()
{
Text = ip.Name, Value = ip.Id.ToString()
});
}
ViewData["Title"] = "New Interest Point Newsletter";
var crumbs = GetCrumbs();
crumbs.Add(new BreadCrumb()
{
Action = "New", Controller = "InterestPointNewsletters", Icon = "fa-plus", Text = "New"
});
ViewData["BreadCrumbs"] = crumbs;
return(View());
}
public async Task <ActionResult> NView(string viewName, string newsletterKey = null, string editionKey = null, string articleKey = null)
{
var model = new NewsletterViewModel()
{
Title = viewName
};
model.NewsletterListings = await Repository.GetNewslettersAsync();
// Newsletters are only cached for 2 minutes so we don't have to take into account updates to the mega-menu(ministries), sidebar(resource links, top sectors), Live Webcast)
if (NotModifiedSince(Enumerable.Max(model.NewsletterListings, n => n.Timestamp)))
{
return(StatusCode(StatusCodes.Status304NotModified));
}
if (newsletterKey != null)
{
model.Newsletter = model.NewsletterListings.SingleOrDefault(x => x.Key == newsletterKey);
if (model.Newsletter == null)
{
return(await SearchNotFound());
}
if (editionKey != null)
{
string newsHostUri = new Uri(Configuration["NewsHostUri"]).ToString().TrimEnd('/');
if (articleKey == null)
{
model.Edition = await Repository.GetEditionAsync(newsletterKey, editionKey);
if (model.Edition == null)
{
return(await SearchNotFound());
}
model.Edition.HtmlBody = model.Edition.HtmlBody.Replace("<!--REPLACE-WITH-PUBLIC-URL-->", newsHostUri);
}
else
{
model.Article = await Repository.GetArticleAsync(newsletterKey, editionKey, articleKey);
if (model.Article == null)
{
return(await SearchNotFound());
}
model.Article.HtmlBody = model.Article.HtmlBody.Replace("<!--REPLACE-WITH-PUBLIC-URL-->", newsHostUri);
}
}
}
await LoadAsync(model);
return(View(viewName, model));
}
public IActionResult Index()
{
var model = new NewsletterViewModel();
model.Newsletters = _newsletterRepository.GetNewsletters();
//var items = from w in _warningRepository.GetWarnings().Where(x => (model.IsAllBrandsSelected == true || x.BrandId == model.BrandId))
// join b in _brandRepository.GetBrands() on w.BrandId equals b.Id
// select new WarningViewModel
// var model = from u in _customerRepository.GetAll().Where(x => x.FirstName == user.UserFirstname))
return(View(model));
}
public ActionResult Sample()
{
var viewModel = new NewsletterViewModel()
{
Items =
{
Convert(EntityGenerator.GenerateHost()),
Convert(EntityGenerator.GenerateTrip(null), "Test host name"),
Convert(EntityGenerator.GenerateTrip(null), "Test host name"),
Convert(EntityGenerator.GenerateHost()),
}
};
return View("Newsletter", viewModel);
}
public ActionResult Display(string id)
{
var newsletter = _newsletterService.GetById(id);
if (newsletter == null)
return RedirectToAction("list");
var contents = _newsletterService.GetContents(newsletter);
var viewModel = new NewsletterViewModel
{
Items = contents.Select(item => Convert(item)).ToList()
};
return View("Newsletter", viewModel);
}
public async Task <IActionResult> Send([FromBody] NewsletterViewModel model)
{
var combinedUsers = await _repo.Newsletters.Where(x => x.IsSubsribed).Select(x => x.Email).ToListAsync();
try
{
await _email.SendEmailToAllAsync(combinedUsers, model.Subject, model.Message);
return(NoContent());
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
public async System.Threading.Tasks.Task <ActionResult> NewsletterSignUp(NewsletterViewModel model)
{
IMailChimpManager mailChimpManager = new MailChimpManager("7c9f307bfe083c6152698211349bf9a8-us20");
var listId = "a0df8aa760";
var member = new Member {
EmailAddress = model.Email, StatusIfNew = Status.Subscribed
};
member.MergeFields.Add("FNAME", model.FirstName);
member.MergeFields.Add("LNAME", model.LastName);
await mailChimpManager.Members.AddOrUpdateAsync(listId, member);
return(Content("<h4 class='m-0'>Thank you for your subscription!</h4>", "text/html"));
}
public ActionResult Create([FromBody] NewsletterViewModel vm)
{
var Newsletter = new Newsletter(vm.Description, vm.Title);
var res = _bo.Create(Newsletter);
if (!res.Success)
{
return(new ObjectResult(HttpStatusCode.InternalServerError));
}
else
{
return(new ObjectResult(HttpStatusCode.OK));
}
}
public async Task <IActionResult> Create([Bind("Title, Description")] NewsletterViewModel vm)
{
if (ModelState.IsValid)
{
var quiz = vm.ToNewsletter();
var createOperation = await _bo.CreateAsync(quiz);
if (!createOperation.Success)
{
return(OperationErrorBackToIndex(createOperation.Exception));
}
return(OperationSuccess("The record was successfuly created"));
}
return(View(vm));
}
public async Task <IActionResult> SignUp(NewsletterViewModel model)
{
var user = new ApplicationUser {
UserName = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
return(View());
}
}
public ActionResult <List <NewsletterViewModel> > List()
{
var res = _bo.List();
if (!res.Success)
{
return(new ObjectResult(HttpStatusCode.InternalServerError));
}
var list = new List <NewsletterViewModel>();
foreach (var item in res.Result)
{
list.Add(NewsletterViewModel.Parse(item));
}
return(list);
}
public ActionResult <NewsletterViewModel> Get(Guid id)
{
var res = _bo.Read(id);
if (res.Success)
{
if (res.Result == null)
{
return(NotFound());
}
var vm = NewsletterViewModel.Parse(res.Result);
return(vm);
}
else
{
return(new ObjectResult(HttpStatusCode.InternalServerError));
}
}
public void Envoi(NewsletterViewModel nvm)
{
var inscrits = _db.NewsletterInscrits.Select(i => i.Utilisateurs.Identites.AspNetUsers.Email);
string sujet = nvm.Sujet;
string body;
string lien = nvm.Lien;
foreach (var item in inscrits)
{
var user = _db.Identites.Where(i => i.AspNetUsers.Email == item).Select(i => new { i.Nom, i.Prenom }).FirstOrDefault();
body = "Bonjour, " + user.Prenom + " " + user.Nom + "\n" +
nvm.Body + "\nProduit mis en avant cette semaine : \n " + lien +
"\nPour vous désinscrire : http://localhost:56706/Areas/Newsletter/Desinscrire?id=" + item;
EnvoiMail(item, sujet, body);
}
}
private async Task <NewsletterViewModel> GetBaseModel(string newsletterKey = null)
{
var model = new NewsletterViewModel();
await LoadAsync(model);
model.NewsletterListings = await Repository.GetNewslettersAsync();
if (newsletterKey != null)
{
model.Newsletter = model.NewsletterListings.SingleOrDefault(x => x.Key == newsletterKey);
if (model.Newsletter == null)
{
return(null);
}
}
return(model);
}
public async Task <IActionResult> Index()
{
var listOperation = await _bo.ListAsync();
if (!listOperation.Success)
{
return(OperationErrorBackToIndex(listOperation.Exception));
}
var list = new List <NewsletterViewModel>();
foreach (var item in listOperation.Result)
{
if (!item.IsDeleted)
{
list.Add(NewsletterViewModel.Parse(item));
}
}
ViewData["Title"] = "Newsletters";
ViewData["BreadCrumbs"] = GetCrumbs();
ViewData["DeleteHref"] = GetDeleteRef();
return(View(list));
}
public ActionResult Update([FromBody] NewsletterViewModel vm)
{
var currentResult = _bo.Read(vm.Id);
if (!currentResult.Success)
{
return(new ObjectResult(HttpStatusCode.InternalServerError));
}
var current = currentResult.Result;
if (current == null)
{
return(NotFound());
}
if (current.Description == vm.Description && current.Title == vm.Title)
{
return(new ObjectResult(HttpStatusCode.NotModified));
}
if (current.Description != vm.Description)
{
current.Description = vm.Description;
}
if (current.Title != vm.Title)
{
current.Title = vm.Title;
}
var updateResult = _bo.Update(current);
if (!updateResult.Success)
{
return(new ObjectResult(HttpStatusCode.InternalServerError));
}
return(Ok());
}
public ActionResult NewsletterForm()
{
var model = new NewsletterViewModel();
return(PartialView("_NewsletterFormPartial", model));
}
public async Task <IViewComponentResult> InvokeAsync(NewsletterViewModel model)
{
var _model = model ?? new NewsletterViewModel();
return(View(_model));
}
