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);
}
