public IdentityResult DeleteMemberShipUser(ApplicationUser user)
{
// first, remove all the roles for this user
_userManager.RemoveFromRoles(user.Id);
//then remove the user completely
var logins = user.Logins;
foreach (var login in logins.ToList())
{
_userManager.RemoveLogin(login.UserId, new UserLoginInfo(login.LoginProvider, login.ProviderKey));
}
var rolesForUser = _userManager.GetRoles(user.Id);
if (rolesForUser.Any())
{
foreach (var item in rolesForUser.ToList())
{
// item should be the name of the role
var result = _userManager.RemoveFromRole(user.Id, item);
}
}
return(_userManager.Delete(user));
}
/// <summary>
/// getting context
/// getting userid
/// getting user from row
/// getting userid from row
/// create a user manager
/// use user manager to get new roles
/// get rid of old roles
/// get index from role
/// find the control by calling row
/// get selected row value
/// add new role
/// save changed and bind grid
/// </summary>
/// <param name="sender"></param> is the grid view
/// <param name="e"></param> is the event
protected void GridViewRoles_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
ApplicationDbContext db = new ApplicationDbContext();
GridView grdRoles = (GridView)sender;
GridViewRow userRow = (GridViewRow)grdRoles.Parent.Parent;
int index = userRow.RowIndex;
string userId = gridViewUser.DataKeys[index]["Id"].ToString();
var user = db.Users.Find(userId);
var um = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
var roles = um.GetRoles(userId);
um.RemoveFromRoles(userId, roles.ToArray());
GridViewRow row = grdRoles.Rows[e.RowIndex];
DropDownList ddl = (DropDownList)row.FindControl("DropDownList1");
string role = ddl.SelectedValue.ToString();
um.RemoveFromRoles(userId, roles.ToArray());
um.AddToRole(userId, role.ToString());
db.SaveChanges();
BindGridView();
}
public void DisableUser(string UserId)
{
var roles = userManager.GetRoles(UserId).ToArray();
if (roles.Count() > 0)
{
userManager.RemoveFromRoles(UserId, roles);
}
}
public void EditUserRole(string userID, IEnumerable <string> roles)
{
var old = _appUserManager.GetRoles(userID).ToArray();
_appUserManager.RemoveFromRoles(userID, old);
foreach (var item in roles)
{
_appUserManager.AddToRole(userID, item);
}
}
public ActionResult Delete(string[] ids)
{
try
{
if (ids.Length != 0)
{
foreach (var id in ids)
{
var userId = Guid.Parse(id);
var objUser = (from user in ids select UserManager.FindById(userId)).FirstOrDefault();
//Task<IList<UserLoginInfo>> loginInfo = _userLoginStore.GetLoginsAsync(objUser);
//_userLoginStore.RemoveLoginAsync(objUser, loginInfo);
var lstUserRole = UserManager.GetRoles(userId);
UserManager.RemoveFromRoles(userId, lstUserRole.ToArray());
UserManager.Update(objUser);
UserManager.Delete(objUser);
}
}
}
catch (Exception ex)
{
LogText.Log(string.Concat("Post.Delete: ", ex.Message));
}
return(RedirectToAction("Index"));
}
// [Permission(Action = ActionName.CanUpdate)]
public IHttpActionResult Edit(string id, [FromBody] AppUserDto user)
{
return(CreateResponse(() =>
{
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
var model = UserManager.FindById(id);
Mapper.Map(user, model);
UserManager.Update(model);
if (user.Roles.Any())
{
var userRoles = UserManager.GetRoles(model.Id);
UserManager.RemoveFromRoles(model.Id, userRoles.ToArray());
UserManager.AddToRoles(model.Id, user.Roles.ToArray());
}
return Ok();
}));
}
private static void CreateUpdateUser(UserManager <ErasmusUser> manager, string email, string username, string role, int?uniId = null)
{
//Check for existing user
var user = manager.Users.SingleOrDefault(x => x.Email == email);
if (user == null)
{
//Doesn't exist - create
user = new ErasmusUser
{
Email = email, UserName = username, EmailConfirmed = true,
Birthday = new DateTime(1990, 1, 1),
UniversityId = uniId
};
manager.Create(user, "Slaptaþodis1");
manager.AddToRole(user.Id, role);
}
else
{
//Exists update
user.UserName = username;
user.EmailConfirmed = true;
manager.RemovePassword(user.Id);
manager.AddPassword(user.Id, "Slaptaþodis1");
manager.Update(user);
manager.RemoveFromRoles(user.Id, UserRoles.AllRoles);
manager.AddToRole(user.Id, role);
}
}
public async Task <ActionResult> UserForm(ApplicationUser model, FormCollection form)
{
var role = form["Roles"];
var pw = form["Password"];
var cpw = form["ConfirmPassword"];
var user = UserManager.FindByEmail(model.Email);
if (user != null)
{
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.MI = model.MI;
var result = await UserManager.UpdateAsync(user);
//Get roles of user
var roles = UserManager.GetRoles(user.Id);
//remove old roles
UserManager.RemoveFromRoles(user.Id, roles.ToArray());
//add new roles
UserManager.AddToRole(user.Id, role);
}
else
{
var result = await UserManager.CreateAsync(model, pw);
//add role
UserManager.AddToRole(model.Id, role);
}
return(RedirectToAction("UserForm", new { id = model.Id }));
}
public bool SetRole(string userId, int roleId)
{
try
{
using (var context = this.GetDataContext())
{
var user = context.Users.FirstOrDefault(it => it.Id == userId);
if (user == null)
{
return(false);
}
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
userManager.RemoveFromRoles(user.Id, new string[] { "Admin", "Owner" });
if (roleId == 1)
{
userManager.AddToRole(user.Id, "Admin");
}
else
{
userManager.AddToRole(user.Id, "Owner");
}
}
}
catch (System.Exception ex)
{
Debug.WriteLine(ex);
return(false);
}
return(true);
}
public void RemoveAllRoles(string userId)
{
var user = um.FindById(userId);
string[] allRoles = um.GetRoles(userId).ToArray();
um.RemoveFromRoles(userId, allRoles);
}
public ActionResult Roles(UserRoleViewModel user)
{
if (ModelState.IsValid)
{
var roles = db.AspNetUsers.Find(user.Id).AspNetRoles.ToList();
foreach (var item in roles)
{
UserManager.RemoveFromRoles(user.Id, item.Name);
}
db.SaveChanges();
AspNetUser users = db.AspNetUsers.Find(user.Id);
var role = db.AspNetRoles.Find(user.RoleId.ToString());
UserManager.AddToRole(user.Id, role.Name);
db.SaveChanges();
// users.AspNetRoles.Select();
// db.Entry(users).State = EntityState.Modified;
return(RedirectToAction("Index"));
}
ViewBag.RoleId = new SelectList(Utilities.Utilities.GetRoles(), "Id", "Name", user.RoleId);
return(View(user));
}
public IdentityResult RefreshUserGroupRoles(string userId)
{
var user = _userManager.FindById(userId);
if (user == null)
{
throw new ArgumentNullException("User");
}
var oldUserRoles = _userManager.GetRoles(userId);
if (oldUserRoles.Count > 0)
{
_userManager.RemoveFromRoles(userId, oldUserRoles.ToArray());
}
var newGroupRoles = GetUserGroupRoles(userId);
var allRoles = _roleManager.Roles.ToList();
var addTheseRoles = allRoles.Where(r => newGroupRoles.Any(gr => gr.RoleId == r.Id));
var roleNames = addTheseRoles.Select(n => n.Name).ToArray();
_userManager.AddToRoles(userId, roleNames);
return(IdentityResult.Success);
}
public ActionResult Edit([Bind(Include = "Email,Id")] EditUserViewModel editUser, params string[] selectedRoles)
{
if (ModelState.IsValid)
{
var user = UserManager.FindById(editUser.Id);
user.UserName = editUser.Email;
user.Email = editUser.Email;
var userRoles = UserManager.GetRoles(user.Id);
selectedRoles = selectedRoles ?? new string[] {};
var result = UserManager.AddToRoles(user.Id, selectedRoles.Except(userRoles).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
result = UserManager.RemoveFromRoles(user.Id, userRoles.Except(selectedRoles).ToArray <string>());
if (!result.Succeeded)
{
ModelState.AddModelError("", result.Errors.First());
return(View());
}
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult Edit(User user_1)
{
var user = userManager.FindById(user_1.UserId);
//var user = userManager.Users.FirstOrDefault(a => a.Id == user_1.UserId);
if (user != null)
{
user.StoreId = user_1.StoreId;
user.Email = user_1.Email;
//if (user_1.UserName != user.UserName)
//{
// user.UserName = user_1.UserName;
//}
user.FullName = user_1.FullName;
}
try
{
var result = userManager.Update(user);
var role = roleManager.FindById(user.Id);
if (role != null)
{
var roles = userManager.GetRoles(user.Id);
userManager.RemoveFromRoles(user.Id, roles.ToArray());
}
var result2 = userManager.AddToRole(user.Id, user_1.Role);
}
catch (Exception e)
{
}
return(Json(new { success = true }));
}
public ActionResult SaveUser(EditUserViewModel model)
{
if (ModelState.IsValid)
{
TimesheetService.IManagement service = new TimesheetService.ManagementClient();
TimesheetService.Employee emp = new TimesheetService.Employee();
emp.Id = model.ApiId;
emp.LastName = model.LastName;
emp.Name = model.Name;
emp.Email = model.Email;
service.UpdateEmployee(model.ApiId.ToString(), emp);
var roles = RoleManager.Roles;
var currentRoles = UserManager.FindById(model.Id).Roles;
foreach (var role in model.Roles)
{
role.Name = roles.Single(t => t.Id == role.Id).Name;
}
List <string> toRemove = new List <string>();
foreach (var item in currentRoles)
{
toRemove.Add(RoleManager.FindById(item.RoleId).Name);
}
var toAdd = model.Roles.Where(r => r.Selected == true).Select(r => r.Name).ToArray();
UserManager.RemoveFromRoles(model.Id, toRemove.ToArray());
UserManager.AddToRoles(model.Id, toAdd);
return(RedirectToAction("UserDetails", "Manage", new { id = model.Id }));
}
return(RedirectToAction("EditUser", "Manage", new { id = model.Id }));
}
public ActionResult Edit(UserEditViewModel model, string[] selectedRoles)
{
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
if (User.Identity.IsAuthenticated)
{
try
{
var UserToUpdate = db.AspNetUsers.Find(model.Id);
var roles = userManager.GetRoles(model.Id).ToArray();
userManager.RemoveFromRoles(model.Id, roles);
userManager.AddToRoles(model.Id, selectedRoles);
return(RedirectToAction("Index"));
}
catch (RetryLimitExceededException)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
else
{
return(RedirectToAction("Login", "Account"));
}
return(View(model));
}
public IActionResult UpdateProfile([FromBody] UpdateUser user)
{
System.Diagnostics.Debug.WriteLine($"{user.Email} {user.FirstName} {user.SecondName} {user.LastName} {user.Roles}");
var u = _userManager.GetByEmail(user.Email);
if (u != null)
{
if (u.FirstName != user.FirstName)
{
_logger.LogInformation($"User[{u.Email}], Changed FirstName: [{u.FirstName}] -> [{user.FirstName}] |");
u.FirstName = user.FirstName;
}
if (u.SecondName != user.SecondName)
{
_logger.LogInformation($"User[{u.Email}], Changed SecondName: [{u.SecondName}] -> [{user.SecondName}] |");
u.SecondName = user.SecondName;
}
if (u.LastName != user.LastName)
{
_logger.LogInformation($"User[{u.Email}], Changed LastName: [{u.LastName}] -> [{user.LastName}] |");
u.LastName = user.LastName;
}
var rolesBefore = _roleManager.GetAllRolesByUserId(u.Id);
_userManager.RemoveFromRoles(u.Email, rolesBefore.ToList());
var rolesAfter = user.Roles;
_userManager.AddToRoles(u.Email, rolesAfter.ToList());
rolesAfter = _roleManager.GetAllRolesByUserId(u.Id);
_userManager.UpdateUser(u);
return(Ok());
}
return(BadRequest(new { message = "No such user." }));
}
/// <summary>
/// change user role
/// </summary>
/// <param name="uid"></param>
/// <param name="roleId"></param>
/// <param name="isAdd"></param>
/// <returns></returns>
public AppConfigs.OperResult ChangeUserRole(string uid, string roleId, bool isAdd = true)
{
if (string.IsNullOrEmpty(uid) || string.IsNullOrWhiteSpace(roleId))
{
return(AppConfigs.OperResult.failDueToArgu);
}
ApplicationUser user = UserManager.FindById(uid);
string[] roles = UserManager.GetRoles(uid).ToArray();
if (roleId == "200" && roles.Length > 0)
{
UserManager.RemoveFromRoles(uid, roles);
return(AppConfigs.OperResult.success);
}
ApplicationRole rn = RoleManager.Roles.SingleOrDefault(a => a.Id == roleId); //find user role .
if (isAdd)
{
if (user.Roles.All(a => a.RoleId != roleId))
{
UserManager.AddToRole(uid, rn.Name);
return(AppConfigs.OperResult.success);
}
return(AppConfigs.OperResult.failDueToExist);
}
else
{
UserManager.RemoveFromRole(uid, rn.Name);
return(AppConfigs.OperResult.success);
}
}
public IHttpActionResult SetOwner(SetRoleBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _context.Users.SingleOrDefault(u => u.Id == model.AccountId);
if (user == null)
{
return(BadRequest("The user have account id " + model.AccountId + " does not exist."));
}
var owner = _context.Owners.SingleOrDefault(o => o.AccountId == user.Id);
if (owner == null)
{
return(BadRequest("The user have account id " + model.AccountId + " is not an Owner."));
}
var listRole = _userManager.GetRoles(user.Id);
if (listRole.Count > 0)
{
_userManager.RemoveFromRoles(user.Id, listRole.ToArray());
}
_userManager.AddToRole(user.Id, RoleName.Owner);
return(Ok("Approved"));
}
public ActionResult EditUser(UserEditViewModel model, string[] selectedRoles)
{
var uM = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));
if (User.Identity.IsAuthenticated) // if the user is already logged in
{
try
{
var UserToUpdate = db.AspNetUsers.Find(model.Id);
var roles = uM.GetRoles(model.Id).ToArray();
uM.RemoveFromRoles(model.Id, roles);
uM.AddToRoles(model.Id, selectedRoles);
return(RedirectToAction("UserList"));
}
catch (RetryLimitExceededException /* dex */)
{
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
else
{
return(RedirectToAction("Login", "Account"));
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public ResultObj UpdateProfile(Profile profile)
{
ResultObj results;
try
{
if (!IsValidProfile(profile))
{
return(WebHelpers.BuildResponse(profile, "Role must have a name and at least one profile.", false, 1));
}
var oldRoles = new BaseRepository <Profile>().Get(profile.Id).Privileges.Split(',');
var newRoles = profile.Privileges.Split(',');
var users = _userRepo.Get(new UserFilter {
ProfileId = profile.Id
});
foreach (var user in users)
{
UserManager.RemoveFromRoles(user.Id, oldRoles);
var user1 = user;
newRoles.ForEach(r => UserManager.AddToRole(user1.Id, r.Trim()));
}
new BaseRepository <Profile>().Update(profile);
results = WebHelpers.BuildResponse(profile, "Role Update Successfully.", true, 1);
}
catch (Exception ex)
{
results = WebHelpers.ProcessException(ex);
}
return(results);
}
private void DeleteUserById(string id)
{
ApplicationUser entity = GetUser(id); // not use "await DoGet(id);" in synchronized function
var logins = entity.Logins.ToList();
var claims = entity.Claims.ToList();
foreach (var login in logins)
{
entity.Logins.Remove(login);
}
foreach (var claim in claims)
{
entity.Claims.Remove(claim);
}
//是否有修改角色
var childUserRoleId = GetIdentityRole(id).Id;
var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));
string childUserRoleName = GetRoleName(childUserRoleId);
if (!string.IsNullOrEmpty(childUserRoleName))
{
userManager.RemoveFromRoles(id, childUserRoleName);
}
userManager.Delete(entity);
}
public void ClearUserRoles(string userId)
{
var user = UserManager.FindById(userId);
var roles = _db.Roles.Where(p => user.Roles.Any(p1 => p1.RoleId == p.Id)).Select(p => p.Name).ToArray();
UserManager.RemoveFromRoles(userId, roles);
}
internal bool UpdateUser(string username, string realUsername, string permission)
{
IdentityResult result = null;
Models.ApplicationDbContext context = new Models.ApplicationDbContext();
var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
var user = userMgr.FindByName(username);
if (!string.IsNullOrEmpty(realUsername))
{
user.RealUserName = realUsername;
result = userMgr.Update(user);
}
if (!string.IsNullOrEmpty(permission) && !userMgr.IsInRole(user.Id, permission))
{
userMgr.RemoveFromRoles(user.Id, "read", "edit", "administrator");
switch (permission)
{
case "administrator":
result = userMgr.AddToRole(user.Id, "administrator");
break;
case "edit":
result = userMgr.AddToRole(user.Id, "edit");
break;
default:
result = userMgr.AddToRole(user.Id, "read");
break;
}
}
if (result == IdentityResult.Success) return true; else return false;
}
public ActionResult DeleteRole(string UserName, string RoleName)
{
try
{
if ((UserName == null) || (RoleName == null))
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
UserName = UserName.ToLower();
//Check that we have an actual user
ExpandedUserDTO objExpandedUserDTO = GetUser(UserName);
if (objExpandedUserDTO == null)
{
return(HttpNotFound());
}
if (UserName.ToLower() == this.User.Identity.Name.ToLower() && RoleName == "Administrator")
{
ModelState.AddModelError(string.Empty, "Error: Cannot delete Administrator Role for the current user");
}
//Go get the user
ApplicationUser user = UserManager.FindByName(UserName);
//Remove User from Role
UserManager.RemoveFromRoles(user.Id, RoleName);
UserManager.Update(user);
ViewBag.AddRole = new SelectList(RolesUserIsNotIn(UserName));
return(RedirectToAction("EditRoles", new { UserName = UserName }));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, "Error: " + ex);
ViewBag.AddRole = new SelectList(RolesUserIsNotIn(UserName));
UserAndRoleDTO objUserAndRolesDTO = GetUserAndRoles(UserName);
return(View("EditRoles", objUserAndRolesDTO));
}
}
public ActionResult ConfirmWedding(int WeddingId, WeddingViewModels WeddingViewModels, bool Confirmed)
{
using (var db = new OtherDbContext())
{
var UserContextWedding = db.Weddings.Where(x => x.Id == WeddingId).FirstOrDefault();
UserContextWedding.IsConfirmed = Confirmed;
var UserId = UserContextWedding.UserId;
db.Weddings.Add(UserContextWedding);
db.Entry(UserContextWedding).State = EntityState.Modified;
db.SaveChanges();
//Wysyłanie maila do pary młodej oraz nadawanie automatycznie uprawnień superusera.
using (var userdb = new ApplicationDbContext())
{
var UserWithWedding = userdb.Users.Where(x => x.Id == UserId).FirstOrDefault();
EmailHelper.SendEmail("Administrator portalu BlueBinders.pl potwierdzil Twoje wesele i nadal Ci specjalne uprawnienia!" +
" Od teraz mozesz zarzadzac zadaniami i profilem!", "Zatwierdzono wesele", UserWithWedding.Email);
List <IdentityRole> ir = userdb.Roles.Include(r => r.Users).ToList();
var userStore = new UserStore <IdentityUser>();
var manager = new UserManager <IdentityUser>(userStore);
var currentRole = manager.GetRoles(UserWithWedding.Id);
manager.RemoveFromRoles(UserWithWedding.Id, currentRole[0]);
manager.AddToRole(UserWithWedding.Id, "suser");
userdb.Users.Add(UserWithWedding);
userdb.Entry(UserWithWedding).State = EntityState.Modified;
userdb.SaveChanges();
}
}
return(RedirectToAction("UsersList"));
}
//public void ClearUserRoles(string userId)
//{
// var um = new UserManager<ApplicationUser>(
// new UserStore<ApplicationUser>(new ApplicationDbContext()));
// var user = um.FindById(userId);
// var currentRoles = new List<IdentityUserRole>();
// currentRoles.AddRange(user.Roles);
// foreach (var role in currentRoles)
// {
// //um.RemoveFromRole(userId, role.Role.Name);
// um.RemoveFromRole(userId, role.RoleId);
// }
//}
public void ClearUserRoles(string userId)
{
var um = new UserManager <ApplicationUser>(
new UserStore <ApplicationUser>(new ApplicationDbContext()));
um.RemoveFromRoles(userId);
}
public IHttpActionResult UpdateUser(FrontendUserModel model)
{
if (ModelState.IsValid)
{
bool passwordOk = true;
bool passwordPresent = false;
if (model.Password != null && model.Password != "")
{
passwordOk = Task.Run(async() => { return(await UserManager.PasswordValidator.ValidateAsync(model.Password)); }).Result.Succeeded;
passwordPresent = true;
}
if (passwordOk)
{
ApplicationUser user = UserManager.FindByName(model.Username);
if (user != null)
{
string newPasswordHash = UserManager.PasswordHasher.HashPassword(model.Password);
if (passwordPresent)
{
user.PasswordHash = newPasswordHash;
}
if (UserManager.Update(user).Succeeded)
{
UserManager.RemoveFromRoles(user.Id, ApplicationRoleManager.DefinedRoles.ToArray());
foreach (string roleName in model.Roles)
{
UserManager.AddToRole(user.Id, roleName);
}
return(Ok());
}
}
}
}
return(BadRequest());
}
public async Task <IHttpActionResult> DeleteUser(DeleteUserBindingModel model)
{
if (string.IsNullOrEmpty(model.Id))
{
return(BadRequest());
}
try
{
var user = await UserManager.FindByIdAsync(model.Id);
IdentityResult result = await UserManager.DeleteAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
else
{
UserManager.RemoveFromRoles(model.Id, UserManager.GetRoles(model.Id).ToArray());
return(Ok());
}
}
catch (Exception ex)
{
throw ex;
}
}
public IdentityResult DeleteUser(string username)
{
var user = _userManager.FindByName(username);
var rolesForUser = _userManager.GetRoles(user.Id);
string[] rolesArray = new string[rolesForUser.Count];
for (int i = 0; i < rolesForUser.Count(); i++)
{
rolesArray[i] = rolesForUser.ElementAt(i).ToString();
}
var remFromRole = _userManager.RemoveFromRoles(user.Id, rolesArray);
if (remFromRole.Succeeded)
{
var results = _userManager.Delete(user);
if (results.Succeeded)
{
return(results);
}
else
{
return(results);
}
}
else
{
return(remFromRole);
}
}
public void EditUser(UserRoleViewModel viewModel)
{
//seed file concept, M4 L11
viewModel.AppUser.UserName = viewModel.AppUser.Email;
var store = new UserStore <AppUser>(dealerDb);
var userMgr = new UserManager <AppUser>(new UserStore <AppUser>(dealerDb));
var roleMgr = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(dealerDb));
AppUser update = userMgr.FindById(viewModel.AppUser.Id);
update.FirstName = viewModel.AppUser.FirstName;
update.LastName = viewModel.AppUser.LastName;
update.Email = viewModel.AppUser.Email;
if (!string.IsNullOrEmpty(viewModel.Password) && !string.IsNullOrEmpty(viewModel.ConfirmPassword))
{
update.PasswordHash = userMgr.PasswordHasher.HashPassword(viewModel.ConfirmPassword);
}
userMgr.RemoveFromRoles(update.Id, userMgr.GetRoles(update.Id).ToArray());
userMgr.Update(update);
var user = userMgr.FindById(viewModel.AppUser.Id);
var role = roleMgr.FindById(viewModel.RoleId);
userMgr.AddToRole(user.Id, role.Name);
dealerDb.SaveChanges();
}
public async Task<ActionResult> AssignRole(string username, string rolename)
{
UserStore<ApplicationUser> userStore = new UserStore<ApplicationUser>(_identityDb);
UserManager<ApplicationUser> userManager = new UserManager<ApplicationUser>(userStore);
var user = userManager.Users.FirstOrDefault(u => u.UserName == username);
await Task.Run(() => userManager.RemoveFromRoles(user.Id, userManager.GetRoles(user.Id).ToArray()));
//var role = roles.FirstOrDefault(r => r == rolename);
//if(role == null)
userManager.AddToRole(user.Id, rolename);
return RedirectToAction("Users", "Admin");
}
protected void grvUsers_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
var row = grvUsers.Rows[e.RowIndex];
var id = grvUsers.DataKeys[e.RowIndex].Value.ToString();
var firstName = ((TextBox)row.FindControl("txtFirstName")).Text;
var lastName = ((TextBox)row.FindControl("txtLastName")).Text;
var email = ((TextBox)row.FindControl("txtEmail")).Text;
var currentPassword = ((TextBox)row.FindControl("txtCurrentPassword")).Text;
var newPassword = ((TextBox)row.FindControl("txtNewPassword")).Text;
var role = ((DropDownList)row.FindControl("ddlRoleEdit")).Text;
var jobClinic = ((DropDownList)row.FindControl("ddlJobClinicEdit")).Text; //TODO: Automatically edit RelationType (exept Writer) on files.
var isActive = ((CheckBox)row.FindControl("chkIsActive")).Checked;
var userStore = new UserStore<IdentityUser>();
var userManager = new UserManager<IdentityUser>(userStore);
var user = userManager.FindById(id);
if (user != null && (
userManager.FindById(SharedClass.CurrentUser).UserName == "Admin" ||
user.UserName != "Admin"
))
{
if (newPassword != "")
{
var result = userManager.ChangePassword(id, currentPassword, newPassword);
}
userManager.SetEmail(id, email);
userManager.RemoveFromRoles(id, userManager.GetRoles(id).ToArray());
userManager.AddToRole(id, role);
using (Medical_Clinic_Entities mc = new Medical_Clinic_Entities())
{
BSI__Clinic_Employee employee = mc.BSI__Clinic_Employees.Where(o => o.Id == id).First();
employee.First_Name = firstName;
employee.Last_Name = lastName;
employee.Job_Clinic = jobClinic;
employee.Is_Active = isActive;
mc.SaveChanges();
}
}
grvUsers.EditIndex = -1;
}
private JsonResult ChangeUserAdminStatus(string userId, bool admin)
{
var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(_db));
ApplicationUser user = userManager.FindById(userId);
IdentityResult result = null;
if (admin)
result = userManager.AddToRole(userId, "Admin");
else
result = userManager.RemoveFromRoles(userId, "Admin");
string errors = "";
foreach (string er in result.Errors)
{
errors += er + " ";
}
if (result.Succeeded)
return Json(new AppMessage() { Type = AppMessage.Success, Message = String.Format(AppString.UserIsNow, user.Email, admin ? AppString.PartialIsNowAdmin : AppString.PartialIsNoLongerAdmin) });
else
return Json(new AppMessage() { Type = AppMessage.Error, Message = String.Format(AppString.UpdateForTypeFailed, AppString.User) + " " + errors });
}
public ActionResult Edit([Bind(Include = "FirstName,LastName,Email,PhoneNumber,UserName")] ApplicationUser applicationUser)
{
if (ModelState.IsValid)
{
var userStore = new UserStore<ApplicationUser>(db);
var userManager = new UserManager<ApplicationUser>(userStore);
string userId = userManager.FindByName(applicationUser.UserName).Id;
userManager.RemoveFromRoles(userId, userManager.GetRoles(userId).ToArray());
userManager.AddToRoles(userId, Request["Role"].Split(','));
userManager.Update(applicationUser);
return RedirectToAction("Index");
}
return View(applicationUser);
}
