public async Task <ActionResult> DeleteAccount(DeleteAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = UserManager.FindById(User.Identity.GetUserId <int>());
if (UserManager.CheckPassword(user, model.Password))
{
// Delete UserDetails (connection with User [FK])
user.RemoveUserDetails();
IdentityResult result = await UserManager.DeleteAsync(user);
if (result.Succeeded)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
AddErrors(result);
model.Checked = false;
return(View(model));
}
else
{
IdentityResult uncorrectPassword = IdentityResult.Failed("You entered a wrong password.");
AddErrors(uncorrectPassword);
model.Checked = false;
return(View(model));
}
}
public async Task <IActionResult> DeleteAccount2step(DeleteAccountViewModel model)
{
ViewBag.Token = model.Token;
var userIsAuth = HttpContext.User.Identity.IsAuthenticated;
if (!userIsAuth)
{
ModelState.AddModelError("Error", "You need to be log in.");
return(PartialView("~/Views/Auth/DeleteAccountConfirmation.cshtml"));
}
var responseFromApi = await _apiService.DeleteAccountProcess(model, "2step");
if (!responseFromApi.Success)
{
ModelState.AddModelError("Error", responseFromApi.Messages.First());
return(PartialView("~/Views/Auth/DeleteAccountConfirmation.cshtml"));
}
if (responseFromApi.Success)
{
_encryptionService.RemoveEncryptionKey(HttpContext.User.Identity.Name);
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
TempData["logoutMessage"] = "You account has been deleted.";
}
return(RedirectToAction(controllerName: "Home", actionName: "Index"));
}
public async Task <IActionResult> Delete([FromBody] DeleteAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(Ok());
}
var user = await _userManager.FindByIdAsync(User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value);
if (user == null)
{
return(Ok(new { error = "User not found.", error_description = $"Unable to load user with ID '{_userManager.GetUserId(User)}'." }));
}
if (user.UserName != model.UserName)
{
return(Ok());
}
await _signInManager.SignOutAsync();
_userContext.RemoveUserGuidCookies();
var deleteUserResult = await _userManager.DeleteAsync(user);
if (!deleteUserResult.Succeeded)
{
AddErrors(deleteUserResult);
return(Ok());
}
_logger.LogInformation("User deleted and logged out.");
return(Ok(new { token = await _userContext.GenerateToken(_userContext.NewGuestUser()) }));
}
public async Task <IActionResult> Deletes([FromBody] DeleteAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(BadRequest(Errors.AddErrorToModelState("user_search_failure", "Could not find user in database.", ModelState)));
}
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
var temp = _appDbContext.Users.First(u => u.Identity.Email.Equals(model.Email));
_appDbContext.Users.Remove(temp);
await _userManager.DeleteAsync(user);
await _appDbContext.SaveChangesAsync();
return(new OkObjectResult("Account Deleted"));
}
else
{
return(BadRequest(Errors.AddErrorToModelState("user_search_failure", "Password is invalid", ModelState)));
}
}
public ActionResult DeleteAccount(DeleteAccountViewModel user)
{
if (!ModelState.IsValid)
{
return(View(user));
}
if (user.password != user.ConfirmPassword)
{
ModelState.AddModelError("", "Passwords do not match");
return(View(user));
}
var result = m.AccountDelete(user);
if (result)
{
return(RedirectToAction("Login", "Home"));
}
else
{
ModelState.AddModelError("", "Invalid Password");
return(View(user));
}
}
public ActionResult DeleteAccount(DeleteAccountViewModel model)
{
// require users to enter their password in order to execute account delete action
var user = UserManager.Find(User.Identity.Name, model.CurrentPassword);
if (user != null)
{
// execute delete action
if (UserHelper.DeleteUser(User.Identity.Name))
{
// delete email address and set password to something random
UserManager.SetEmail(User.Identity.GetUserId(), null);
string randomPassword = "";
using (SHA512 shaM = new SHA512Managed())
{
randomPassword = Convert.ToBase64String(shaM.ComputeHash(Encoding.UTF8.GetBytes(Path.GetRandomFileName())));
}
UserManager.ChangePassword(User.Identity.GetUserId(), model.CurrentPassword, randomPassword);
AuthenticationManager.SignOut();
return(View("~/Views/Account/AccountDeleted.cshtml"));
}
// something went wrong when deleting user account
return(View("~/Views/Errors/Error.cshtml"));
}
return(RedirectToAction("Manage", new { message = ManageMessageId.WrongPassword }));
}
public ActionResult DeleteAccount(DeleteAccountViewModel model)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
AuthenticationManager.SignOut();
// execute delete action
if (Whoaverse.Utils.User.DeleteUser(User.Identity.Name))
{
// deletion executed without errors
return(View("~/Views/Account/AccountDeleted.cshtml"));
}
else
{
return(View("~/Views/Errors/Error.cshtml"));
}
}
else
{
return(View("~/Views/Errors/Error.cshtml"));
}
}
else
{
return(View("~/Views/Errors/Error.cshtml"));
}
}
public IActionResult GetAccount(string CustomerID)
{
DeleteAccountViewModel deleteAccountViewModel = null;
Customer cust = _customerRepository.GetCustomer(Convert.ToInt32(CustomerID));
Account acc = _accountRepository.GetAccountByCustomerID(Convert.ToInt32(CustomerID));
if (cust != null && acc != null)
{
string name = cust.Name;
int accountID = acc.AccountID;
deleteAccountViewModel = new DeleteAccountViewModel()
{
CustomerName = name, AccountID = accountID
};
}
else
{
ViewData["DeleteSuccess"] = "false";
deleteAccountViewModel = new DeleteAccountViewModel()
{
CustomerName = "No Account", AccountID = 000000000
};
}
return(View("DeleteAccount", deleteAccountViewModel));
}
public async Task <JsonNetResult> DeleteMemberAccount(DeleteAccountViewModel model)
{
var response = new GetDeleteAccountResponse();
if (string.IsNullOrWhiteSpace(model.Language) || string.IsNullOrEmpty(model.Language))
{
response.Success = false;
response.ResponseData = null;
response.Message = "An error has occured.";
if (_logger.IsErrorEnabled)
{
_logger.Error("Language is null or empty in DeleteMemberAccount POST action of surface controller MyAccountController");
}
return(ReturnJsonResponse(response));
}
var culture = GetCultureInformationForLanguage(model.Language);
string locale = culture.Locale;
if (!ModelState.IsValid)
{
response.Success = false;
response.Message = GetErrorsFromModelState(ModelState).FirstOrDefault();
return(ReturnJsonResponse(response));
}
var result = await _profileService.DeleteAccount(model.Email, locale, model.Reason);
if (result == null)
{
response.Success = false;
response.ResponseData = null;
response.Message = "An error has occured.";
}
if (result.Status != (int)ResponseStatus.Success)
{
response.Success = false;
response.ResponseData = model;
response.Message = result.Message;
return(ReturnJsonResponse(response));
}
bool isDeleted = _umbracoHelper.DeleteUmbracoMember(model.Email);
if (!isDeleted)
{
response.Success = false;
response.Message = "An error has occured.";
return(ReturnJsonResponse(response));
}
Logout();
response.Success = true;
response.Message = result.Message;
return(ReturnJsonResponse(response));
}
public AccountViewModel()
{
CreateAccountViewModel = new CreateAccountViewModel();
DeleteAccountViewModel = new DeleteAccountViewModel();
UpdateAccountView = new UpdateAccountViewModel();
GetAccountViewModel = new GetAccountViewModel();
GetAccountCollectionViewModel = new GetAccountCollectionViewModel();
}
public IActionResult DeleteAccount()
{
var model = new DeleteAccountViewModel {
StatusMessage = StatusMessage
};
return(View(model));
}
public ActionResult DeleteAccount(DeleteAccountViewModel model)
{
if (Session["UserID"] == null)
{
return(RedirectToAction("Login"));
}
UserModel user;
if (model.ID == 0)
{
user = userService.GetByUserName(Session["Username"].ToString());
}
else
{
user = userService.GetByID(model.ID);
}
if (user == null)
{
ViewBag.Status = false;
ModelState.AddModelError("", "User not found");
return(View());
}
else if (Session["Role"].ToString() == "Admin")
{
if (userService.Delete(user))
{
TempData["Status"] = true;
TempData["Message"] = "User Account successfully deleted";
return(RedirectToAction("ListUsers"));
}
}
else if (userService.PasswordIsMatched(user.UserName, model.Password))
{
if (userService.Delete(user))
{
Logout();
TempData["Status"] = true;
TempData["Message"] = "User Account successfully deleted";
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("", "Can't delete user");
}
}
return(View());
}
public async Task <ActionResult> DeleteAccount(DeleteAccountViewModel model)
{
if (ModelState.IsValid)
{
var user = _userService.FindById(User.Identity.GetUserId <int>());
var picture = _userService.FindById(user.Id).PictureId;
if (picture.HasValue)
{
_pictureService.Delete(picture.Value);
}
var ordersId = _orderService.GetAll().Where(o => o.UserId == user.Id).Select(o => o.Id).ToList();
if (ordersId.Any())
{
var responses = _responseService.GetAll()
.Select(r => r.OrderId.Value)
.Where(r => ordersId.Contains(r)).ToList();
if (responses.Any())
{
foreach (var response in responses)
{
_responseService.Delete(response);
}
}
}
var comments = _commentService.GetAll().Where(c => c.CustomerId == user.Id).ToList();
if (comments.Any())
{
foreach (var comment in comments)
{
_commentService.Delete(comment.Id);
}
}
ClientViewModelBLL userDto = new ClientViewModelBLL
{
Password = model.Password,
Email = User.Identity.Name
};
var operationDetails = await _userService.DeleteAccount(userDto);
if (operationDetails.Succedeed)
{
_unitOfWork.Save();
LogOff();
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
}
return(View(model));
}
public async Task <IActionResult> Delete([Bind] DeleteAccountViewModel password)
{
var user = await GetCurrentLocalUserAsync();
if (HttpContext.Request.Method == "GET")
{
ViewData["Controller"] = "Account";
ViewData["Action"] = nameof(Delete);
HttpContext.Items["RequirePassword"] = await _userManager.HasPasswordAsync(user);
ModelState.Clear();
return(View(password ?? new DeleteAccountViewModel()));
}
else if (HttpContext.Request.Method == "POST")
{
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var RequirePassword = await _userManager.HasPasswordAsync(user);
if (RequirePassword)
{
if (password.CurrentPassword != password.ConfirmPassword || !await _userManager.CheckPasswordAsync(user, password.CurrentPassword))
{
ModelState.AddModelError(string.Empty, "Password not correct.");
return(View(password));
}
}
var result = await _userManager.DeleteAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!result.Succeeded)
{
throw new InvalidOperationException($"Unexpected error occurred deleteing user with ID '{userId}'.");
}
await _signInManager.SignOutAsync();
return(Redirect("~/"));
}
else
{
throw new ArgumentOutOfRangeException("Method");
}
}
public ActionResult DeleteAccount(DeleteAccountViewModel model)
{
if (!ModelState.IsValid)
{
return(View("~/Views/Errors/Error.cshtml"));
}
if (!User.Identity.IsAuthenticated)
{
return(View("~/Views/Errors/Error.cshtml"));
}
AuthenticationManager.SignOut();
// execute delete action
return(View(Utils.User.DeleteUser(User.Identity.Name) ? "~/Views/Account/AccountDeleted.cshtml" : "~/Views/Errors/Error.cshtml"));
}
public IActionResult DeleteAccount(DeleteAccountViewModel model)
{
Account account = _accountRepository.Delete(model.AccountID);
if (account != null)
{
ViewData["DeleteSuccess"] = "true";
}
else
{
ViewData["DeleteSuccess"] = "false";
}
return(View(model));
//return model.AccountID;
}
public IActionResult DeleteAccount1Step(DeleteAccountViewModel model)
{
if (!ModelState.IsValid)
{
ModelState.AddModelError("Error", "There was an error. Try again or contact support.");
return(PartialView("~/Views/Auth/DeleteAccount.cshtml"));
}
var responseFromApi = _apiService.DeleteAccountProcess(model, "1step").Result;
if (!responseFromApi.Success)
{
ModelState.AddModelError("Error", responseFromApi.Messages.First());
return(PartialView("~/Views/Auth/DeleteAccount.cshtml"));
}
return(PartialView("~/Views/Auth/DeleteAccountNotification.cshtml"));
}
public async Task <IActionResult> DeleteAccount(DeleteAccountViewModel model)
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
try
{
var passwordIsCorrect = await _userManager.CheckPasswordAsync(user, model.Password);
if (passwordIsCorrect)
{
user.UserName = user.Id;
user.NormalizedUserName = null;
user.NormalizedEmail = null;
user.AccessFailedCount = 0;
user.Email = "deleted";
user.FirstName = null;
user.LastName = null;
user.Organisation = null;
user.Degree = null;
user.VATID = null;
user.PhoneNumber = null;
user.EmailConfirmed = false;
user.PhoneNumberConfirmed = false;
user.IsDeleted = true;
var roles = _userManager.GetRolesAsync(user).Result.ToAsyncEnumerable().ToEnumerable();
await _userManager.RemoveFromRolesAsync(user, roles);
var result = await _userManager.UpdateAsync(user);
await _signInManager.SignOutAsync();
_logger.LogInformation("User logged out.");
return(RedirectToAction(nameof(HomeController.Index), "Home"));
}
return(View());
}
catch
{
return(View());
}
}
public JsonResult DeleteAccount(DeleteAccountViewModel viewModel)
{
if (ModelState.IsValid)
{
if (!_userService.PasswordIsValidForCurrentUser(viewModel.DeleteConfirmPassword))
{
ModelState.AddModelError("DeleteConfirmPassword", @"The password you provided is invalid.");
}
var currentUser = _userService.GetCurrentUser();
_userService.Logout();
_userService.Delete(currentUser);
_emailService.SendAccountDeletionReasonsEmail(viewModel.Reason, viewModel.Elaboration, viewModel.Suggestions);
}
return(Json(_validationHelper.ModelStateToJsonResult(ModelState)));
}
public async Task <IActionResult> Delete(string returnUrl = "")
{
try
{
// check user exists
var userAccount = await _userStore.GetUserAccountAsync(User.Identity.Name);
var davm = new DeleteAccountViewModel();
return(View(davm));
}
catch (Exception)
{
Log.Warning($"User account not found: '{User.Identity.Name}'");
var davm = new DeleteAccountViewModel();
ModelState.AddModelError("", $"No user found with name '{User.Identity.Name}'");
return(View(davm));
}
}
public ActionResult DeleteAccount(int id = 0)
{
if (Session["UserID"] == null)
{
return(RedirectToAction("Login"));
}
if (id == 0)
{
ViewBag.Message = $"Are you sure you want to delete account called {Session["Username"]}?";
return(View());
}
DeleteAccountViewModel model = new DeleteAccountViewModel
{
ID = id
};
return(DeleteAccount(model));
}
public ActionResult DeleteAccount(DeleteAccountViewModel model)
{
// require users to enter their password in order to execute account delete action
var user = UserManager.Find(User.Identity.Name, model.CurrentPassword);
if (user != null)
{
// execute delete action
if (Utils.User.DeleteUser(User.Identity.Name))
{
AuthenticationManager.SignOut();
return(View("~/Views/Account/AccountDeleted.cshtml"));
}
// something went wrong when deleting user account
return(View("~/Views/Errors/Error.cshtml"));
}
return(RedirectToAction("Manage", new { message = ManageMessageId.WrongPassword }));
}
public async Task <IActionResult> Delete(DeleteAccountViewModel davm)
{
try
{
if (!ModelState.IsValid || !davm.Confirm)
{
ModelState.AddModelError("", "You must confirm that you want to delete your user account and associated settings.");
return(View("Delete"));
}
var deleted = await _userStore.DeleteUserAsync(User.Identity.Name);
if (deleted)
{
// delete user's settings
try
{
var us = await _userStore.GetUserSettingsAsync(User.Identity.Name);
await _userStore.DeleteUserSettingsAsync(User.Identity.Name);
}
catch (UserSettingsNotFoundException)
{
// no action needed
}
catch (UserStoreException e)
{
Log.Error($"Error deleting user settings during user account {User.Identity.Name} deletion", e);
}
// repositories
try
{
var repos = await _repoSettingsStore.GetRepoSettingsForOwnerAsync(User.Identity.Name);
foreach (var r in repos)
{
await _repoSettingsStore.DeleteRepoSettingsAsync(r.OwnerId, r.RepositoryId);
}
}
catch (RepoSettingsNotFoundException)
{
// no action needed
}
catch (RepoSettingsStoreException e)
{
Log.Error($"Error deleting repo settings during user account {User.Identity.Name} deletion", e);
}
// owner settings
try
{
var owner = await _ownerSettingsStore.GetOwnerSettingsAsync(User.Identity.Name);
await _ownerSettingsStore.DeleteOwnerSettingsAsync(owner.OwnerId);
}
catch (OwnerSettingsNotFoundException)
{
// no action needed
}
catch (OwnerSettingsStoreException e)
{
Log.Error($"Error deleting owner settings during user account {User.Identity.Name} deletion", e);
}
// datasets
try
{
await _datasetStore.DeleteDatasetsForOwnerAsync(User.Identity.Name);
}
catch (DatasetStoreException e)
{
Log.Error($"Error deleting datasets during user account {User.Identity.Name} deletion", e);
}
// templates
try
{
await _schemaStore.DeleteSchemaRecordsForOwnerAsync(User.Identity.Name);
}
catch (Exception e)
{
Log.Error($"Error deleting templates during user account {User.Identity.Name} deletion", e);
}
// jobs
try
{
await _jobStore.DeleteJobsForOwnerAsync(User.Identity.Name);
}
catch (Exception e)
{
Log.Error($"Error deleting jobs during user account {User.Identity.Name} deletion", e);
}
await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
return(RedirectToAction("Index", "Home"));
}
// error
ViewBag.Message =
"Unable to delete account at this time, if the problem persists please open a ticket with support.";
return(View("Delete"));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public void WhenPackagesNotSet_ReturnsFalse()
{
var viewModel = new DeleteAccountViewModel();
Assert.False(viewModel.HasOrphanPackages);
}
public DeleteAccountPage()
{
InitializeComponent();
_vm = BindingContext as DeleteAccountViewModel;
_vm.Page = this;
}
public Task <DeleteAccountResponse> DeleteAccountAsync(DeleteAccountViewModel deleteAccount)
{
throw new NotImplementedException();
}
public async Task<IActionResult> Delete(DeleteAccountViewModel request)
{
var result = await _mediator.SendAsync(request);
return Json(result);
}