Ejemplo n.º 1
0
        public async Task <ActionResult> CheckEMail(CheckEMailViewModel model)
        {
            var user = UserManager.FindById(model.UserId);

            if (user != null)
            {
                // der Benutzer hat seine E-Mail Adresse nicht verändert
                if (user.Email.ToLower().Equals(model.EMail.ToLower()))
                {
                    // es passiert nix
                }
                else
                {
                    // der Benutzer hat seine E-Mail Adresse verändert
                    // prüfen, ob es diese Adresse bereits gibt
                    var user2 = UserManager.FindByEmail(model.EMail);
                    if (user2 != null)
                    {
                        ModelState.AddModelError("EMail", "Es existiert bereits ein Benutzerkonto für diese E-Mail Adresse");
                        return(View(model));
                    }
                    // neue E-Mail Adresse setzen
                    UserManager.SetEmail(model.UserId, model.EMail);
                }


                // Jetzt eine neue Mail senden
                string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);

                var mailModel = new ConfirmEmailMailModel
                {
                    User  = user,
                    Token = code
                };

                new MailController().VerfiyEMail(mailModel).Deliver();

                return(RedirectToAction("RegisterSuccess", model));
            }
            else
            {
                ModelState.AddModelError("EMail", "Das Benutzerkonto existiert nicht!");
                return(View(model));
            }
        }
Ejemplo n.º 2
0
        public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            if (string.IsNullOrEmpty(model.Email) && string.IsNullOrEmpty(model.Password))
            {
                return(RedirectToAction("Login"));
            }

            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            // Standard: 1 E-Mail Adresse = Benutzername
            var user = await UserManager.FindByEmailAsync(model.Email);

            // Abwärtskompatibel: Benutzername
            if (user == null)
            {
                user = await UserManager.FindByNameAsync(model.Email);
            }
            // Ausnahme: In Kontakten suchen => bisher noch nicht


            if (user == null)
            {
                ModelState.AddModelError("", "Falscher Benutzername oder Passwort.");
                logger.WarnFormat("Invalid login attempt: {0}", model.Email);
                return(View(model));
            }

            // Require the user to have a confirmed email before they can log on.
            if (user.Registered > new DateTime(2015, 7, 26))
            {
                if (!await UserManager.IsEmailConfirmedAsync(user.Id))
                {
                    var model2 = new CheckEMailViewModel();

                    model2.EMail  = user.Email;
                    model2.UserId = user.Id;

                    return(View("CheckEMail", model2));
                }
            }
            else
            {
                // Reparatur alter Konten
                //
                if (!user.EmailConfirmed)
                {
                    user.EmailConfirmed = true;
                    user.ExpiryDate     = null;
                    user.Remark         = String.Empty;
                    user.Group          = String.Empty;
                    user.Curriculum     = String.Empty;
                    user.Email          = string.IsNullOrEmpty(user.Email) ? String.Empty : user.Email.ToLower();
                    await UserManager.UpdateAsync(user);
                }
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(user.UserName, model.Password, model.RememberMe, shouldLockout : false);

            switch (result)
            {
            case SignInStatus.Success:
                await UserManager.StoreLogInAsync(user.Id);

                return(RedirectToLocal(returnUrl));

            case SignInStatus.LockedOut:
                return(View("Lockout"));

            case SignInStatus.RequiresVerification:
                return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));

            case SignInStatus.Failure:
            default:
                ModelState.AddModelError("", "Falscher Benutzername oder Passwort.");
                return(View(model));
            }
        }