public async Task <ActionResult> DeleteUser(string ID)
{
AppUser user = await UserManager.FindByIdAsync(ID);
if (user == null)
{
ViewBag.Error = $"Error occurred while looking for a user with ID = {ID}";
return(View("Error"));
}
TempData["Message"] = new Message()
{
Text = "Success! <strong>You have successfully deleted user.</strong>", ClassName = "alertMessage successful"
};
//First delete book from shelf
ShelfRepository.RemoveBooksFromUser(ID);
if (user.UserName == User.Identity.Name)
{
AuthManager.SignOut();
await UserManager.DeleteAsync(user);
return(RedirectToAction("List", "Book"));
}
await UserManager.DeleteAsync(user);
return(RedirectToAction("Index", "Admin"));
}
//[Authorize(Roles ="DeleteUser")]
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
Log log = new Log()
{
AppUserId = claims.FirstOrDefault().Value,
Content = Notification.DELETE_USER,
Created = DateTime.Now
};
_logService.Create(log);
_logService.Save();
return(request.CreateResponse(HttpStatusCode.OK, id));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.OK, string.Join(",", result.Errors)));
}
}
public async Task <ActionResult> Delete(string id)
{
AppUser user = await _userManager.FindByIdAsync(id);
if (user != null)
{
// Memorise all child entities.
user.Carts?.ToString();
user.Orders?.ToList();
user.Address?.ToString();
IdentityResult result = await _userManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
return(View("_Error", result.Errors));
}
}
else
{
return(View("_Error", new string[] { "User Not Found" }));
}
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
RequirePassword = await _userManager.HasPasswordAsync(user);
if (RequirePassword)
{
if (!await _userManager.CheckPasswordAsync(user, Input.Password))
{
ModelState.AddModelError(string.Empty, "Password not correct.");
return(Page());
}
}
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();
_logger.LogInformation("User with ID '{UserId}' deleted themselves.", userId);
return(Redirect("~/"));
}
public async Task <ActionResult> Delete(string id)
{
var identiyUser = await _userManager.FindByIdAsync(id);
if (identiyUser == null)
{
return(RedirectToAction("Index", "User"));
}
var result = _userManager.DeleteAsync(identiyUser);
return(RedirectToAction("Index", "User"));
}
public async Task <IHttpActionResult> DeleteUser(string id)
{
var user = await AppUserManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await AppUserManager.DeleteAsync(user);
return(result.Succeeded ? GetErrorResult(result):Ok());
}
return(NotFound());
}
public async Task <IHttpActionResult> DeleteApplicationUser(string id)
{
var applicationUser = await AppUserManager.FindByIdAsync(id);
if (applicationUser == null)
{
return(NotFound());
}
await AppUserManager.DeleteAsync(applicationUser);
return(Ok(applicationUser));
}
protected void Session_End(object sender, EventArgs e)
{
if ((Session["userId"] != null))
{
AppUserManager usermanager = new AppUserManager(new UserStore <AppUser>(new AppDbContext()));
var user = usermanager.FindById(Session["userId"].ToString());
var deleteresult = usermanager.DeleteAsync(user);
var token = user.Token;
new AuthorizeServiceClient().DeactivateToken(token);
}
}
public async Task <IHttpActionResult> DeleteUser()
{
var user = await AppUserManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(NotFound());
}
IdentityResult result = await AppUserManager.DeleteAsync(user);
return(result.Succeeded ? Ok() : GetErrorResult(result));
}
public ContentResult DeleteUser(string Id)
{
var user = _userManager.FindByIdAsync(Id).Result;
_userManager.DeleteAsync(user);
var json = JsonConvert.SerializeObject(new
{
id = 0,
success = true,
message = "User deleted successfully."
});
return(Content(json, "application/json"));
}
public async Task <IHttpActionResult> DeleteUser(string id)
{
//Only SuperAdmin or Admin can delete users (Later when implement roles)
var appUser = await AppUserManager.FindByIdAsync(id);
if (appUser == null)
{
return(NotFound());
}
var result = await AppUserManager.DeleteAsync(appUser);
return(result.Succeeded ? Ok() : GetErrorResult(result));
}
//[Authorize(Roles ="DeleteUser")]
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
return(request.CreateResponse(HttpStatusCode.OK, id));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.OK, string.Join(",", result.Errors)));
}
}
//[Authorize(Roles ="DeleteUser")]
public async Task <IHttpActionResult> Delete(string id)
{
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
return(Ok(id));
}
else
{
return(Ok(string.Join(",", result.Errors)));
}
}
public ActionResult Delete(long adminId)
{
AppUser deleteUser = userManager.FindByIdAsync(adminId).Result;
IdentityResult result = userManager.DeleteAsync(deleteUser).Result;
if (result.Succeeded)
{
TempData["message"] = "삭제되었습니다.";
return(RedirectToAction("Index"));
}
else
{
AddErrorsFromResult(result);
}
return(View());
}
public async Task <ActionResult> Delete(string id)
{
AppUser user = await _userManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await _userManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
return(View("Error", result.Errors));
}
return(View("Error", new string[] { "User Not Found" }));
}
public async Task <IHttpActionResult> DeleteUser(string id)
{
var appUser = await AppUserManager.FindByIdAsync(id);
if (appUser == null)
{
return(NotFound());
}
IdentityResult result = await AppUserManager.DeleteAsync(appUser);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public async System.Threading.Tasks.Task <IHttpActionResult> Delete(string name)
{
AppUserManager userMgr = new AppUserManager(new UserStore <AppUser>(db));
AppUser user = await userMgr.FindByNameAsync(name);
if (user != null)
{
IdentityResult result = await userMgr.DeleteAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok("OK"));
}
return(BadRequest(ModelState));
}
public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
UserName = userModel.Email,
Email = userModel.Email,
FirstName = userModel.FirstName,
LastName = userModel.LastName,
BirthDate = userModel.BirthDate.Value,
Gender = userModel.Gender.Value,
JoinDate = DateTime.Now.Date,
};
try
{
var addUserResult = await AppUserManager.CreateAsync(user, userModel.Password);
if (!addUserResult.Succeeded)
{
return(GetErrorResult(addUserResult));
}
//var user = await unitOfWork.AccountRepository.FindByNameAsync( createUserModel.Email );
string code = await AppUserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code = code }));
await AppUserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(Created(new Uri(Url.Link("GetUserById", new { id = user.Id })), user.ToDto()));
}
catch (Exception ex)
{
await AppUserManager.DeleteAsync(user);
throw new BusinessLogicException($"Could not create user: {ex.Message}");
}
}
//[Authorize(Roles ="DeleteUser")]
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
if (User != null && MemoryCacheHelper.RemoveUserEditByAdmin(User.Identity.Name))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, CommonConstants.Error_Edit_By_Admin));
}
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
return(request.CreateResponse(HttpStatusCode.OK, id));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.OK, string.Join(",", result.Errors)));
}
}
public async Task <RepositoryResult <UserInterfaceModel> > DeleteUserAsync(int id)
{
try
{
if (id <= 0)
{
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.BadRequest));
}
using (DataContext dbContext = DataContext.Create())
using (DbContextTransaction tx = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
UserModel user = await AppUserManager.FindByIdAsync(id);
if (user == null)
{
tx.Rollback();
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.NotFound));
}
IdentityResult result = await AppUserManager.DeleteAsync(user);
if (!result.Succeeded)
{
tx.Rollback();
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.BadRequest)
{
identityResult = result
});
}
tx.Commit();
return(new RepositoryResult <UserInterfaceModel>(HttpStatusCode.OK)
{
identityResult = result
});
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
try
{
if (string.IsNullOrEmpty(id))
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, nameof(id) + " không có giá trị"));
}
var appUser = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(appUser);
if (result.Succeeded)
{
return(request.CreateResponse(HttpStatusCode.OK, id));
}
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(",", result.Errors)));
}
catch (DbEntityValidationException ex)
{
foreach (var eve in ex.EntityValidationErrors)
{
Trace.WriteLine($"Entity of type \"{eve.Entry.Entity.GetType().Name}\" in state \"{eve.Entry.State}\" has the following validation error.");
foreach (var ve in eve.ValidationErrors)
{
Trace.WriteLine($"- Property: \"{ve.PropertyName}\", Error: \"{ve.ErrorMessage}\"");
}
}
LogError(ex);
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.InnerException.Message));
}
catch (DbUpdateException dbEx)
{
LogError(dbEx);
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dbEx.InnerException.Message));
}
catch (Exception ex)
{
LogError(ex);
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ex.Message));
}
}
public async Task <IActionResult> Delete(string id)
{
if (id == null)
{
throw new System.Exception("User not found");
}
//get User Data from Userid
var user = await _userManager.FindByIdAsync(id);
//Gets list of Roles associated with current user
var rolesForUser = await _userManager.GetRolesAsync(user);
using (var transaction = _userContext.Database.BeginTransaction())
{
if (rolesForUser.Count() > 0)
{
foreach (var item in rolesForUser.ToList())
{
// item should be the name of the role
var resultR = await _userManager.RemoveFromRoleAsync(user, item);
}
}
//Delete User
var result = await _userManager.DeleteAsync(user);
transaction.Commit();
if (result.Succeeded)
{
TempData["Message"] = "User Deleted Successfully. ";
TempData["MessageValue"] = "1";
return(RedirectToAction("Index"));
}
else
{
throw new System.Exception("Not deleted");
}
}
}
public async Task <HttpResponseMessage> Delete(HttpRequestMessage request, string id)
{
_userRoleService.DeleteByUserId(id);
_userRoleService.SaveChange();
AppUser user = await AppUserManager.FindByIdAsync(id);
var result = await AppUserManager.DeleteAsync(user);
if (result.Succeeded)
{
if (user.Avatar != null)
{
DeleteElementImage(user.Avatar);
}
return(request.CreateResponse(HttpStatusCode.OK, id));
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Join(",", result.Errors)));
}
}
//[Authorize(Roles = UserRoles.AllAdmins)] //TODO: Implement
public async Task <IHttpActionResult> DeleteUser(string id)
{
//TODO: Admin cannot delete registeradmin
// System Admin cannot be deleted
// Cannot delete users that belong to other service providers
var appUser = await AppUserManager.FindByIdAsync(id);
if (appUser != null)
{
IdentityResult result = await AppUserManager.DeleteAsync(appUser);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
return(NotFound());
}
public async Task <ActionResult> Delete(string id)
{
AppUser user = await UserManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await UserManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
return(View("Error", result.Errors));
}
}
else
{
return(View("Error", new string[] { "Пользователь не найден" }));
}
}
public async Task <IActionResult> Delete(string id)
{
AppUser user = await userManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await userManager.DeleteAsync(user);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
Errors(result);
}
}
else
{
ModelState.AddModelError("", "User Not Found");
}
return(View("Index", userManager.Users));
}
public async Task <IHttpActionResult> CreateUser(CreateUserBindingModel createUserModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
bool IsMarketer = false;
if (null != createUserModel.Marketer && !bool.TryParse(createUserModel.Marketer, out IsMarketer))
{
return(BadRequest());
}
bool IsAffiliate = false;
if (null != createUserModel.Affiliate && !bool.TryParse(createUserModel.Affiliate, out IsAffiliate))
{
return(BadRequest());
}
if (!IsMarketer && !IsAffiliate)
{
return(BadRequest("Affiliate or Marketer must be selected"));
}
if (IsAffiliate)
{
string error = ValidateCreateModel(createUserModel, Role.Affiliate);
if (!String.IsNullOrEmpty(error))
{
return(BadRequest(ModelState));
}
}
// check if the user created a program
if (IsMarketer)
{
string error = ValidateCreateModel(createUserModel, Role.Vendor);
if (!String.IsNullOrEmpty(error))
{
return(BadRequest(ModelState));
}
}
var user = new ApplicationUser()
{
UserName = createUserModel.Username,
Email = createUserModel.Email,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
Level = 3,
JoinDate = DateTime.Now.Date
};
IdentityResult addUserResult = await this.AppUserManager.CreateAsync(user, createUserModel.Password);
if (!addUserResult.Succeeded)
{
return(GetErrorResult(addUserResult));
}
// extend the user with specific information
var userExt = new UserExtension()
{
SkypeHandle = createUserModel.SkypeHandle,
UserId = user.Id,
IndividualDescription = createUserModel.IndividualDescription,
FirstName = createUserModel.FirstName,
LastName = createUserModel.LastName,
PhoneNumber = createUserModel.PhoneNumber,
Category = Convert.ToInt32(createUserModel.UserCategory)
};
UserExtManager.UserExtensions.Add(userExt);
try
{
int resultCount = await UserExtManager.Update();
}
catch (Exception ex)
{
// todo delete user here
try
{
await AppUserManager.DeleteAsync(user);
}
catch
{
// do our best to not create secondary errors
}
return(InternalServerError());
}
// check if the user created a program
if (IsMarketer)
{
AppUserManager.AddToRole(user.Id, "Vendor");
Program newProgram = new Program()
{
CreatedDate = DateTime.Now,
CreatorId = user.Id,
Description = createUserModel.ProgramDescription,
Url = createUserModel.ProgramUrl,
Name = createUserModel.ProgramName,
Category = Convert.ToInt32(createUserModel.ProgramCategory)
};
MarketManager.Programs.Add(newProgram);
await MarketManager.Update();
}
if (IsAffiliate)
{
AppUserManager.AddToRole(user.Id, "Affiliate");
}
Uri locationHeader = await SendConfirm(user);
return(Created(locationHeader, TheModelFactory.Create(user, userExt)));
}
public async Task <IdentityResult> DeleteAsync(ApplicationUser user)
{
return(await _userManager.DeleteAsync(user));
}
