public ActionResult YouTubeAlertUnsubscribe(string email, string guid)
        {
            email = HttpUtility.UrlDecode(email);
            guid  = HttpUtility.UrlDecode(guid);

            using (var db = new SiteDbContext())
            {
                var ifEmailExist = db.YouTubeAlertRegistration
                                   .Any(r => r.Email.Equals(email));

                if (ifEmailExist)
                {
                    var userData = db.YouTubeAlertRegistration.Where(r => r.Email.Equals(email)).FirstOrDefault();
                    if (userData.Email == email && userData.SecretKey == guid)
                    {
                        YouTubeAlertRegistration newsletterAccount = db.YouTubeAlertRegistration.Find(userData.Id);
                        db.Entry(newsletterAccount).State = System.Data.Entity.EntityState.Deleted;
                        db.SaveChanges();

                        ViewBag.Message = "Vous êtes maintenant désinscrit aux alertes YouTube de Gamers Addict.";
                    }
                    else
                    {
                        ViewBag.Message = "Erreur dans clef secrète.";
                    }
                }
                else
                {
                    ViewBag.Message = "Vous n'êtes pas inscrit à la newsletter, désinscription impossible.";
                }
            }
            return(View());
        }
        public ActionResult YouTubeAlertSubscribe(YouTubeAlertRegistration model)
        {
            using (var db = new SiteDbContext())
            {
                var ifEmailExist = db.YouTubeAlertRegistration
                                   .Any(r => r.Email.Equals(model.Email));

                if (!ifEmailExist)
                {
                    YouTubeAlertRegistration newRegistration = new YouTubeAlertRegistration
                    {
                        Email     = model.Email,
                        SecretKey = Guid.NewGuid().ToString()
                    };

                    db.YouTubeAlertRegistration.Add(newRegistration);
                    db.SaveChanges();

                    return(Json("Inscription effectuée !", JsonRequestBehavior.AllowGet));
                }
                else
                {
                    return(Json("L'adresse email est déjà inscrite !", JsonRequestBehavior.AllowGet));
                }
            }
        }
        public ActionResult ChangeEmail(ChangeEmailViewModel model)
        {
            if (ModelState.IsValid)
            {
                //Update Account
                var context = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
                ApplicationUserManager _userManager = new ApplicationUserManager(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(context));
                var user = _userManager.FindByName(User.Identity.Name);

                var oldEmail = user.Email;
                user.Email = model.Email;
                _userManager.Update(user);
                HttpContext.GetOwinContext().Get <ApplicationDbContext>().SaveChanges();

                //Update Newsletter
                using (var db = new SiteDbContext())
                {
                    var ifEmailExist = db.NewsletterRegistration
                                       .Any(r => r.Email.Equals(oldEmail));

                    if (ifEmailExist)
                    {
                        NewsletterRegistration newsletterRegistration = db.NewsletterRegistration
                                                                        .Where(r => r.Email == oldEmail)
                                                                        .Select(r => r).FirstOrDefault();

                        newsletterRegistration.Email = model.Email;

                        db.Entry(newsletterRegistration).State = System.Data.Entity.EntityState.Modified;
                        db.SaveChanges();
                    }
                }

                //Update YouTube Alert
                using (var db = new SiteDbContext())
                {
                    var ifEmailExist = db.YouTubeAlertRegistration
                                       .Any(r => r.Email.Equals(oldEmail));

                    if (ifEmailExist)
                    {
                        YouTubeAlertRegistration youTubeAlertRegistration = db.YouTubeAlertRegistration
                                                                            .Where(r => r.Email == oldEmail)
                                                                            .Select(r => r).FirstOrDefault();

                        youTubeAlertRegistration.Email = model.Email;

                        db.Entry(youTubeAlertRegistration).State = System.Data.Entity.EntityState.Modified;
                        db.SaveChanges();
                    }
                }

                return(RedirectToAction("Index", new { Message = "Adresse Email modifier avec succès !" }));
            }

            return(View(model));
        }
Beispiel #4
0
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                if (!model.CharteAccepted)
                {
                    ModelState.AddModelError("", "Vous n'avez pas accepté les conditions d'utilisation.");
                    return(View(model));
                }

                var user = new ApplicationUser {
                    UserName = model.UserName, Email = model.Email, RegistrationDate = DateTime.Now, LastLoginDate = DateTime.Now
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                if (result.Succeeded)
                {
                    if (model.MailSubscription)
                    {
                        using (var db = new SiteDbContext())
                        {
                            YouTubeAlertRegistration newRegistration = new YouTubeAlertRegistration
                            {
                                Email     = model.Email,
                                SecretKey = Guid.NewGuid().ToString()
                            };

                            db.YouTubeAlertRegistration.Add(newRegistration);
                            db.SaveChanges();
                        }
                    }

                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    return(RedirectToAction("Index", "Home"));
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
        //
        // GET: /Manage/ChangeYouTubeAlert
        public ActionResult ChangeYouTubeAlert()
        {
            using (var db = new SiteDbContext())
            {
                //Get Username
                var pseudo = User.Identity.GetUserName();

                //Get Email
                var applicationDbContext = HttpContext.GetOwinContext().Get <ApplicationDbContext>();
                var email = applicationDbContext.Users
                            .Where(r => r.UserName == pseudo)
                            .Select(r => r.Email).ToArray()[0];

                ViewBag.email = email;

                //Verify if is register
                var ifEmailExist = db.YouTubeAlertRegistration
                                   .Any(r => r.Email.Equals(email));

                if (ifEmailExist)
                {
                    var userData = db.YouTubeAlertRegistration.Where(r => r.Email.Equals(email)).FirstOrDefault();
                    ViewBag.register  = "true";
                    ViewBag.secretKey = userData.SecretKey;

                    return(View());
                }
                else
                {
                    ViewBag.register = "false";
                    YouTubeAlertRegistration newsletterModel = new YouTubeAlertRegistration();
                    newsletterModel.Email = email;

                    return(View(newsletterModel));
                }
            }
        }