public async Task <IActionResult> DeleteRoleConfirmed(DeleteUserViewModel model)
{
var role = await roleManager.FindByIdAsync(model.Id);
if (role == null)
{
ViewBag.ErrorMessage = $"Role with Id = {model.Id} cannot be found";
return(View("NotFound"));
}
else
{
var result = await roleManager.DeleteAsync(role);
if (result.Succeeded)
{
return(RedirectToAction("ListRoles", "Administration"));
}
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
return(View(model));
}
}
public async Task <IActionResult> Delete(string id)
{
var user = await userManager.FindByIdAsync(id);
if (user != null)
{
var model = new DeleteUserViewModel()
{
RoleId = user.UserName,
UserId = user.Id,
Email = user.Email,
City = user.City,
Address = user.Address,
};
var rolesName = await userManager.GetRolesAsync(user);
if (rolesName != null && rolesName.Any())
{
var role = await roleManager.FindByNameAsync(rolesName.FirstOrDefault());
model.RoleId = role.Id;
}
ViewBag.Roles = roleManager.Roles;
return(View(model));
}
else
{
return(View("~/Views/Error/RoleNotFound.cshtml", id));
}
}
public ActionResult DeleteConfirmed(DeleteUserViewModel duvm)
{
string id = (string)Session["userid"];
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
ApplicationUser user = db.Users.Find(id);
if (user != null)
{
DeleteDocs(user.Files.ToArray());
db.Users.Remove(user);
db.SaveChanges();
TempData["alert"] = "success|Elev togs bort!|user";
}
else
{
TempData["alert"] = "danger|Eleven gick inte att hitta!";
}
}
catch (RetryLimitExceededException)
{
// Log errors here
TempData["alert"] = "danger|Det gick inte att ta bort eleven!";
}
return(PartialView("_Delete", duvm));
}
// GET: User/Delete
public ActionResult Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
using (var database = new ApplicationDbContext())
{
var user = database.Users
.Where(u => u.Id.Equals(id))
.First();
if (user == null)
{
return(HttpNotFound());
}
var viewModel = new DeleteUserViewModel();
viewModel.User = user;
viewModel.Roles = GetUserRoles(user, database);
return(View(viewModel));
}
}
public ActionResult Delete(string Id)
{
var user = userRepo.ResultTable.Where(x => x.Id == Id).First();
var model = new DeleteUserViewModel(user);
return(View(model));
}
public async Task <ActionResult> Delete(string id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var user = await UserManager.FindByIdAsync(id);
if (user == null)
{
return(HttpNotFound());
}
var viewModel = new DeleteUserViewModel()
{
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
UserRoles = await UserManager.GetRolesAsync(user.Id)
};
return(View(viewModel));
}
public async Task <IActionResult> DeleteUser(string userId)
{
var user = await _mediator.SendAsync(new UserQuery { UserId = userId });
var campaigns = await _mediator.SendAsync(new CampaignByApplicationUserIdQuery()
{
ApplicationUserId = userId
});
var events = await _mediator.SendAsync(new EventsByApplicationUserIdQuery()
{
ApplicationUserId = userId
});
var volunteerTasks = await _mediator.SendAsync(new VolunteerTasksByApplicationUserIdQuery()
{
ApplicationUserId = userId
});
var viewModel = new DeleteUserViewModel
{
UserId = userId,
UserName = user.UserName,
IsSiteAdmin = user.IsSiteAdmin,
OrganizationName = user.Organization?.Name,
IsOrganizationAdmin = user.IsOrganizationAdmin,
Campaigns = campaigns?.Select(x => x.Name),
Events = events?.Select(x => x.Name),
VolunteerTasks = volunteerTasks?.Select(x => x.Name)
};
return(View(viewModel));
}
// Get User/Delete
public ActionResult Delete(string id)
{
if (id == null)
{
this.AddNotification("No id specified!", NotificationType.ERROR);
return(Redirect("/User/List"));
}
using (var db = new ApplicationDbContext())
{
var user = db.Users.Find(id);
if (user == null)
{
this.AddNotification("Invalid user id!", NotificationType.ERROR);
return(Redirect("/User/List"));
}
var viewModel = new DeleteUserViewModel();
viewModel.UserName = db.Users.Where(u => u.Id == id).Select(u => u.UserName).FirstOrDefault();
viewModel.FullName = db.Users.Where(u => u.Id == id).Select(u => u.FullName).FirstOrDefault();
viewModel.UploadedSongsCount = user.UploadedSongs.Count;
viewModel.PlaylistCount = user.Playlists.Count;
this.AddNotification($"Deleting the user '{viewModel.FullName}' will delete all songs and playlists created by him!", NotificationType.WARNING);
this.AddNotification($"Total songs '{viewModel.UploadedSongsCount}'!", NotificationType.INFO);
this.AddNotification($"Total playlists '{viewModel.PlaylistCount}'!", NotificationType.INFO);
return(View(viewModel));
}
}
public async Task <IActionResult> Destroy(string id, DeleteUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await this.userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var result = await this.userManager.DeleteAsync(user);
if (result.Succeeded)
{
TempData.AddSuccessMessage($"User {user.UserName} successfully deleted.");
return(RedirectToAction(nameof(Index)));
}
else
{
AddModelErrors(result);
return(View(model));
}
}
public async Task <IActionResult> Delete(string userid)
{
if (userid == null)
{
Response.StatusCode = 404;
return(View("NotFound"));
}
User user;
try
{
user = await this.userManager.FindByIdAsync(userid);
}
catch (Exception)
{
Response.StatusCode = 404;
return(View("NotFound"));
}
var userRoles = await this.userManager.GetRolesAsync(user);
if (userRoles.Contains(WebConstants.MasterAdminRole))
{
return(PartialView("_MasterAdminEditPartial"));
}
var model = new DeleteUserViewModel()
{
Id = userid,
UserName = user.FirstName + " " + user.LastName
};
return(PartialView("_DeleteUserPartial", model));
}
public ActionResult Delete(string id, DeleteUserViewModel viewModel)
{
if (ModelState.IsValid)
{
using (var database = new ApplicationDbContext())
{
// Get user from database
var user = database.Users.FirstOrDefault(u => u.Id.Equals(id));
if (user == null)
{
return(HttpNotFound());
}
// Get user posts from database
var userPosts = database.Posts
.Where(a => a.Author.Id.Equals(user.Id));
// Delete user solutions
foreach (var post in userPosts)
{
database.Posts.Remove(post);
}
// Delete user and save changes
database.Users.Remove(user);
database.SaveChanges();
return(RedirectToAction("List"));
}
}
return(RedirectToAction("List"));
}
public ActionResult DeleteUser(DeleteUserViewModel model)
{
using (DBModel db = new DBModel())
{
try
{
//db.AspNetUsers.RemoveRange(db.AspNetUsers.Where(r => r.Id == model.UserId));
//var getUserToDelete = db.AspNetUsers.SingleOrDefault(c => c.Id == model.UserId);
var getUserToDelete = db.AspNetUsers.SingleOrDefault(c => c.Id == model.UserId);
getUserToDelete.AccessFailedCount = 4;
getUserToDelete.LockoutEndDateUtc = Convert.ToDateTime("2030/12/31 11:43:52 AM");
getUserToDelete.Status = 2;
var userDeleted = db.SaveChanges();
if (userDeleted > 0)
{
return(Json("success", JsonRequestBehavior.AllowGet));
}
else
{
return(Json("Error! Unable to delete user", JsonRequestBehavior.AllowGet));
}
}
catch (Exception ex)
{
return(Json(ex.Message, JsonRequestBehavior.AllowGet));
}
}
}
public async Task <IActionResult> DeleteUser(DeleteUserViewModel model, [FromHeader] string authorization)
{
if (!ModelState.IsValid)
{
return(BadRequest(model));
}
HttpParameters httpParameters = HttpParametersService
.GetHttpParameters(
model,
ConfigHelper.AppSetting(Constants.ServerUrls, Constants.DeleteUser),
HttpMethod.Delete,
string.Empty,
authorization
);
DeleteUserResponse deleteUserResult = await _gWService.PostTo <DeleteUserResponse>(httpParameters);
if (deleteUserResult.StatusCode == 404)
{
return(await ResponseService.GetResponse <NotFoundObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
else if (deleteUserResult.StatusCode == 422)
{
return(await ResponseService.GetResponse <UnprocessableEntityObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
else if (deleteUserResult.StatusCode != 200)
{
return(await ResponseService.GetResponse <BadRequestObjectResult, DeleteUserResponse>(deleteUserResult, ModelState));
}
return(new OkObjectResult(deleteUserResult));
}
public async Task <ActionResult> Delete([FromForm] DeleteUserViewModel deleteUserViewModel)
{
var user = await _userRepository.GetUser(deleteUserViewModel.UserName);
await _userRepository.Delete(user);
return(Ok());
}
//
//GET: /Manage/Delete/32432
public ActionResult DeleteUser(string id)
{
var db = new ApplicationDbContext();
var user = db.Users.First(s => s.Id == id);
var model = new DeleteUserViewModel(user);
return(View(model));
}
public IActionResult DeleteUser(DeleteUserViewModel model)
{
if (ModelState.IsValid)
{
return(RedirectToAction("DeleteUser", "Document"));
}
return(View(model));
}
public static async Task <bool> DeleteAsync(Authentication authentication, IUserDescriptor descriptor)
{
var dialog = await DeleteUserViewModel.CreateInstanceAsync(authentication, descriptor);
if (dialog != null && await dialog.ShowDialogAsync() == true)
{
return(true);
}
return(false);
}
public IActionResult DeleteUser(DeleteUserViewModel model, string manage)
{
var user = _userService.GetUserByEmail(model.Email);
var userViewModel = _mapper.Map <DeleteUserViewModel>(user);
if (!ModelState.IsValid)
{
return(View(userViewModel));
}
if (user == null)
{
ModelState.AddModelError("", "There is no user with such email");
return(View(userViewModel));
}
if (user.IsDeleted)
{
if (manage == "Delete")
{
ModelState.AddModelError("UserDeleted", "User is already deleted");
}
}
if (user.Email == User.Identity.Name)
{
if (manage == "Delete")
{
ModelState.AddModelError("", "You cannot delete yourself");
}
}
var isLastAdmin = _userService.IsLastAdmin(model.Email);
if (isLastAdmin)
{
if (manage == "Delete")
{
ModelState.AddModelError("", "You cannot delete the only admin");
}
}
if (manage == "Restore")
{
_userService.RestoreUser(user.Email);
}
else
{
_userService.DeleteUser(user.Email);
}
return(RedirectToAction(nameof(ManageUsers)));
}
public async Task <IActionResult> Delete(DeleteUserViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("Delete"));
}
await this.userService.DeleteUserAsync(model.Id);
return(RedirectToAction("Index"));
}
public ActionResult Delete(DeleteUserViewModel model)
{
CcmUser user = _userManager.GetUser(model.Id);
if (user != null)
{
_userManager.Delete(user);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> DeleteUser(string userId)
{
var user = await _mediator.SendAsync(new UserQuery { UserId = userId });
var viewModel = new DeleteUserViewModel
{
UserId = userId,
UserName = user.UserName,
};
return(View(viewModel));
}
public IActionResult Delete(DeleteUserViewModel model)
{
var userId = userService.GetUserId(User.Identity.Name);
var takenId = model.Id;
this.admins.DeleteUser(model.Id);
if (takenId == userId)
{
signInManager.SignOutAsync();
return(RedirectToAction("Login", "Account"));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> DeleteUser(DeleteUserViewModel model)
{
if (ModelState.IsValid)
{
await service.DeleteUser(model);
return(RedirectToAction("DisplayAllUsers"));
}
else
{
return(View());
}
}
public ActionResult DeleteUser(DeleteUserViewModel model)
{
if (User.Identity.IsAuthenticated && User.IsInRole("Admin"))
{
if (!ModelState.IsValid)
{
return(View(model));
}
SiteUserManager.DeleteSiteUser(model.Id, Server);
return(RedirectToAction("Users", "Admin"));
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Delete(DeleteUserViewModel model)
{
var user = await _userManager.FindByIdAsync(model.Id.ToString());
if (user == null)
{
return(NotFound(model.Id));
}
await _userManager.DeleteAsync(user);
Notifier.Success($"你成功删除了“{user.UserName}”的账户！");
return(RedirectToAction(nameof(List)));
}
public ActionResult Delete(string id)
{
var domainUser = UserManager.FindById(id);
if (domainUser == null)
{
return(View("Error"));
}
Mapper.CreateMap <DCUser, DeleteUserViewModel>();
DeleteUserViewModel user = Mapper.Map <DeleteUserViewModel>(domainUser);
ViewBag.Title = String.Format("Delete {0} ?", user.UserName);
return(View(user));
}
public async Task <IActionResult> DeleteConfirm(DeleteUserViewModel deleteUser)
{
var user = await userManager.FindByIdAsync(deleteUser.Id);
if (user == null)
{
return(NotFound());
}
await userManager.DeleteAsync(user);
TempData.AddSuccessMessage($"User {user.UserName} was succesfully deleted");
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Delete(DeleteUserViewModel userModel)
{
var user = await userManager.FindByIdAsync(userModel.Id);
if (user == null)
{
return(NotFound());
}
return(View(new DeleteUserViewModel
{
Id = userModel.Id,
UserName = user.UserName
}));
}
public async Task <IActionResult> DeleteUser(string id)
{
DeleteUserViewModel deleteUserViewModel = new DeleteUserViewModel();
if (!string.IsNullOrEmpty(id))
{
ApplicationUser applicationUser = await _userManager.FindByIdAsync(id);
if (applicationUser != null)
{
deleteUserViewModel.FullName = applicationUser.FullName;
deleteUserViewModel.Id = applicationUser.Id;
}
}
return(PartialView("DeleteUser", deleteUserViewModel));
}
public async Task <IActionResult> DeleteUser(DeleteUserViewModel model, string id)
{
var user = await userManager.FindByIdAsync(id);
if (user != null)
{
var result = await userManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("ListUsers", "Administration"));
}
}
ViewBag.ErrorTitle = "The user that you want to delete cannot be found";
return(View("Error"));
}
