public Task <Result <RoleModel> > Edit(UpdateRoleModel model)
=> Result <RoleModel> .TryAsync(async() =>
{
var result = await _repository.FirstOrDefaultAsync <Role>(r => r.Id == model.Id, r =>
r.RoleFeature.Select(rf => rf.Feature.FeaturePermission.Select(fp => fp.Permission)));
if (!result.Success || result.Data == null)
{
return(Result <RoleModel> .Failed(Error.WithCode(ErrorCodes.NotFound)));
}
var featureIds = model.Feature;
var resultList = await _repository.ListAsync <Feature>(f => featureIds.Contains(f.Id));
if (!resultList.Success || resultList.Data == null)
{
return(Result <RoleModel> .Failed(Error.WithCode(ErrorCodes.InvalidModel)));
}
var features = resultList.Data;
if (features.Count != featureIds.Count())
{
return(Result <RoleModel> .Failed(Error.WithCode(ErrorCodes.InvalidModel)));
}
var role = result.Data;
role.Name = model.Name;
_repository.RemoveRange(role.RoleFeature);
role.RoleFeature = model.Feature.Select(f => new RoleFeature
{
RoleId = role.Id, FeatureId = f, Id = Guid.NewGuid()
}).ToList();
await _repository.CommitAsync();
return(Result <RoleModel> .Successful(_autoMapper.Map <RoleModel>(role)));
});
public async Task <IActionResult> UpdateRole([FromBody] UpdateRoleModel model)
{
var user = await userManager.FindByIdAsync(model.Id);
if (user != null)
{
AppRole applicationRole = await roleManager.FindByIdAsync(model.RoleId);
if (applicationRole != null)
{
IdentityResult newRoleResult = await userManager.AddToRoleAsync(user, applicationRole.Name);
if (newRoleResult.Succeeded)
{
return(Ok(user));
}
else
{
return(BadRequest(newRoleResult.Errors));
}
}
else
{
return(BadRequest("Role ID is null - " + model.RoleId));
}
}
return(BadRequest(user));
}
private async Task <TResponse <bool> > CanUpdate(UpdateRoleModel request)
{
try
{
var role = await ReadOnlyRepository.QueryFirstOrDefaultAsync <RoleModel>(SqlQuery.ROLE_FIND_BY_NAME_AND_ID,
new
{
request.Name,
request.Id
});
if (role.IsSuccess)
{
if (role.Data != null)
{
return(await Fail <bool>(ErrorEnum.ROLE_HAS_EXIST.GetStringValue()));
}
return(await Ok(true));
}
return(await Fail <bool>(role.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <IActionResult> Update(UpdateRoleModel model)
{
if (ModelState.IsValid)
{
var databaseUsersInRole = await _userManager.GetUsersInRoleAsync(model.RoleId);
var usersSent = model.Users.ToList();
var usersToRemove = databaseUsersInRole
.Where(du => usersSent.All(us => du.UserName != us.UserName))
.ToList();
var usersToAdd = usersSent
.Where(us => databaseUsersInRole.All(du => du.UserName != us.UserName))
.ToList();
var results = usersToRemove
.Select(async u => await _userManager.RemoveFromRoleAsync(u, model.RoleName))
.Select(r => r.Result)
.Union(
usersToAdd
.Select(async u => await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync(u.UserId), model.RoleName))
.Select(r => r.Result)
);
if (results.Any(r => !r.Succeeded))
{
Errors(results.First(r => !r.Succeeded));
}
return(RedirectToAction("Index"));
}
return(await Update(model.RoleId));
}
public async Task <IActionResult> UpdateAdminRole(UpdateRoleModel updateAdminRoleModel)
{
var user = await _applicationDbContext.Users.SingleOrDefaultAsync(u => u.Id.Equals(updateAdminRoleModel.ID));
if (user == null)
{
Response.StatusCode = (int)HttpStatusCode.BadRequest;
return(Json("No user found"));
}
var adminRoleID = (await _applicationDbContext.Roles.SingleOrDefaultAsync(r => r.Name.Equals("Admin"))).Id;
var isAlreadyAdmin = await _applicationDbContext.UserRoles.AnyAsync(r => r.UserId.Equals(user.Id) && r.RoleId.Equals(adminRoleID));
if (isAlreadyAdmin)
{
_applicationDbContext.UserRoles.RemoveRange(_applicationDbContext.UserRoles.Where(r => r.UserId.Equals(user.Id) && r.RoleId.Equals(adminRoleID)));
}
else
{
await _applicationDbContext.UserRoles.AddAsync(new IdentityUserRole <string>
{
UserId = user.Id,
RoleId = adminRoleID
});
}
await _applicationDbContext.SaveChangesAsync();
return(Json("Updated role."));
}
public async Task <IActionResult> Edit(UpdateRoleModel model)
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
UpdateRolePermissionModel editrole = new UpdateRolePermissionModel();
editrole.Description = model.Description;
editrole.Name = model.Name;
editrole.Id = model.Id;
if (!await RoleSvc.UpdateAsync(editrole))
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = RoleSvc.ErrorMsg
}));
}
UpdateRoleOrPermissionModel update = new UpdateRoleOrPermissionModel();
update.Id = editrole.Id;
update.Ids = model.Ids;
if (!await PerSvc.UpdateRoleToPermissesAsync(update))
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = RoleSvc.ErrorMsg
}));
}
scope.Complete();
return(Json(new AjaxResult {
Status = "ok"
}));
}
}
public void UpdateRoleMaster(UpdateRoleModel updateRoleModel) // Working Ok
{
try
{
using (OracleConnection con = new OracleConnection(MyConnectionString))
{
con.Open();
OracleCommand cmd = new OracleCommand("pkg_api_integration.PROC_VSEC_ROLEMASTER_INS", con);
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("P_ROLEID", OracleDbType.Int32, updateRoleModel.id, ParameterDirection.Input);
cmd.Parameters.Add("P_PARENTROLEID", OracleDbType.Int32, DBNull.Value, ParameterDirection.Input);
cmd.Parameters.Add("P_ROLESNAME", OracleDbType.Varchar2, updateRoleModel.shortName, ParameterDirection.Input);
cmd.Parameters.Add("P_DISPLAYNAME", OracleDbType.Varchar2, updateRoleModel.name, ParameterDirection.Input);
cmd.Parameters.Add("P_ACTIVEFLAG", OracleDbType.Char, updateRoleModel.status.ToLower() == "enabled" ? "Y" : "N", ParameterDirection.Input);
cmd.Parameters.Add("P_ACTION", OracleDbType.Varchar2, "U", ParameterDirection.Input);
cmd.Parameters.Add("P_USER", OracleDbType.Varchar2, updateRoleModel.user, ParameterDirection.Input);
cmd.Parameters.Add("P_STATUSFLAG", OracleDbType.Varchar2, 200, "", ParameterDirection.Output); //.Value = 200;
cmd.Parameters.Add("P_ERROR", OracleDbType.Varchar2, 2000, "", ParameterDirection.Output); //.Value = 2000;
cmd.ExecuteNonQuery();
con.Close();
}
}
catch (Exception ex)
{
throw;
}
}
public RoleResponseModel UpdateRoleService(UpdateRoleModel request)
{
RoleResponseModel response = new RoleResponseModel();
var resDelete = _rolesRepository.DeleteRolePermission(request.roleId);
if (resDelete > 0)
{
var resUpdate = 0;
resUpdate = _rolesRepository.InsertRolePermission(request.roleId, request.permissionList);
if (resUpdate > 0)
{
response.success = true;
}
else
{
response.success = false;
}
}
else
{
response.success = false;
}
return(response);
}
public async Task <IActionResult> UpdateRole(string name, UpdateRoleModel model)
{
var validationData = _service.ValidateUpdateRole(User, model);
if (!validationData.IsValid)
{
return(BadRequest(AppResult.FailValidation(data: validationData)));
}
var entity = _service.GetRoleByName(name);
if (entity == null)
{
return(NotFound(AppResult.NotFound()));
}
var result = await _service.UpdateRoleAsync(entity, model);
if (result.Succeeded)
{
return(Ok(AppResult.Success(entity)));
}
foreach (var err in result.Errors)
{
ModelState.AddModelError(err.Code, err.Description);
}
return(BadRequest(AppResult.FailValidation(ModelState)));
}
public async Task <IdentityResult> UpdateRoleAsync(AppRole entity,
UpdateRoleModel model)
{
model.CopyTo(entity);
var result = await _roleManager.UpdateAsync(entity);
return(result);
}
public async Task <IActionResult> UpdateRole([FromBody] UpdateRoleModel model)
{
return(await ProcessAsync(async() =>
{
await _roleService.Update(model);
return Ok();
}, Permissions.System.Groups.EditGroups));
}
public async Task <IActionResult> UpdateRole([FromBody] UpdateRoleModel model)
{
try
{
await _roleService.Update(model);
return(Ok());
}
catch (Exception e)
{
return(HandleException(e));
}
}
public async Task <IActionResult> UpdateAsync([FromBody] UpdateRoleModel model)
{
_logger.LogInformation($"Update {model.Id} role");
if (ModelState.IsValid)
{
if (await _service.UpdateAsync(_mapper.Map <RoleDTO>(model)))
{
return(Ok());
}
return(BadRequest());
}
return(BadRequest(ModelState));
}
public JsonResult Update(UpdateRoleModel model, string pIds)
{
JsonResult json = new JsonResult();
if (string.IsNullOrEmpty(model.roleName))
{
return(Json(new { success = false, msg = "角色名称不为空" }, "text/json"));
}
List <Role> mrRole = db.Role.Where(m => m.roleName == model.roleName).ToList();
if (mrRole != null & mrRole.Count > 1)
{
return(Json(new { success = false, msg = "角色名称已经存在" }, "text/json"));
}
using (TransactionScope scope = new TransactionScope())
{
try
{
Role role = db.Role.FirstOrDefault(m => m.roleName == model.roleName);
if (role != null)
{
role.roleName = model.roleName;
role.roleNote = model.roleNote;
}
db.Entry(role).State = EntityState.Modified;
RolePrivilege rolePrivilege =
db.RolePrivilege.Where(m => m.roleId == model.roleId).FirstOrDefault();
if (rolePrivilege != null)
{
rolePrivilege.privilegeIds = pIds;
rolePrivilege.roleId = model.roleId;
}
db.Entry(rolePrivilege).State = EntityState.Modified;
if (db.SaveChanges() > 0)
{
json.Data = new { success = true, msg = "修改成功！" };
}
else
{
json.Data = new { success = false, msg = "修改失败！" };
}
}
catch (DbEntityValidationException ex)
{
throw;
}
scope.Complete();
}
return(json);
}
public async Task <IActionResult> Update(UpdateRoleModel model)
{
if (ModelState.IsValid)
{
var role = await _roleManager.FindByIdAsync(model.Id);
role.Name = model.Name;
role.Description = model.Description;
await _roleManager.UpdateAsync(role);
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public IHttpActionResult UpdateRole(long roleId, UpdateRoleModel role)
{
if (roleId == 0 || role.roleName.Equals(null) || role.roleName == string.Empty)
{
return(BadRequest("enter a value for Role name"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
long output = Storage.updateRole(roleId, role.roleName, role.desc, role.userNames);
return(new StatusCodeResult(HttpStatusCode.NoContent, this));
}//UpdateRole
public async Task <IActionResult> UpdateRole(UpdateRoleModel updateRoleModel)
{
if (!ModelState.IsValid)
{
return(RedirectToAction("UpdateRole"));
}
var role = await _roleManager.FindByIdAsync(updateRoleModel.RoleId);
role.Name = updateRoleModel.RoleName;
await _roleManager.UpdateAsync(role);
TempData["RoleStatus"] = "RoleUpdated";
return(RedirectToAction("Roles"));
}
public async Task <TResponse <bool> > Update(int userId,
UpdateRoleModel request,
int permissionId)
{
try
{
var checkValid = await _userService.CheckPermission(userId,
permissionId);
if (checkValid.IsSuccess)
{
var canUpdate = await CanUpdate(request);
if (canUpdate.IsSuccess)
{
var result = await WriteRepository.ExecuteAsync(SqlQuery.ROLE_UPDATE,
new
{
request.Id,
request.Name,
UserUpdated = userId,
DateUpdated = DateTime.Now
});
if (result.IsSuccess)
{
if (result.Data > 0)
{
return(await Ok(true));
}
return(await Fail <bool>(ErrorEnum.BAD_REQUEST.GetStringValue()));
}
return(await Fail <bool>(result.Message));
}
return(await Fail <bool>(canUpdate.Message));
}
return(await Fail <bool>(checkValid.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public async Task <IActionResult> Update(string Id)
{
var role = await _roleManager.FindByIdAsync(Id);
if (Id == null)
{
return(NotFound());
}
var model = new UpdateRoleModel
{
Id = role.Id,
Name = role.Name,
Description = role.Description
};
return(View(model));
}
public static async Task <long> UpdateAsync(long roleId, string roleName, string desc, List <string> userNames)
{
UpdateRoleModel fromBodyRole = new UpdateRoleModel();
fromBodyRole.roleId = roleId;
fromBodyRole.roleName = roleName;
fromBodyRole.desc = desc;
fromBodyRole.userNames = userNames;
long output = -1;
HttpResponseMessage response = await MyClient.client.PostAsJsonAsync(string.Format("security/role/{0}", roleId), fromBodyRole);
if (response.IsSuccessStatusCode)
{
output = await response.Content.ReadAsAsync <long>();
}
return(output);
}
public async Task <IActionResult> Edit(UpdateRoleModel model)
{
if (ModelState.IsValid)
{
var response = await _roleService.Update(model);
if (response.IsSuccess)
{
StatusMessage = SuccessNotifcation("Update role success!");
return(RedirectToAction("Index"));
}
ModelState.AddModelError("", response.Message);
}
return(View(model));
}
public IActionResult UpdateRole(string userId, string roleId)
{
int newUserId = _dataProtector.Unprotect(userId);
int newRoleId = _dataProtector.Unprotect(roleId);
ResponseDetails response = _apiHelper.SendApiRequest("", "role/get-all", HttpMethod.Get);
List <RoleViewModel> roles = JsonConvert.DeserializeObject <List <RoleViewModel> > (response.Data.ToString());
UpdateRoleModel model = new UpdateRoleModel();
model.ApiModel.UserId = newUserId;
model.ApiModel.RoleId = newRoleId;
model.Roles = roles;
return(View(model));
}
public async Task Should_Update_Role_Successfully()
{
UpdateRoleModel updateRoleModel = new UpdateRoleModel()
{
RoleName = "New Role"
};
var result = await administrationController.UpdateRole(Guid.NewGuid(), updateRoleModel);
Assert.That(result, Is.TypeOf <NoContentResult>());
result = await administrationController.UpdateRole(Guid.NewGuid(), updateRoleModel);
Assert.That(result, Is.TypeOf <ObjectResult>());
var resultStat = result as ObjectResult;
Assert.That(resultStat.StatusCode, Is.EqualTo(StatusCodes.Status500InternalServerError));
}
public ActionResult Update(UpdateRoleModel updateRoleModel) // working Ok
{
if (ModelState.IsValid)
{
_roleMasterRepository.UpdateRoleMaster(updateRoleModel);
if (updateRoleModel != null)
{
responsemessage2 = new ResponseMessage2("success", "");
}
else
{
responsemessage2 = new ResponseMessage2("Failed", "");
}
}
return(Ok(responsemessage2));
}
public IActionResult UpdateRole(UpdateRoleModel model)
{
ResponseDetails response = _apiHelper.SendApiRequest(model.ApiModel, "user/change-role", HttpMethod.Post);
if (response.Success)
{
return(RedirectToAction("Index"));
}
else
{
ErrorViewModel errorModel = new ErrorViewModel
{
Message = response.Data.ToString()
};
return(View("Error", errorModel));
}
}
public async Task <TResponse <bool> > Update(UpdateRoleModel model)
{
try
{
var response = await HttpService.Send <bool>(_baseUrl + ApiUrl.ROLE_UPDATE, model, HttpMethod.Put);
if (response.IsSuccess)
{
return(await Ok(response.Data));
}
return(await Fail <bool>(response.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
public ActionResult Update(UpdateRoleModel updateRoleModel)
{
Data.Models.Role r = new Data.Models.Role()
{
Id = updateRoleModel.Id,
Name = updateRoleModel.Name,
Description = updateRoleModel.Description,
UpdateTime = DateTime.Now
};
if (role.Update(r) > 0)
{
return(new ResponseModel <string>(ErrorCode.success, ""));
}
else
{
return(new ResponseModel <string>(ErrorCode.record_exist, ""));
}
}
public async Task <IActionResult> UpdateRole(Guid roleId, UpdateRoleModel updateRoleModel)
{
IdentityRole role = await _roleManager.FindByIdAsync(roleId.ToString());
role.Name = updateRoleModel.RoleName;
var result = await _roleManager.UpdateAsync(role);
if (result.Succeeded)
{
return(NoContent());
}
foreach (var error in result.Errors)
{
_log.LogError(error.Description, error);
}
return(StatusCode(StatusCodes.Status500InternalServerError, result.Errors));
}
public bool UpdateRole(UpdateRoleModel model)
{
try
{
var eventUser = _db.EventUsers.First(x => x.EventId == model.GroupId && x.UserId == model.UserId);
eventUser.RoleId = model.RoleId;
_db.Entry(eventUser).State = EntityState.Modified;
_db.SaveChanges();
return(true);
}
catch (Exception ex)
{
JavaScriptSerializer js = new JavaScriptSerializer();
string json = js.Serialize(model);
Log.Error("Group - UpdateRole- " + json, ex);
throw;
}
}
public Xinchen.PrivilegeManagement.DTO.Role UpdateRole(UpdateRoleModel updateRoleModel, int[] privilegeIds)
{
using (TransactionScope scope = new TransactionScope())
{
Xinchen.PrivilegeManagement.DTO.Role role = this._privilegeBase.GetRole(updateRoleModel.Id);
if (role == null)
{
throw new ApplicationException("该角色不存在");
}
role.Description = updateRoleModel.Description;
role.Status = updateRoleModel.Status;
role = this._privilegeBase.UpdateRole(role);
var rolePrivileges = this.PrivilegeBase.GetRolePrivileges(role.Id).ToList();
int[] numArray = privilegeIds;
for (int i = 0; i < numArray.Length; i++)
{
Predicate <Xinchen.PrivilegeManagement.DTO.Privilege> match = null;
int privilegeId = numArray[i];
if (match == null)
{
match = x => x.Id == privilegeId;
}
if (!rolePrivileges.Exists(match))
{
this.PrivilegeBase.AddRolePrivilege(role.Id, privilegeId);
}
}
foreach (Xinchen.PrivilegeManagement.DTO.Privilege privilege in rolePrivileges)
{
if (!privilegeIds.Contains <int>(privilege.Id))
{
this.PrivilegeBase.RemoveRolePrivilege(privilege.Id, role.Id);
}
}
scope.Complete();
return(role);
}
}
