public async Task<IActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.AddPasswordAsync(user, model.NewPassword);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToAction(nameof(Index), new { Message = ManageMessageId.SetPasswordSuccess });
                }
                AddErrors(result);
                return View(model);
            }
            return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error });
        }
Beispiel #2
0
        public async Task<ActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
                if (result.Succeeded)
                {
                    var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                    if (user != null)
                    {
                        await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                    }
                    return RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess });
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        public async Task<ActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
                if (result.Succeeded)
                {
                    var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                    if (user != null)
                    {
                        await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                    }
                    return RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess });
                }
                AddErrors(result);
            }

            // Si llegamos a este punto, es que se ha producido un error, volvemos a mostrar el formulario
            return View(model);
        }
Beispiel #4
0
        public async Task <IActionResult> ResetPasswordConfirm([FromQuery] string UserName, [FromQuery] string Token, SetPasswordViewModel viewModel)
        {
            if (ModelState.IsValid)
            {
                if (string.IsNullOrEmpty(UserName) || string.IsNullOrEmpty(Token))
                {
                    return(NotFound());
                }

                var user = await _userManager.FindByNameAsync(UserName);

                var result = await _userManager.ResetPasswordAsync(user, Token, viewModel.Password);

                if (result.Succeeded)
                {
                    ViewData["UserName"]         = UserName;
                    ViewData["Token"]            = Token;
                    ViewBag.SuccessResetPassword = true;
                    return(View());
                }
                else
                {
                    ViewData["UserName"]         = UserName;
                    ViewData["Token"]            = Token;
                    ViewBag.SuccessResetPassword = false;
                    ModelState.AddModelError("", "خطا در تغییر رمز عبور");
                    return(View(viewModel));
                }
            }
            else
            {
                ViewData["UserName"]         = UserName;
                ViewData["Token"]            = Token;
                ViewBag.SuccessResetPassword = false;
                return(View(viewModel));
            }
        }
		public ActionResult SetPassword(SetPasswordViewModel setPasswordViewModel)
		{
			if(!this.ValidateAndAppendMessages(setPasswordViewModel))
			{
				return View(new SetPasswordViewModel { AuthToken = setPasswordViewModel.AuthToken });
			}

			// Check if Auth Token is Expired
			if (this.UserLoginService.AuthTokenIsExired(setPasswordViewModel.AuthToken))
			{
				return this.Issue404();
			}

			using (var unitOfWork = this.UnitOfWorkFactory.NewUnitOfWork())
			{
				try
				{
					this.UserLoginService.SetPasswordUsingAuthToken(setPasswordViewModel.AuthToken, setPasswordViewModel.Password);
					unitOfWork.Commit();

					this.ForwardMessage(new SuccessMessage { Text = "Your password has been reset.  You may now login using your new password." });

					return RedirectToAction("login");
				}
				catch (Exception ex)
				{
					this.LogHandledException(ex);
					unitOfWork.Rollback();

					this.AppendMessage(new ErrorMessage { Text = GenericMessages.ErrorMessage });
				}
			}

			return View();
		}
        public async Task<ActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var result = await UserManager.AddPasswordAsync(User.Identity.GetUserId(), model.NewPassword);
                if (result.Succeeded)
                {
                    var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
                    if (user != null)
                    {
                        await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                    }
                    return RedirectToAction("Index", new { Message = ManageMessageId.SetPasswordSuccess });
                }
                AddErrors(result);
            }

            // Это сообщение означает наличие ошибки; повторное отображение формы
            return View(model);
        }
        public async Task<ActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (this.ModelState.IsValid)
            {
                var result = await this.UserManager.AddPasswordAsync(this.User.Identity.GetUserId(), model.NewPassword);
                if (result.Succeeded)
                {
                    var user = await this.UserManager.FindByIdAsync(this.User.Identity.GetUserId());
                    if (user != null)
                    {
                        await this.SignInManager.SignInAsync(user, false, false);
                    }
                    return this.RedirectToAction("Profile", new { Message = ManageMessageId.SetPasswordSuccess });
                }
                this.AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return this.View(model);
        }