public async Task <IActionResult> Delete(UserDeleteVM vm)
{
if (ModelState.IsValid)
{
IdentityUser user = await _userManager.FindByIdAsync(vm.UserId);
if (user == null)
{
return(NotFound());
}
IdentityResult result = await _userManager.DeleteAsync(user);
if (result.Succeeded)
{
_logger.LogInformation("User deleted successfully");
return(RedirectToAction(nameof(Index)).WithSuccess("User deletion done"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(vm));
}
public async Task <IActionResult> Delete(string id)
{
UserDeleteVM user;
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:55169/api/Users/" + id);
request.Headers.Add("Accept", "application/json");
var client = _httpClientFactory.CreateClient();
var response = await client.SendAsync(request).ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
using var responseStream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
user = await JsonSerializer.DeserializeAsync <UserDeleteVM>(responseStream);
}
else
{
user = new UserDeleteVM();
}
return(View(user));
}
// User Controller GET: Delete Page
public UserDeleteVM GetDeleteUser(string referenceId)
{
// get the user information from the passed in reference id
try
{
// get the role manager to get the user role
var roleManager = new RoleManager <ApplicationRole>(new RoleStore <ApplicationRole>(_context));
// load the values into the UserDeleteVM
UserDeleteVM userToBeDeleted = _context.Users.Where(u => u.UserDetail.ReferenceID == referenceId)
.Select(user => new UserDeleteVM()
{
ReferenceID = user.UserDetail.ReferenceID,
Email = user.Email,
// find the role id associated to the user
RoleName = user.Roles.FirstOrDefault().RoleId.ToString(),
// find the client id associated to the user
ClientReferenceID = user.UserDetail.Client.ReferenceID,
FirstName = user.UserDetail.FirstName,
LastName = user.UserDetail.LastName,
BusinessTitle = user.UserDetail.BusinessTitle,
BusinessPhone = user.UserDetail.BusinessPhone,
MobilePhone = user.UserDetail.MobilePhone,
HomePhone = user.UserDetail.HomePhone,
ClientName = user.UserDetail.Client.ClientName,
StatusID = user.UserDetail.Status.StatusID,
StatusName = user.UserDetail.Status.StatusName,
// get the applications associated with the user to be deleted
Applications = user.UserDetail.Applications.Select(a => new ApplicationVM()
{
ApplicationName = a.ApplicationName,
Description = a.Description,
URL = a.URL,
ReferenceID = a.ReferenceID
})
}).FirstOrDefault();
// get the actual role name assigned the user from the role id above
userToBeDeleted.RoleName = roleManager.FindById(userToBeDeleted.RoleName).Name.ToString();
return(userToBeDeleted);
}
catch (Exception e)
{
if (e is SqlException)
{
}
// if no user found return null and handle it in the controller
return(null);
}
}
public async Task <IActionResult> Delete(string id, UserDeleteVM userDelete)
{
var client = _httpClientFactory.CreateClient();
HttpResponseMessage httpResponseMessage = await client.DeleteAsync(new Uri("http://localhost:55169/api/Users/" + id)).ConfigureAwait(false);
if (httpResponseMessage.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(Index)));
}
return(View(userDelete));
}
public IActionResult Delete([FromBody] UserDeleteVM duser)
{
if (!ModelState.IsValid)
{
var errors = CustomValidator.GetErrorsByModel(ModelState);
return(BadRequest(errors));
}
var user = _context.Users.SingleOrDefault(p => p.Id == duser.Id);
if (user != null)
{
_context.Users.Remove(user);
_context.SaveChanges();
}
return(Ok());
}
public ActionResult Delete(UserDeleteVM model)
{
if (ModelState.IsValid)
{
// proceed if the user repository deleteuser method succeeded
if (_userRepo.DeleteUser(model.ReferenceID, model.ClientReferenceID, out string msg))
{
TempData["SuccessMsg"] = msg;
return(RedirectToAction("Index"));
}
TempData["ErrorMsg"] = msg;
}
// load the view with same information if the deletion failed
return(View(_userRepo.GetDeleteUser(model.ReferenceID)));
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserService _userService = new UserService();
User user = _userService.GetUserById(id.Value);
if (user == null)
{
return(HttpNotFound());
}
Mapper.CreateMap <User, UserDeleteVM>();
UserDeleteVM userDeleteVM = Mapper.Map <UserDeleteVM>(user);
return(View(userDeleteVM));
}
public async Task <IActionResult> Delete(string id)
{
if (id == null)
{
return(NotFound());
}
IdentityUser user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
UserDeleteVM vm = new UserDeleteVM()
{
Email = user.Email,
Username = user.UserName,
UserId = user.Id
};
return(View(vm));
}
public string Delete(UserDeleteVM user)
{
var http = (HttpWebRequest)WebRequest.Create(new Uri(_url));
http.Accept = "application/json";
http.ContentType = "application/json";
http.Method = "DELETE";
string parsedContent = JsonConvert.SerializeObject(user);
UTF8Encoding encoding = new UTF8Encoding();
Byte[] bytes = encoding.GetBytes(parsedContent);
Stream newStream = http.GetRequestStream();
newStream.Write(bytes, 0, bytes.Length);
newStream.Close();
var response = http.GetResponse();
var stream = response.GetResponseStream();
var sr = new StreamReader(stream);
var content = sr.ReadToEnd();
return(content.ToString());
}
public async Task <IActionResult> Delete([FromQuery] UserDeleteVM vm)
{
var _vm = Mapper.Map <User>(vm);
return(ExecMethod(() => ValidateEntry(new UserDeleteValidation(repo), _vm), () => repo.Delete(_vm)));
}
public Task <string> DeleteAsync(UserDeleteVM user)
{
return(Task.Run(() => Delete(user)));
}
