public async Task <IHttpActionResult> Delete(Guid id, UserDeleteViewModel model)
{
if (model == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var buyerAccountUuid = model.BuyerAccountUuid.GetValueOrDefault(Guid.Empty);
var buyerAccount = await _accountService.GetAccount(buyerAccountUuid).ConfigureAwait(false);
if (buyerAccount == null)
{
return(BadRequest("The specified buyer account was not found."));
}
var user = await _userService.GetUser(id).ConfigureAwait(false);
if (user == null)
{
return(NotFound());
}
await _userService.RemoveUserFromBuyerAccount(buyerAccountUuid, id).ConfigureAwait(false);
return(StatusCode(HttpStatusCode.NoContent));
}
public IActionResult DeleteView(string id)
{
List <UserDeleteViewModel> listmodel = new List <UserDeleteViewModel>();
if (id == null)
{
}
var user = _userManager.FindByIdAsync(id).Result;
var roles = _userManager.GetRolesAsync(user).Result;
if (user == null)
{
}
var usermodel = new UserDeleteViewModel()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
PhoneNo = user.PhoneNumber,
UserId = user.Id
};
foreach (var role in roles)
{
usermodel.RolesList.Add(role);
}
return(View(usermodel));
}
public async Task <IActionResult> DeleteUser(UserDeleteViewModel userModel)
{
if (ModelState.IsValid)
{
var user = await this.userManager.FindByEmailAsync(userModel.Email);
var currentSignedUser = await this.userManager.GetUserAsync(HttpContext.User);
if (user.Id == currentSignedUser.Id)
{
this.logger.Information($"The currently signed administrator '{userModel.Email}' cannot remove himself.");
ModelState.AddModelError(string.Empty, $"Aktuálne prihlásený administrátor '{userModel.Email}' nemôže byť zmazaný.");
return(View(userModel));
}
var result = await this.userManager.DeleteAsync(user);
if (result.Succeeded)
{
ConfirmationMessage("Administrátor bol zmazaný.");
this.logger.Information($"The administrator '{userModel.Email}' has been removed.");
return(RedirectToAction(nameof(Users)));
}
this.logger.Error($"The administrator '{userModel.Email}' could not be removed.");
foreach (var error in result.Errors)
{
this.logger.Error($"{error.Code} {error.Description}");
ModelState.AddModelError(string.Empty, error.Description);
}
}
return(View(userModel));
}
public ActionResult Delete(int id, UserDeleteViewModel userDeleteViewModel)
{
try
{
using (var userService = new UserService())
{
if (userDeleteViewModel == null)
{
throw new NullReferenceException();
}
userDeleteViewModel.AddressId = userService.EagerDisconnectedService.FindBy(u => u.Id == id).First().AddressId;
userDeleteViewModel.Address.Id = userDeleteViewModel.AddressId;
userDeleteViewModel.PhoneNumber.Id = userService.EagerDisconnectedService.FindBy(u => u.Id == id).First().PhoneNumberId;
userDeleteViewModel.PhoneNumber.Id = userDeleteViewModel.PhoneNumberId;
var convertedViewModel = DTOMapper.MappFrom((IUser)userDeleteViewModel);
userService.EagerDisconnectedService.Delete(Session[convertedViewModel.Id] as UserDTO, convertedViewModel);
}
return(RedirectToAction("Index"));
}
catch (Exception e)
{
TempData["ResultMessage"] = e.Message;
return(View("Error"));
}
}
// GET: Users/Delete/5
public ActionResult Delete(int?id)
{
if (id == null || id == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
using (var userService = new UserService())
{
var foundUser = userService.EagerDisconnectedService.FindByInclude(
x => x.Id == id.Value && x.Active, a => a.Address, p => p.PhoneNumber);
if (!foundUser.Any())
{
throw new Exception("No users found.");
}
var user = foundUser.First();
var IdeleteViewModel = ModelMapper.MappFrom(user);
var deleteViewModel = new UserDeleteViewModel(IdeleteViewModel);
return(View(deleteViewModel));
}
}
catch (Exception e)
{
TempData["ResultMessage"] = e.Message;
return(View("Error"));
}
}
public ActionResult Delete(UserDeleteViewModel udvm)
{
try
{
if (ModelState.IsValid)
{
using (var bd = new BD_EvaluacionEntities())
{
var oUser = bd.Usuarios.Find(udvm.Codigo_Usuario);
oUser.IdState = 3;
bd.Entry(oUser).State = System.Data.Entity.EntityState.Modified;
bd.SaveChanges();
}
mensaje = "Ok";
}
else
{
string errors = string.Empty;
foreach (var item in ModelState.Values)
{
if (item.Errors.Count > 0)
{
mensaje += string.Format("{0} \n", item.Errors[0].ErrorMessage);
}
}
mensaje += " Contacte al Administrador";
}
}
catch (Exception ex)
{
mensaje = ex.Message;
}
return(RedirectToAction("Delete", "User", new { id = udvm.Codigo_Usuario, mensaje }));
}
public async Task <IActionResult> DeleteUser(string id, bool?saveChangesError = false)
{
if (String.IsNullOrEmpty(id))
{
RedirectToAction(nameof(ListUsers));
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(RedirectToAction(nameof(ListUsers)));
}
var userUrls = await _context.Urls.Where(u => u.Id == user.Id).ToListAsync();
UserDeleteViewModel userDeleteVM = new UserDeleteViewModel
{
User = user,
Urls = userUrls
};
if (saveChangesError.GetValueOrDefault())
{
ViewData["ErrorMessage"] = "Delete failed. Try again, and if the problem persists see your system administrator.";
}
return(View("~/Views/Admin/Users/Delete.cshtml", userDeleteVM));
}
public async Task<ActionResult> DeleteConfirm(UserDeleteViewModel model)
{
ApplicationUser user = await userManager.FindByIdAsync(model.Id);
if (user != null)
{
await userManager.DeleteAsync(user);
}
return RedirectToAction("Index");
}
public ActionResult Delete(UserDeleteViewModel model)
{
using (var context = new ApplicationDbContext())
{
var userService = new UserService(context, HttpContext);
userService.Delete(model);
context.SaveChanges();
return(RedirectToAction("List"));
}
}
public ActionResult Delete(UserDeleteViewModel model)
{
UserRepository repository = new UserRepository();
if (model.Id.ToString() != String.Empty)
{
repository.Delete(model.Id);
}
return(RedirectToAction("Index"));
}
//删除用户（一个或者多个）
public int User_Delete(UserDeleteViewModel userDeleteViewModel)
{
int DeleteRowsNum = _IUserInfoRepository
.DeleteByUseridList(userDeleteViewModel.DeleleIdList);
if (DeleteRowsNum == userDeleteViewModel.DeleleIdList.Count)
{
return(DeleteRowsNum);
}
else
{
return(-1);
}
}
public async Task <ActionResult> UserDeleteAsync(UserDeleteViewModel model)
{
var query = new QueryData <SysUserDeleteQuery>()
{
Criteria = new SysUserDeleteQuery()
{
UserNo = model.UserNo,
IsDelete = model.IsDelete
}
};
var result = await _manager.UserDeleteAsync(query);
return(Ok(result));
}
private UserDeleteViewModel getUserDeleteViewModel(IdentityUser identityUser)
{
if (identityUser == null)
{
return(null);
}
var user = new UserDeleteViewModel()
{
Id = identityUser.Id
};
return(user);
}
public ActionResult Delete(int id)
{
UserRepository repository = new UserRepository();
User user = repository.GetById(id);
UserDeleteViewModel model = new UserDeleteViewModel();
model.username = user.username;
model.password = user.password;
model.firstName = user.firstName;
model.lastName = user.lastName;
model.isAdmin = user.isAdmin;
return(View(model));
}
public ActionResult Delete(string id)
{
using (var context = new ApplicationDbContext())
{
var userService = new UserService(context, HttpContext);
var user = userService.GetById(id);
if (user == null)
{
return(HttpNotFound());
}
var viewModel = new UserDeleteViewModel(user);
return(View(viewModel));
}
}
public async Task <IActionResult> Delete()
{
User user = await repository.UserManager.FindByNameAsync(User.Identity.Name);
if (user is null)
{
return(NotFound());
}
UserDeleteViewModel model = new UserDeleteViewModel
{
UserName = user.UserName,
Id = user.Id
};
return(View(model));
}
public void Delete(UserDeleteViewModel model)
{
var userCleranceLevel = GetCurrentUserCleranceLevel();
if (userCleranceLevel.Level < model.CleranceLevel)
{
return;
}
var user = new ApplicationUser {
Id = model.Id
};
_context.Users.Attach(user);
_context.Entry(user).State = EntityState.Deleted;
}
public ActionResult ConfirmUserDelete(int id)
{
var user = userService.GetUserEntity(id);
if (user != null)
{
if (user.Email == User.Identity.Name)
{
throw new HttpException(404, "Not found");
}
var deleteUser = new UserDeleteViewModel()
{
Email = user.Email, UserId = user.UserId
};
return(View(deleteUser));
}
throw new HttpException(404, "Not foud");
}
public async Task <IActionResult> Delete([FromForm] UserDeleteViewModel model)
{
if (!ModelState.IsValid)
{
return(RedirectToAction(nameof(Overview)));
}
try
{
await _userService.DeleteAsync(model.Id);
return(RedirectToAction(nameof(Overview), new { success = true }));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public ActionResult Delete(UserDeleteViewModel model)
{
int id = LoginFilter.GetUserId();
UserRepository repository = new UserRepository();
if (model.Id.ToString() != String.Empty)
{
repository.Delete(model.Id);
}
if (model.Id == id)
{
return(RedirectToAction("Logout", "Home"));
}
else
{
return(RedirectToAction("Index"));
}
}
public ActionResult Delete(string id, string mensaje)
{
if (mensaje != null && mensaje.Trim() != "")
{
if (mensaje == "Ok")
{
ViewBag.Message = "Usuario Eliminado exitosamente";
ViewBag.Status = true;
}
else if (mensaje != "Ok")
{
ViewBag.Message = mensaje;
ViewBag.Status = false;
}
}
try
{
#region Carga datos a mostrar
var oUser = new UserDeleteViewModel();
using BD_EvaluacionEntities Db = new BD_EvaluacionEntities();
oUser = (from usr in Db.Usuarios
join car in Db.Cargos on usr.Codigo_Cargo equals car.Codigo_Cargo
join rol in Db.Rol on usr.Tipo_Usuario equals rol.Tipo_Usuario
join sta in Db.Estado_Componentes on usr.IdState equals sta.IdState
where usr.Codigo_Usuario == id
select new UserDeleteViewModel
{
Codigo_Usuario = usr.Codigo_Usuario,
Nombre_Usuario = usr.Nombre_Usuario,
Tipo_Usuario = rol.Nombre,
Codigo_Cargo = car.Nombre_Cargo,
IdState = sta.StateDescription
}).FirstOrDefault();
return(View(oUser));
#endregion
}
catch (Exception)
{
ActionResult result = new HttpStatusCodeResult(HttpStatusCode.InternalServerError);
return(result);
}
}
public async Task <IActionResult> DeleteUserAccount(UserDeleteViewModel model)
{
try
{
var user = await UserManager.FindByIdAsync(model.UserId);
await UserManager.DeleteAsync(user);
EmployeeServices.DeleteEmployee(model.UserId);
}
catch (Exception e)
{
Logger.LogDebug("Failed to delete user account,most likely model was not correct {@Exception}", e);
Logger.LogError("Failed to delete user account,most likely model was not correct {Exception}", e.Message);
return(BadRequest());
}
var users = UserManager.Users.ToList();
return(PartialView("_TablePartial", users));
}
public ActionResult Delete(int id)
{
UserRepository repository = new UserRepository();
User user = repository.GetById(id);
UserDeleteViewModel model = new UserDeleteViewModel();
model.imgURL = user.ImgURL;
model.username = user.Username;
model.password = user.Password;
model.firstName = user.FirstName;
model.lastName = user.LastName;
model.Email = user.Email;
//model.isAdmin = user.IsAdmin;
//model.IsEmailConfirmed = user.IsEmailConfirmed;
return(View(model));
}
public async Task Delete_ShouldReturnOk()
{
// Arrange
var user = new User {
UserId = Guid.NewGuid(), Email = "*****@*****.**", FirstName = "Jing"
};
var model = new UserDeleteViewModel {
BuyerAccountUuid = Guid.NewGuid()
};
Mock.Mock <IAccountService>().Setup(x => x.GetAccount(model.BuyerAccountUuid.Value)).Returns(Task.FromResult(new BuyerAccount()));
Mock.Mock <IUserService>().Setup(x => x.GetUser(user.UserId)).Returns(Task.FromResult(user));
// Act
var retVal = await Controller.Delete(user.UserId, model);
// Assert
Assert.That(retVal, Is.TypeOf <StatusCodeResult>());
Assert.That(((StatusCodeResult)retVal).StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
Mock.Mock <IUserService>().Verify(x => x.RemoveUserFromBuyerAccount(model.BuyerAccountUuid.Value, user.UserId), Times.Once);
}
/// <summary>
/// Atribui o valor booleano true à propriedade User.Delete.
/// Tem como efeito a alteração da propriedade User.UpdateAt.
/// </summary>
/// <param name="userDelete"></param>
/// <returns>Retorna um texto contendo o resultado do comando.</returns>
public async Task <string> Delete(UserDeleteViewModel userDelete)
{
var email = _authenticatedUser.GetEmail();
User user = await _userManager.FindByEmailAsync(email);
var confirmPass = await _userManager.CheckPasswordAsync(user, userDelete.Password);
if (!confirmPass)
{
return(null);
}
user.Deleted = true;
user.EmailConfirmed = false;
user.UpdatedAt = DateTime.UtcNow;
var result = await _userManager.UpdateAsync(user);
await _signInManager.SignOutAsync();
return(result.ToString());
}
// GET: User/Delete/5
public async Task <ActionResult> Delete(int id)
{
var user = await _userManager.FindByIdAsync(id.ToString());
if (user == null || !await CanManageUser(user))
{
AddErrorMessage("User not found or you do not have permission to manage the user.");
return(RedirectToAction(nameof(Index)));
}
var roles = await _userManager.GetRolesAsync(user);
var model = new UserDeleteViewModel
{
Id = user.Id,
UserName = user.UserName,
Email = user.Email,
Roles = roles.Any() ? string.Join(',', roles) : "-"
};
return(View(model));
}
public async Task <IActionResult> DeleteAccount(UserDeleteViewModel model)
{
var user = await this.userManager
.CheckPasswordAsync(model.Email, model.Password);
if (user == null)
{
this.ShowNotification(NotificationMessages.InvalidCredentials);
return(View(model));
}
await this.userService.DeleteAsync(user);
await this.signInManager.SignOutAsync(this.HttpContext);
this.ShowNotification(
"Your account has been deleted premanently!",
NotificationType.Success);
return(RedirectToHome());
}
public ActionResult Delete(int id)
{
UserRepository repository = new UserRepository();
User user = repository.GetById(id);
UserDeleteViewModel model = new UserDeleteViewModel();
model.ImgURL = user.ImgURL;
model.Username = user.Username;
model.Password = user.Password;
model.Email = user.Email;
model.FirstName = user.FirstName;
model.LastName = user.LastName;
model.IsAdmin = user.IsAdmin;
model.IsEmailConfirmed = user.IsEmailConfirmed;
model.ValidationCode = user.ValidationCode;
user.IsStudent = model.IsStudent;
user.IsTeacher = model.IsTeacher;
return(View(model));
}
public async Task <IActionResult> Delete(UserDeleteViewModel model)
{
var user = await repository.UserManager.FindByNameAsync(User.Identity.Name);
if (user is null)
{
return(NotFound($"User with ID '{model.Id}' was not found"));
}
if (!await repository.UserManager.CheckPasswordAsync(user, model.ConfirmPassword))
{
ModelState.AddModelError(string.Empty, "Password is not correct");
return(View(model));
}
var result = await repository.UserManager.DeleteAsync(user);
if (!result.Succeeded)
{
throw new InvalidOperationException($"Exception caused deleting user, ID: '{model.Id}'");
}
await signInManager.SignOutAsync();
return(Redirect("~/"));
}
public IActionResult delete(int Id)
{
if (Id == 0)
{
return(NotFound());
}
var user = userRepository.GetUser(Id);
if (user == null)
{
return(NotFound());
}
var viewModel = new UserDeleteViewModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Id = user.Id
};
return(View(viewModel));
}
