public async Task <IActionResult> Edit(string userId)
{
// получаем пользователя
IdentityUser user = await userManager.FindByIdAsync(userId);
if (user != null)
{
// получем список ролей пользователя
var userRoles = await userManager.GetRolesAsync(user);
var allRoles = roleManager.Roles.ToList();
ChangeRoleModel model = new ChangeRoleModel
{
UserId = user.Id,
UserEmail = user.Email,
UserRoles = userRoles,
AllRoles = allRoles
};
return(View(model));
}
return(NotFound());
}
public async Task <ActionResult> ChangeRole(string userId)
{
if (userId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var role = await UserService.GetUserRole(userId);
ChangeRoleModel model = new ChangeRoleModel
{
UserId = userId,
OldRole = role,
Role = role
};
var userRole = UserService.GetUserRole(userId);
var roles = AccountService.GetAllRoles().ToList();
ViewBag.Role = new SelectList(
roles,
"Name",
"Description",
model.Role);
return(View(model));
}
public eErrors ChangeRole(ChangeRoleModel i_Model)
{
eErrors error = eErrors.None;
using (MyDiveEntities MyDiveDB = new MyDiveEntities())
{
ObjectResult <int?> serverResult = MyDiveDB.stp_GetUserRole(i_Model.AdminId);
List <int> result = new List <int>();
foreach (int res in serverResult)
{
result.Add(res);
}
if (result.Count > 0)
{
if (result[0] == 1)
{
MyDiveDB.stp_ChangeUserRole(i_Model.UserId, (int)i_Model.Role);
}
else
{
error = eErrors.UserIsNotAdmin;
}
}
else
{
error = eErrors.AdminNotExist;
}
}
return(error);
}
public async Task <IdentityResult> ChangeRole(ChangeRoleModel model)
{
bool roleExist = this.RoleManager.RoleExistsAsync(model.UpdatedRole).Result;
var user = this.UserManager.FindByIdAsync(model.Id).Result;
var currentRole = await this.UserManager.GetRolesAsync(user);
IdentityResult result = null;
if (!roleExist && !currentRole.Any())
{
return(IdentityResult.Failed());
}
if (!roleExist && currentRole.Any())
{
await this.UserManager.RemoveFromRoleAsync(user, currentRole.First());
return(IdentityResult.Success);
}
if (roleExist && !currentRole.Any())
{
result = await this.UserManager.AddToRoleAsync(user, model.UpdatedRole);
}
else
{
await this.UserManager.RemoveFromRoleAsync(user, currentRole.First());
result = await this.UserManager.AddToRoleAsync(user, model.UpdatedRole);
}
return(result);
}
public ActionResult ChangeRole(int?id)
{
// Получаем редактируемого пользователя из БД
User user = db.Users.FirstOrDefault(p => p.Id == id);
// Если пользователь найден
if (user != null)
{
// Формируем список для dropdown
SelectList roles;
// Админ может присвоить роль модератора, пользователя или забанить
if (User.IsInRole("Admin"))
{
roles = new SelectList(db.Roles.Where(p => p.Id > 1), "Id", "Description");
}
// Модератор может присвоить роль пользователя или забанить
else
{
roles = new SelectList(db.Roles.Where(p => p.Id > 2), "Id", "Description");
}
ViewBag.Roles = roles;
ViewBag.UserName = user.Login;
ChangeRoleModel model = new ChangeRoleModel();
model.UserId = user.Id;
model.RoleId = (int)user.RoleId;
return(View(model));
}
// иначе выводим ошибку
else
{
return(View("Error"));
}
}
public async Task <ActionResult> ChangeRole(string userId)
{
var user = await UserManager.FindByIdAsync(userId);
var model = new ChangeRoleModel();
if (user == null)
{
ModelState.AddModelError("", "Usuário não encontrado");
}
else
{
model.Role = user.Roles.FirstOrDefault().RoleId ?? "";
model.UserId = userId;
}
var r = RoleList.CreateSelectableList(Database);
//foreach (var role in r)
//{
// role.Selected = (role.Text == model.Role);
//}
ViewBag.Roles = r;
return(View(model));
}
public ActionResult ChangeRole(ChangeRoleModel model)
{
if (ModelState.IsValid)
{
// Получаем пользователя и роль из БД
User user = db.Users.FirstOrDefault(p => p.Id == model.UserId);
Role role = db.Roles.FirstOrDefault(p => p.Id == model.RoleId);
// Если такие записи найдены в БД
if (user != null && role != null)
{
// Изменяем и сохраняем запись пользователя
user.Role = role;
db.Entry(user).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Profile/" + user.Login, "Account"));
}
// иначе добавляем сообщение об ошибке
else
{
ModelState.AddModelError("", "Ошибка при изменении роли...");
}
}
else
{
ModelState.AddModelError("", "Ошибка при изменении роли...");
}
return(View(model));
}
public IActionResult ChangeRole(string id)
{
if (String.IsNullOrEmpty(id))
{
return(NotFound().WithError(LOCALIZATION_ERROR_NOT_FOUND));
}
var account = _userManager.Users.Where(u => u.Id == id)?.First();
if (account == null)
{
return(NotFound().WithError(LOCALIZATION_ERROR_NOT_FOUND));
}
var roles = _userManager.GetRolesAsync(account)?.Result;
ChangeRoleModel model = new ChangeRoleModel
{
Id = account.Id,
Email = account.Email,
Username = account.UserName,
Roles = roles == null ? new List <string>() : roles.ToList(),
};
return(View(model));
}
public async Task <ActionResult> ChangeRole([Bind(Include = "UserId,OldRole,Role")] ChangeRoleModel model)
{
if (ModelState.IsValid)
{
try
{
ChangeRoleDTO changeRoleDTO = new ChangeRoleDTO
{
UserId = model.UserId,
OldRole = model.OldRole,
Role = model.Role
};
await UserService.ChangeUserRole(changeRoleDTO);
TempData["success"] = "Изменения сохранены.";
}
catch (Exception)
{
ModelState.AddModelError("", "Произошла ошибка. Попробуйте еще раз либо обратитесь к администратору.");
}
}
ViewBag.Role = GetRoleNameSelectList(model.Role);
return(View());
}
public PartialViewResult ChangeUserRole(string userId, string email)
{
var model = new ChangeRoleModel
{
UserId = userId,
Email = email
};
return(PartialView("_ChangeRole", model));
}
public async Task <ActionResult> ChangeRole(ChangeRoleModel model)
{
var user = await _userManager.FindByIdAsync(model.Id);
await UpdateRoleStatus(user, UserRoleName, model.IsVerified);
await UpdateRoleStatus(user, MaintainerRoleName, model.CanUpload);
await _userManager.UpdateSecurityStampAsync(user);
return(RedirectToAction("Index"));
}
public async Task <HttpResponseMessage> Update(ChangeRoleModel model)
{
Thread.CurrentThread.CurrentCulture = culture;
var role = "";
if (model.roleId == "0")
{
role = "Administrador";
}
else if (model.roleId == "1")
{
role = "Provider";
}
else if (model.roleId == "2")
{
role = "User";
}
try
{
using (SqlConnection connection1 = new SqlConnection(connetionString))
{
await connection1.OpenAsync();
string roleid = await GetRoleId(connection1, role);
if (roleid != "")
{
await doChangeRole(connection1, model, roleid);
}
}
}
catch (TransactionAbortedException ex)
{
ErrorModel _errors = new ErrorModel();
_errors.message = ex.Message;
return(Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, _errors));
}
catch (ApplicationException ex)
{
ErrorModel _errors = new ErrorModel();
_errors.message = ex.Message;
return(Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, _errors));
}
catch (Exception ex)
{
ErrorModel _errors = new ErrorModel();
_errors.message = ex.Message;
return(Request.CreateResponse(System.Net.HttpStatusCode.InternalServerError, _errors));
}
return(Request.CreateResponse(System.Net.HttpStatusCode.OK));
}
public IActionResult EditRole(ChangeRoleModel inputModel)
{
var result = this.AdminService.ChangeRole(inputModel).Result;
if (result == IdentityResult.Success)
{
return(RedirectToAction(nameof(AllUsers)));
}
this.ViewData[GlobalConstants.Error] = GlobalConstants.RoleChangeError;
return(this.EditRole(inputModel.Id));
}
public ActionResult ChangeRole(ChangeRoleModel model)
{
ApplicationUser user = UserManager.FindById(model.UserId);
string oldRole = user.Roles.ToList()[0].RoleId;
oldRole = db.Roles.Where(r => r.Id == oldRole).First().Name;
UserManager.RemoveFromRole(user.Id, oldRole);
UserManager.AddToRole(user.Id, model.Role);
return(RedirectToAction("Index", "Users"));
}
public async Task <IActionResult> UpdateRole(ChangeRoleModel model)
{
var user = _dbContext.Users.Single(x => x.Id == model.UserRoles.First().UserId);
var roles = await _userManager.GetRolesAsync(user);
await _userManager.RemoveFromRolesAsync(user, roles);
var role = _dbContext.Roles
.Single(x => x.Id == model.UserRoles.First().RoleId);
await _userManager.AddToRoleAsync(user, role.Name);
StatusMessage = "Role Updated";
return(RedirectToAction(nameof(ManageUsers)));
}
public void ChangeRoleShouldFailWithNonExistantRole()
{
//arrange
var roles = new[]
{
"admin",
"user"
};
foreach (var currentRolename in roles)
{
var role = new IdentityRole
{
Name = currentRolename
};
this.roleManager.CreateAsync(role).GetAwaiter();
}
var user = new GetShreddedUser
{
Id = "UserIdTests",
UserName = "******",
FirstName = "UserFirstNameTests",
LastName = "UserLastNameTests",
};
this.userManager.CreateAsync(user).GetAwaiter();
this.Context.SaveChanges();
//act
string newRole = "RoleTests";
var model = new ChangeRoleModel
{
Id = user.Id,
ApplicationRoles = roles,
UpdatedRole = newRole,
Username = user.UserName,
Role = GlobalConstants.DefaultRole
};
var methodResult = this.adminService.ChangeRole(model);
//assert
methodResult.Should().Equals(IdentityResult.Failed());
}
public async Task <PartialViewResult> ChangeUserRole(ChangeRoleModel changeRoleModel)
{
if (ModelState.IsValid)
{
var result = await UserService.ChangeUserRole(changeRoleModel.Role, changeRoleModel.UserId);
if (result.Succedeed)
{
ViewBag.ChangeRoleStatus = "Success";
return(PartialView("_ChangeRole", changeRoleModel));
}
ModelState.AddModelError(result.Property, result.Message);
}
ViewBag.ChangeRoleStatus = "Fail";
return(PartialView("_ChangeRole", changeRoleModel));
}
public async Task <ActionResult> ChangeRole(string id)
{
var user = _userManager.Users.Where(x => x.Id == id).Include(x => x.Roles).First();
var verifiedRoleId = await GetVerifiedRoleId();
var maintainerRoleId = await GetMaintainerRoleId();
var model = new ChangeRoleModel
{
Id = user.Id,
UserName = user.UserName,
IsVerified = user.Roles.Any(r => r.RoleId == verifiedRoleId),
CanUpload = user.Roles.Any(r => r.RoleId == maintainerRoleId)
};
return(View(model));
}
public async Task <IActionResult> Edit(string userId)
{
User user = await _userManager.FindByIdAsync(userId);
if (user != null)
{
var userRoles = await _userManager.GetRolesAsync(user);
var allRoles = _roleManager.Roles.ToList();
ChangeRoleModel model = new ChangeRoleModel {
UserId = user.Id, UserEmail = user.Email, UserRoles = userRoles, AllRoles = allRoles
};
return(View(model));
}
return(NotFound());
}
public async Task <ActionResult> Edit(string Id)
{
ApplicationRole role = await RoleManager.FindByIdAsync(Id);
if (role == null)
{
return(View("Error", new string[] { "该角色不存在！" }));
}
ChangeRoleModel model = new ChangeRoleModel
{
Id = role.Id,
RoleName = role.Name,
Description = role.Description
};
return(View(model));
}
public ActionResult RoleChange(ChangeRoleModel model)
{
#region role and is logged in
if (Session["uname"] == null || Session["uname"].ToString() == "")
{
return(RedirectToAction("Login", "User"));
}
if (Session["role"].ToString() != "Admin")
{
return(RedirectToAction("Index", "Unauthorised"));
}
#endregion
Database d = Database.CurrentInstance;
AESCryptoStuff aes_obj = AESCryptoStuff.CurrentInstance;
try
{
if (d.OpenConnection())
{
string queryString = "UPDATE dububase.users SET role = @role Where username=@username;";
MySqlCommand cmd = new MySqlCommand(queryString, d.conn);
cmd.CommandText = queryString;
cmd.Parameters.AddWithValue("@role", model.NewRole);
cmd.Parameters.AddWithValue("@username", model.Username);
cmd.ExecuteNonQuery();
return(RedirectToAction("UserProfile", "Admin", new { username = model.Username }));
}
}catch (System.Data.SqlClient.SqlException ex)
{
string errorMsg = "Error";
errorMsg += ex.Message;
throw new Exception(errorMsg);
}
finally
{
d.CloseConnection();
}
//change to somewhere
return(View());
}
public async Task <IActionResult> ChangeRole(string id)
{
User user = await userManager.FindByIdAsync(id);
if (user != null)
{
var userRoles = await userManager.GetRolesAsync(user);
var allRoles = roleManager.Roles.ToList();
ChangeRoleModel model = new ChangeRoleModel {
Id = user.Id, UserName = user.UserName, Roles = allRoles, UserRoles = userRoles
};
return(View(model));
}
else
{
return(NotFound());
}
}
public IActionResult UpdateRole(string userId)
{
var user = _dbContext.Users.Single(x => x.Id == userId);
List <IdentityUserRole <string> > userRoles = _dbContext.UserRoles.Where(x => x.UserId == userId).ToList();
var model = new ChangeRoleModel
{
User = user,
Roles = _dbContext.Roles
.Select(x => new { x.Id, x.Name })
.AsEnumerable()
.Select(x => new Tuple <string, string>(x.Id, x.Name))
.ToList(),
UserRoles = userRoles
};
return(View(model));
}
private async Task doChangeRole(SqlConnection connection1, ChangeRoleModel model, string roleId)
{
String commandText1 = "UPDATE AspNetUserRoles " +
"SET RoleId = @roleId " +
"WHERE UserId = @userId";
SqlCommand command1 = new SqlCommand(commandText1, connection1);
SqlParameter parameter = new SqlParameter("@roleId", SqlDbType.VarChar);
parameter.Value = roleId;
command1.Parameters.Add(parameter);
parameter = new SqlParameter("@userId", SqlDbType.VarChar);
parameter.Value = model.userId;
command1.Parameters.Add(parameter);
await command1.ExecuteNonQueryAsync();
}
public async Task <ActionResult> ChangeRole(string userId)
{
if (userId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var role = await UserService.GetUserRole(userId);
ChangeRoleModel model = new ChangeRoleModel
{
UserId = userId,
OldRole = role,
Role = role
};
ViewBag.Role = GetRoleNameSelectList(model.Role);
return(View(model));
}
public async Task <ActionResult> Edit(ChangeRoleModel role)
{
ApplicationRole mroles = await RoleManager.FindByIdAsync(role.Id);
if (!ModelState.IsValid)
{
return(View(role));
}
mroles.Id = role.Id;
mroles.Description = role.Description;
mroles.WhoCreate = User.Identity.GetUserName();
var result = await RoleManager.UpdateAsync(mroles);
if (result.Succeeded)
{
return(View("_SuccessView", new { Result = "修改成功" }));
}
return(View());
}
public async Task <ActionResult> ChangeRole(ChangeRoleModel model)
{
if (ModelState.IsValid)
{
var roles = await UserManager.GetRolesAsync(model.UserId);
var roleFound = Database.Roles.Find(model.Role);
foreach (var role in roles)
{
await UserManager.RemoveFromRoleAsync(model.UserId, role);
}
await UserManager.AddToRoleAsync(model.UserId, roleFound.Name);
return(RedirectToAction("Index", new { userId = model.UserId, message = ManageMessageId.RoleChanged }));
}
ViewBag.Roles = RoleList.CreateSelectableList(Database);
return(View(model));
}
public async Task <IActionResult> Edit(string id)
{
var user = await userManager.FindByIdAsync(id);
if (user != null)
{
var userRoles = await userManager.GetRolesAsync(user);
var allRoles = roleManager.Roles.ToList();
ChangeRoleModel model = new ChangeRoleModel
{
UserId = user.Id,
UserName = user.UserName,
UserRoles = userRoles.ToList(),
AllRoles = allRoles
};
return(View(model));
}
ModelState.AddModelError("", "User not found");
return(View("Index", "Admin"));
}
public async Task <IActionResult> Change(string userId)
{
int _id = int.Parse(userId);
User user = await _user.FindById(_id);
if (user != null)
{
var userRoles = await _user.RolesInUser(user.Id);
var allRoles = await _role.ToListRole();
ChangeRoleModel model = new ChangeRoleModel
{
UserId = user.Id,
UserEmail = user.Email,
UserRoles = userRoles,
AllRoles = allRoles
};
return(View(model));
}
return(NotFound());
}
public IHttpActionResult ChangeUserRole([FromBody] ChangeRoleModel i_Model)
{
LogControllerEntring("changerole");
IHttpActionResult result = Ok();
eErrors error = eErrors.None;
try
{
error = m_Logic.ChangeRole(i_Model);
if (error != eErrors.None)
{
result = BadRequest(((int)error).ToString());
}
LogData("user role changed", i_Model);
}
catch (Exception ex)
{
result = LogException(ex, JsonConvert.SerializeObject(i_Model));
}
return(result);
}
