public async Task <IActionResult> EditUser(Guid id, AdminEditUserViewModel model)
{
ICreateEditEntityDto castedModel = (ICreateEditEntityDto)model;
castedModel.Area = "Admin";
castedModel.Controller = this.GetType().Name.Replace("Controller", string.Empty);
castedModel.Action = "Edit";
castedModel.EntityName = "User";
this.ViewData[BreadcrumbEntityNamePluralPlaceholder] = "Users";
this.ModelState.Remove("Area");
this.ModelState.Remove("Controller");
this.ModelState.Remove("Action");
this.ModelState.Remove("EntityName");
if (this.ModelState.IsValid)
{
if (await this.identityService.EditUserAsync(model.Id, model.Email, model.FirstName, model.LastName))
{
this.TempData["SuccessStatusMessage"] = "User data has been successfully edited.";
return(this.RedirectToAction("GetAll", this.ControllerName));
}
}
return(this.View("AbstractViews/Edit", castedModel));
}
public async Task <ActionResult> Edit(AdminEditUserViewModel model)
{
try
{
if (ModelState.IsValid)
{
var Db = new ApplicationDbContext();
var id = User.Identity.GetUserId();
var user = Db.Users.First(u => u.Email == model.Email);
if (!String.IsNullOrEmpty(model.NewPassword))
{
user.PasswordHash = new PasswordHasher().HashPassword(model.NewPassword);
}
// Update the user data:
user.FullName = model.FullName;
user.Email = model.Email;
user.Alias = model.Alias;
user.Suspended = model.Suspended;
Db.Entry(user).State = System.Data.Entity.EntityState.Modified;
await Db.SaveChangesAsync();
return(RedirectToAction("Index", "Account", new { area = "Admin" }));
}
}
catch (DataException)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save userId. Try again, and if the problem persists submit bug report.");
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public IActionResult EditUser(AdminEditUserViewModel viewModel)
{
if (_userService.GetOrCreateUser(User.Identity.Name).AuthLevel == Models.User.AuthType.Admin)
{
if (ModelState.IsValid)
{
User user = _userRepository.Get(viewModel.ID);
user.ImplantID = viewModel.ImplantID;
user.Pin = viewModel.Pin;
user.PSN = viewModel.PSN;
user.AuthLevel = viewModel.AuthLevel;
user.Email = viewModel.Email;
user.IsDonator = viewModel.IsDonator;
if (user.AuthLevel == Models.User.AuthType.Admin)
{
user.Bio = viewModel.Bio;
user.ProfilePic = viewModel.ProfilePic;
}
_userRepository.Update(user);
return(RedirectToAction("ManageUsers", "Admin", new { changeAction = "updated" }));
}
return(View());
}
else
{
return(RedirectToAction("Index", "Admin", new { changeAction = "unauth" }));
}
}
public async Task <ActionResult> EditUser(string id, AdminEditUserViewModel model)
{
try
{
//find the user by id and pass it to edit column
var user = UserManager.FindById(id);
//with the user found we get its the details
model.Email = user.Email;
var roles = await UserManager.GetRolesAsync(user.Id);
model.UserName = user.UserName;
foreach (var role in roles)
{
model.RoleName = role;
}
AdmnUserName = model.UserName;
AdmnUserEmail = model.Email;
AdmnUserRole = model.RoleName;
return(RedirectToAction("EditUser"));
}
catch
{
return(View());
}
}
public async Task <ActionResult> SaveUser(string id, AdminEditUserViewModel model)
{
try
{
AdmnUserRole = model.RoleName;
AdmnUserName = model.UserName;
//we find the user's ID by search the database with username
var userid = context.Users.Where(x => x.UserName == AdmnUserName).Select(x => x.Id).FirstOrDefault();
//with the user id we get user roles and create a string array of roles
var user = await UserManager.FindByIdAsync(userid);
var userRole = await UserManager.GetRolesAsync(user.Id);
string[] roles = new string[userRole.Count];
userRole.CopyTo(roles, 0);
//we remove any existing roles of the user
await UserManager.RemoveFromRolesAsync(user.Id, roles);
//we asign new role
await UserManager.AddToRoleAsync(user.Id, AdmnUserRole);
return(RedirectToAction("Index", "Administrator", new { Message = ManageMessageId.UserUpdate }));
}
catch
{
return(RedirectToAction("Index", "Administrator", new { Message = ManageMessageId.Error }));
}
}
//[Authorize(Roles = "Admin")]
public ActionResult Index(string fullName, string alias, string email, string role)
{
var Db = new ApplicationDbContext();
var allRoles = Db.Roles;
//var users = Db.Users;
var users = from u in Db.Users
select u;
//search for user
if (!String.IsNullOrEmpty(fullName))
{
fullName = fullName.Trim();
users = users.Where(u => u.FullName.ToUpper().Contains(fullName.ToUpper()));
}
if (!String.IsNullOrEmpty(alias))
{
alias = alias.Trim();
users = users.Where(u => u.Alias.ToUpper().Contains(alias.ToUpper()));
}
if (!String.IsNullOrEmpty(email))
{
email = email.Trim();
users = users.Where(u => u.Email.ToUpper().Contains(email.ToUpper()));
}
//order users and limit
users = users.Take(10).OrderBy(u => u.FullName);
var usersList = new List <AdminEditUserViewModel>();
foreach (var user in users.ToList())
{
var u = new AdminEditUserViewModel(user);
usersList.Add(u);
}
//search for role
if (!String.IsNullOrEmpty(role))
{
role = role.Trim();
// usersList = usersList.Where(u=>u.UserRoles.Where(usr=>usr.RoleName.Contains(role.ToUpper())));
var found = from pple in usersList
from guys in pple.UserRoles
where (guys.RoleName.ToUpper().Contains(role.ToUpper()))
select pple;
usersList = found.ToList();
}
return(View(usersList));
}
public async Task <ActionResult> Edit(string id)
{
ApplicationUser user = await UserManager.FindByIdAsync(id);
AdminEditUserViewModel userEditVM = new AdminEditUserViewModel(user);
if (user != null)
{
//return View(user);
return(View(userEditVM));
}
else
{
return(RedirectToAction("Index"));
}
}
//[Authorize(Roles = "Admin")]
public ActionResult Edit(string user, ManageMessageId?Message = null)
{
var Db = new ApplicationDbContext();
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var dbUser = Db.Users.First(u => u.UserName == user);
if (dbUser == null)
{
return(HttpNotFound());
}
var model = new AdminEditUserViewModel(dbUser);
ViewBag.MessageId = Message;
return(View(model));
}
public ActionResult EditUser(string id)
{
if (id == null)
{
return(RedirectToAction("Users"));
}
IUserRepository repo = RepoFactory.CreateUserRepo();
var user = repo.GetUserById(id);
var model = new AdminEditUserViewModel()
{
Email = user.Email,
FirstName = user.FirstName,
Id = User.Identity.GetUserId(),
Role = user.Role,
LastName = user.LastName
};
return(View(model));
}
public ActionResult EditUser(AdminEditUserViewModel modelUser)
{
if (modelUser.ConfirmPassword != modelUser.Password)
{
ModelState.AddModelError("", "confirm password did not match");
return(View(modelUser));
}
if (ModelState.IsValid)
{
var userMgr = HttpContext.GetOwinContext().GetUserManager <UserManager <AppUser> >();
AppUser newUser = new AppUser()
{
Id = modelUser.Id,
Email = modelUser.Email,
UserName = modelUser.Email
};
try
{
userMgr.Update(newUser);
}
catch { }
var identity = new ClaimsIdentity(newUser.Id);
IUserRepository repo = RepoFactory.CreateUserRepo();
repo.UpDateFirstLastName(modelUser.LastName, modelUser.FirstName, modelUser.Id);
var response = userMgr.ChangePassword(modelUser.Id, modelUser.OldPassword, modelUser.ConfirmPassword);
if (response.Succeeded)
{
return(RedirectToAction("Users", "Admin"));
}
foreach (string error in response.Errors)
{
ModelState.AddModelError("", error);
}
}
return(View(modelUser));
}
//[Authorize(Roles = "Admin")]
public ActionResult Delete(string user = null, bool?deleteError = false)
{
var Db = new ApplicationDbContext();
if (user == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (deleteError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Delete failed. Please try again, and if the problem persists send us a bug report.";
}
var dbUser = Db.Users.First(u => u.UserName == user);
if (dbUser == null)
{
return(HttpNotFound());
}
var model = new AdminEditUserViewModel(dbUser);
return(View(model));
}
public async Task <ActionResult> EditUser(string id)
{
var UserManager = AccountController.GetUserManager(HttpContext);
var user = await UserManager.FindByIdAsync(id);
var model = new AdminEditUserViewModel
{
UserId = id,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Role = UserManager.GetRoles(id).FirstOrDefault(),
RoleOptions = from r in ApplicationDbContext.Create().Roles
select new SelectListItem
{
Value = r.Name,
Text = r.Name
},
};
return(View(model));
}
public async Task <ActionResult> Edit([Bind(Include = "UserName, Email,Id")] AdminEditUserViewModel editUser, params string[] selectedRole)
{
if (ModelState.IsValid)
{
var user = await UserManager.FindByIdAsync(editUser.Id);
if (user == null)
{
return(HttpNotFound());
}
user.UserName = editUser.UserName;
user.Email = editUser.Email;
var userRoles = await UserManager.GetRolesAsync(user.Id);
selectedRole = selectedRole ?? new string[] { };
var result = await UserManager.AddToRolesAsync(user.Id, selectedRole.Except(userRoles).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
result = await UserManager.RemoveFromRolesAsync(user.Id, userRoles.Except(selectedRole).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", "Something failed.");
return(View());
}
public async Task <ActionResult> EditUser(AdminEditUserViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var UserManager = AccountController.GetUserManager(HttpContext);
// update name and/or email
var user = UserManager.FindById(model.UserId);
if (user == null)
{
return(RedirectToAction("Users", "Admin", new { Message = $"User {model.UserId} does not exist" }));
}
if (!model.FirstName.IsNullOrWhiteSpace())
{
user.FirstName = model.FirstName;
}
if (!model.LastName.IsNullOrWhiteSpace())
{
user.LastName = model.LastName;
}
if (!model.UserName.IsNullOrWhiteSpace())
{
user.UserName = model.UserName;
}
if (!model.Email.IsNullOrWhiteSpace())
{
user.Email = model.Email;
}
await UserManager.UpdateAsync(user);
// update password
if (!model.NewPassword.IsNullOrWhiteSpace() && model.NewPassword.Equals(model.ConfirmPassword))
{
UserManager.RemovePassword(model.UserId);
var result = UserManager.AddPassword(model.UserId, model.NewPassword);
if (result.Succeeded)
{
return(RedirectToAction("Users", "Admin", new { Message = "User Successfully Updated" }));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
return(View(model));
}
// update role
var roles = await UserManager.GetRolesAsync(model.UserId);
await UserManager.RemoveFromRolesAsync(model.UserId, roles.ToArray());
await UserManager.AddToRoleAsync(model.UserId, model.Role);
return(RedirectToAction("Users", "Admin", new { Message = "User Successfully Updated" }));
}
