public async Task <IActionResult> Delete(DeleteAccountModel model) { if (ModelState.IsValid) { var userLoggedIn = await _userManager.GetUserAsync(User); if (userLoggedIn.Email == model.Email) { var passwordValidateResult = await _userManager.CheckPasswordAsync(userLoggedIn, model.Password); if (passwordValidateResult) { await _signInManager.SignOutAsync(); await _userManager.DeleteAsync(userLoggedIn); return(RedirectToAction("Index", "Home")); } ModelState.AddModelError(string.Empty, "Incorrect password"); } ModelState.AddModelError(string.Empty, "The email you input is not equal to your own account"); } return(View(model)); }
public async Task <IActionResult> DeleteAccount(DeleteAccountModel model) { var currentUser = await this.GetTheCurrentUserAsync(); if (currentUser == null) { this._logger.LogWarning($"Current user - NOT FOUND"); return(NotFound()); } var currentUserPass = await this._userManager .CheckPasswordAsync(currentUser, model.Password); if (currentUserPass && model.IAgree) { await this._usersService.DeleteAccountAsync(currentUser); await this._signInManager.SignOutAsync(); this._logger.LogInformation($"User with id {currentUser.Id} has been marked as deleted and signed out "); return(this.RedirectToAction("Index", "Home")); } else { this._logger.LogWarning($""); return(this.View(model)); } }
public async Task <IActionResult> DeleteAccountAsync([FromBody] DeleteAccountModel model) { var user = await _userManager.FindByNameAsync(model.Email); if (user == null) { return(Problem("Utilizatorul nu a fost sters")); } if (!await _userManager.CheckPasswordAsync(user, model.Password)) { return(Problem("Utilizatorul nu a fost sters")); } var result = await _userManager.DeleteAsync(user); var userId = await _userManager.GetUserIdAsync(user); if (!result.Succeeded) { throw new InvalidOperationException($"Unexpected error occurred deleting user with ID '{userId}'."); } await _signInManager.SignOutAsync(); return(Ok()); }
public IActionResult DeleteAccount(DeleteAccountModel model) { if (ModelState.IsValid) { if (!IsLoged) { return(RedirectToAction("Index", "Home")); } try { if (Int32.TryParse(User.FindFirstValue(ClaimTypes.NameIdentifier), out int aId)) { var result = DataStore.Account.DeleteAccount((int)aId, model.Password); if (result) { LogoutApplication(); return(RedirectToAction("Index", "Home")); } else { ModelState.AddModelError("DeleteAccountMassege", "Delete account failed. Incorrect password."); return(View()); } } } catch (Exception) { } } return(View()); }
public async Task <IHttpActionResult> Delete(DeleteAccountModel userPass) { ApplicationUser user = await UserManager.FindAsync(User.Identity.GetUserName(), userPass.userPass); if (user != null) { await UserManager.DeleteAsync(user); NotesProvider.DeleteAll(User.Identity.GetUserId()); return(Ok()); } return(BadRequest("ERROR")); }
public ActionResult DeleteAccount(DeleteAccountModel model) { if (ModelState.IsValid) { //We need to pull the user's current email to access the account string CurrentEmail = RetrieveEmail(); //Calls AccountDelete from the AccountProcessor class in the DatabaseBusinessLogic folder if (AccountDelete(CurrentEmail, model.Password) == 1) { FormsAuthentication.SignOut(); return(RedirectToAction("Index", "Home")); } else { ModelState.AddModelError("", "Error deleting account"); } } return(View(model)); }
public async Task <IActionResult> Delete(DeleteAccountModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var userIdVal = User.FindFirst(ClaimTypes.NameIdentifier)?.Value; if (string.IsNullOrEmpty(userIdVal)) { return(BadRequest("Invalid attempt")); } int userId = Convert.ToInt32(userIdVal); var response = await userService.DeleteAsync(userId, model.Password); if (!response.Success) { return(BadRequest(response.Message)); } return(Ok(true)); }
public async Task <ActionResult> Delete(DeleteAccountModel model) { if (!ModelState.IsValid) { return(View()); } if (model.Email.ToLower().Equals(CurrentUser.Email.ToLower())) { ApplicationUser user = await userManager.FindByNameAsync(CurrentUser.Email); if (user == null) { throw new ObjectNotFoundException(); } var result = await userManager.DeleteAsync(user); if (result == IdentityResult.Success) { return(RedirectToAction("LogOut", "Auth")); } } return(View()); }
public async Task<IActionResult> DeleteAccount(DeleteAccountModel model) { if(!ModelState.IsValid) { TempData[TempDataKeys.HtmlMessage] = ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage).AsEnumerable().Reverse().Aggregate((a, b) => a + "<br />" + b); return RedirectToAction(nameof(DeleteAccount)); } if (!model.Username.Equals(User.Identity.Name)) { ModelState.AddModelError(string.Empty, "Invalid Username."); } var user = await _accountRepository.GetUserFromContextAsync(User); if (!await _accountRepository.IsPasswordValidAsync(user, model.Password)) { ModelState.AddModelError(string.Empty, "Invalid Password."); } if(user.TwoFactorEnabled) { if (!await _accountRepository.TwoFactorCodeValidAsync(user, model.TwoFactorCode)) { ModelState.AddModelError(string.Empty, "Invalid Two-Factor Code."); } } // Check model state again. if (!ModelState.IsValid) { TempData[TempDataKeys.HtmlMessage] = ModelState.Values.SelectMany(v => v.Errors).Select(v => v.ErrorMessage).AsEnumerable().Aggregate((a, b) => a + "<br />" + b); return RedirectToAction(nameof(DeleteAccount)); } await _accountRepository.SignOutAsync(); await _accountRepository.DeleteUserAccountAsync(user); TempData[TempDataKeys.Redirect] = RedirectPurpose.AccountDeleted; return RedirectToAction(nameof(AuthController.Login), GoliathControllers.AuthController); }
public ActionResult DeleteAccount(DeleteAccountModel model) { if (ModelState.IsValid) { if (model.UserId == 1) { ModelState.AddModelError("DeleteAccount", "Cannot delete 1st administrator."); } else { using (var context = new UsersContext()) { var user = context.UserProfiles.SingleOrDefault(u => u.UserId == model.UserId); if (user != null) { Membership.DeleteUser(user.UserName, true); ViewData["Message"] = "User has been successfully deleted."; } } } } FormToViewData(); return(View("Manage")); }
public IActionResult DeleteAccount() { var deleteModel = new DeleteAccountModel(); return(this.View(deleteModel)); }
public IActionResult DeleteAccount() { DeleteAccountModel model = new DeleteAccountModel(); return(View(model)); }
public HttpResponseMessage DeleteAccount(DeleteAccountModel model) { HttpResponseMessage resp = new HttpResponseMessage(); IEnumerable <User> users = this.usersManager.GetItems() as IEnumerable <User>; IEnumerable <Claim> claims = (HttpContext.Current.User as ClaimsPrincipal).Claims; string userEmail = claims.Where(c => c.Type == ClaimTypes.Email).Select(c => c.Value).FirstOrDefault(); if (!string.IsNullOrEmpty(userEmail)) { User user = users.Where(u => u.Email == userEmail).FirstOrDefault(); if (user != null) { if (model.IsExternal) { this.usersManager.DeleteItem(user); this.usersManager.SaveChanges(); resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = true })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } else { string hashedPassword = PasswordHelper.CreatePasswordHash(model.Password, user.Salt); if (user.HashedPassword == hashedPassword) { this.usersManager.DeleteItem(user); this.usersManager.SaveChanges(); resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = true })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } else { resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = false, State = "incorrect_password" })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } } } else { resp.Content = new StringContent(JsonConvert.SerializeObject(new ChangeGeneralResponseViewModel() { IsSuccessful = false })); resp.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json"); } } return(resp); }