public async Task <IActionResult> Put(int id, [FromBody] UpdateRoleDto roleDto)
{
var result = await _roleService.Update(id, roleDto);
if (!_roleService.Success())
{
return(BadRequest(_roleService.Errors));
}
return(Ok(result));
}
public async Task UpdateRoleAndAssignPermission()
{
var role = await CreateRole();
role.Name = "hello";
role.Description = "sugar";
var permission = await CreatePermission();
Detach();
var updateRoleDto = new UpdateRoleDto
{
Role = role.Adapt <RoleDto>(),
PermissionIds = new List <int> {
permission.Id
}
};
var controllerResult = await _controller.UpdateRole(updateRoleDto.Adapt <UpdateRoleDto>());
var response = HttpResponseTest.CheckForValid200HttpResponseAndReturnValue(controllerResult);
Assert.Equal(role.Name, response.Name);
Assert.Equal(role.Description, response.Description);
Assert.Equal(role.Id, response.Id);
var dbRole = await Db.Role.Include(r => r.RolePermissions).FirstOrDefaultAsync(r => r.Id == role.Id);
Assert.NotEmpty(dbRole.RolePermissions);
Detach();
updateRoleDto = new UpdateRoleDto
{
Role = role.Adapt <RoleDto>(),
PermissionIds = new List <int> {
}
};
controllerResult = await _controller.UpdateRole(updateRoleDto.Adapt <UpdateRoleDto>());
response = HttpResponseTest.CheckForValid200HttpResponseAndReturnValue(controllerResult);
Assert.Equal(role.Name, response.Name);
Assert.Equal(role.Description, response.Description);
Assert.Equal(role.Id, response.Id);
dbRole = await Db.Role.Include(r => r.RolePermissions).FirstOrDefaultAsync(r => r.Id == role.Id);
Assert.Empty(dbRole.RolePermissions);
}
public int UpdateRoles(UpdateRoleDto model)
{
int[] p = Newtonsoft.Json.JsonConvert.DeserializeObject <int[]>(model.power);
Role role = new Role();
role.RoleId = model.RoleId;
role.RoleName = model.RoleName;
role.RolePid = model.RolePid;
role.RoleContent = model.RoleContent;
role.RoleModifyPeople = model.RoleModifyPeople;
role.RoleModifyTime = model.RoleModifyTime;
return(_organization.UpdateRoles(role, p));
}
public async Task <IActionResult> UpdateUserRole(int id, UpdateRoleDto updateRoleDto)
{
if (id != updateRoleDto.Id)
{
return(Unauthorized());
}
ServiceResponse <GetUserDto> response = await _userService.UpdateUserRole(id, updateRoleDto);
if (response.Data == null)
{
return(NotFound(response));
}
return(Ok(response));
}
public async Task <IActionResult> UpdateTeamMemberRoleAsync([FromBody] UpdateRoleDto dto)
{
string openId = GetOpenId();
try
{
var data = await _roleServices.UpdateTeamMemberRoleAsync(dto, openId);
return(Ok(data));
}
catch (Exception err)
{
_logger.Error(typeof(SettingController), "修改角色失败!", new Exception(err.Message));
return(FailedMsg("修改角色失败！" + err.Message));
}
}
public async Task <int> UpdateAsync(UpdateRoleDto updateRoleDto)
{
const string query = @"
UPDATE [Roles]
SET [Name] = @Name
,[NormalizedName] = @NormalizedName
,[ConcurrencyStamp] = @ConcurrencyStamp
WHERE [Id] = @Id;
";
using (var connection = _dbConnectionFactory.GetDbConnection())
{
var updatedRowsNum = await connection.ExecuteAsync(query, updateRoleDto);
return(updatedRowsNum);
}
}
public async Task <IActionResult> PutRole(ulong id, UpdateRoleDto updateRoleDto)
{
try
{
RoleDto roleDto = await _business.Update <RoleDto, UpdateRoleDto>(id, updateRoleDto);
return(Ok(roleDto));
}
catch (ArgumentNullException)
{
return(BadRequest($"A role with id \"{id}\" was not found."));
}
catch (DbUpdateException)
{
return(BadRequest($"A role with the name \"{updateRoleDto.Name}\" already exists."));
}
}
public async Task <ActionResult <bool> > UpdateRole(UpdateRoleDto roleToUpdate)
{
var curRole = await _roleManager.FindByIdAsync(roleToUpdate.Id);
if (curRole == null)
{
return(BadRequest(new ApiResponse(400, "Role does not exists")));
}
curRole.Name = roleToUpdate.NewRoleName;
var res = await _roleManager.UpdateAsync(curRole);
if (res.Succeeded)
{
return(Ok(true));
}
return(BadRequest(new ApiResponse(400, "Saving failed")));
}
public async Task <GetRoleDto> Update(int roleId, UpdateRoleDto roleDto)
{
var validations = await _roleValidator.UpdateValidate(roleId, roleDto);
if (validations.IsValid)
{
var entity = _mapper.Map <Role>(roleDto);
entity.ChangeDescription(roleDto.Description);
await _roleRepository.Update(entity);
var result = await Filter(new FilterRoleDto { Id = roleId });
return(result.FirstOrDefault());
}
Errors.AddRange(validations.Errors.Select(erro => erro.ErrorMessage));
return(null);
}
public async Task Should_update_role()
{
// STEP 1: Add role.
var role = await CreateRoleAsync(roleName);
// STEP 2: Update role.
var updateRequest = new UpdateRoleDto
{
Permissions = new List <string> {
"a", "b"
}
};
var roles_2 = await _.Apps.PutRoleAsync(_.AppName, roleName, updateRequest);
var role_2 = roles_2.Items.Find(x => x.Name == roleName);
// Should return role with correct name.
Assert.Equal(updateRequest.Permissions, role_2.Permissions);
}
public async Task <IEnumerable <IdentityResult> > UpdateRole(UpdateRoleDto model)
{
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)
);
return(results);
}
/// <summary>
/// 修改成员角色
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <QueryRoleDto> UpdateTeamMemberRoleAsync(UpdateRoleDto dto, string openId)
{
var UserId = db.Queryable <Wx_UserInfo>().Where(a => a.OpenId == openId).First()?.ID;
return(await Task.Run(() =>
{
var result = db.Updateable <TeamMember>().SetColumns(a => new TeamMember()
{
RoleId = dto.RoleId,
LastModifyUserId = UserId,
LastModifyTime = DateTime.Now
})
.Where(a => a.ID == dto.MemberId && dto.TeamId == dto.TeamId).ExecuteCommand();
var role = db.Queryable <Role>().Where(a => a.ID == dto.RoleId).Select(a => new QueryRoleDto
{
RoleId = a.ID,
RoleName = a.Name
}).First();
return role;
}));
}
public Result Update([FromBody] UpdateRoleDto dto) => base.Update(dto);
/// <summary>
/// 修改成员角色
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <QueryRoleDto> UpdateTeamMemberRoleAsync(UpdateRoleDto dto, string openId)
{
return(await _roleDal.UpdateTeamMemberRoleAsync(dto, openId));
}
private async Task SynchronizeRolesAsync(AppModel model, SyncOptions options, ISession session)
{
var current = await session.Apps.GetRolesAsync(session.App);
if (options.Delete)
{
foreach (var role in current.Items)
{
if (model.Roles.ContainsKey(role.Name) ||
role.IsDefaultRole ||
role.NumClients > 0 ||
role.NumContributors > 0)
{
continue;
}
await log.DoSafeAsync($"Role '{role.Name}' deleting", async() =>
{
await session.Apps.DeleteRoleAsync(session.App, role.Name);
});
}
}
foreach (var(roleName, _) in model.Roles)
{
var existing = current.Items.FirstOrDefault(x => x.Name == roleName);
if (existing != null)
{
continue;
}
await log.DoSafeAsync($"Role '{roleName}' creating", async() =>
{
var request = new AddRoleDto {
Name = roleName
};
current = await session.Apps.PostRoleAsync(session.App, request);
});
}
foreach (var(roleName, value) in model.Roles)
{
var existing = current.Items.FirstOrDefault(x => x.Name == roleName);
if (existing == null || value.JsonEquals(existing))
{
continue;
}
await log.DoSafeAsync($"Role '{roleName}' updating", async() =>
{
var request = new UpdateRoleDto {
Permissions = value.Permissions
};
await session.Apps.PutRoleAsync(session.App, roleName, request);
});
}
}
public ActionResult <RoleDto> UpdateRole(Guid personId, Guid projectId, Guid roleId, [FromBody] UpdateRoleDto dto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_db.Person.BelongsToUser(personId, HttpContext))
{
return(Forbid());
}
if (_db.Participation.GetRole(personId, projectId)?.RolesWrite != true)
{
return(Forbid());
}
Role role;
var roleFromDb = _db.Role
.FindByCondition(x => x.Id == roleId && x.ProjectId == projectId)
.SingleOrDefault();
if (roleFromDb?.Editable == true)
{
role = _mapper.Map <Role>(dto);
role.Editable = true;
role.CreatedTime = roleFromDb.CreatedTime;
}
else
{
role = roleFromDb;
role.Name = dto.Name;
role.Editable = false;
}
role.Id = roleId;
role.ProjectId = projectId;
role.Eligibilities = new List <Eligibility>();
_db.Role.Update(role);
foreach (var eligibility in dto.Eligibilities)
{
var eligibilityFromDb = _db.Eligibility
.FindByCondition(x => x.Id == eligibility.Id && x.RoleId == roleId)
.SingleOrDefault();
if (eligibilityFromDb != null)
{
eligibilityFromDb.ShiftsRead = eligibility.ShiftsRead;
eligibilityFromDb.ShiftsWrite = eligibility.ShiftsWrite && eligibility.ShiftsRead;
eligibilityFromDb.IsTeamCaptain = eligibility.IsTeamCaptain && eligibility.ShiftsRead;
eligibilityFromDb.IsSubstituteCaptain = eligibility.IsSubstituteCaptain && eligibility.ShiftsRead && !eligibility.IsTeamCaptain;
_db.Eligibility.Update(eligibilityFromDb);
}
}
_db.Save();
var updatedRole = _db.Role
.FindByCondition(x => x.Id == roleId && x.ProjectId == projectId)
.Include(x => x.Eligibilities).ThenInclude(x => x.Category)
.SingleOrDefault();
return(Ok(_mapper.Map <RoleDto>(updatedRole)));
}
catch (Exception e)
{
_logger.LogError($"ERROR in UpdateRole: {e.Message}");
return(StatusCode(500, "Internal server error"));
}
}
public async Task <IActionResult> UpdateRole([FromBody] UpdateRoleDto updateDto)
{
var response = await _mediator.Send(new UpdateRoleCommand(updateDto));
return(Ok(response));
}
public RoleCannotBeUpdatedWithDuplicateNameBusinessRule(IQueryable <Role> roles, UpdateRoleDto updateDto)
{
_roles = roles;
_updateDto = updateDto;
}
public async Task <JsonResultModel <object> > UpdateAsync([FromRoute] int id, [FromBody] UpdateRoleDto input)
{
await _service.UpdateAsync(id, input);
return(new JsonResultModel <object>());
}
public async Task <IActionResult> UpdateRole(string app, string role, [FromBody] UpdateRoleDto request)
{
await CommandBus.PublishAsync(request.ToCommand(role));
return(NoContent());
}
public void Update(UpdateRoleDto dto)
{
UpdateName(dto.Name);
}
public IActionResult Update(UpdateRoleDto dto)
{
var result = _roleService.UpdateRole(dto);
return(Json(result));
}
public async Task Should_manage_roles()
{
// Use role name with hash to test previous bug.
var roleName = $"{Guid.NewGuid()}/1";
var roleClient = Guid.NewGuid().ToString();
var roleContributor1 = "*****@*****.**";
var roleContributor2 = "*****@*****.**";
// STEP 1: Add role.
var createRequest = new AddRoleDto {
Name = roleName
};
var roles_1 = await _.Apps.PostRoleAsync(_.AppName, createRequest);
var role_1 = roles_1.Items.Single(x => x.Name == roleName);
// Should return role with correct name.
Assert.Empty(role_1.Permissions);
// STEP 2: Update role.
var updateRequest = new UpdateRoleDto {
Permissions = new List <string> {
"a", "b"
}
};
var roles_2 = await _.Apps.PutRoleAsync(_.AppName, roleName, updateRequest);
var role_2 = roles_2.Items.Single(x => x.Name == roleName);
// Should return role with correct name.
Assert.Equal(updateRequest.Permissions, role_2.Permissions);
// STEP 3: Assign client and contributor.
await _.Apps.PostClientAsync(_.AppName, new CreateClientDto { Id = roleClient });
await _.Apps.PutClientAsync(_.AppName, roleClient, new UpdateClientDto { Role = roleName });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor1, Role = roleName, Invite = true });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor2, Role = roleName, Invite = true });
var roles_3 = await _.Apps.GetRolesAsync(_.AppName);
var role_3 = roles_3.Items.Single(x => x.Name == roleName);
// Should return role with correct number of users and clients.
Assert.Equal(1, role_3.NumClients);
Assert.Equal(2, role_3.NumContributors);
// STEP 4: Try to delete role.
var ex = await Assert.ThrowsAsync <SquidexManagementException <ErrorDto> >(() =>
{
return(_.Apps.DeleteRoleAsync(_.AppName, roleName));
});
Assert.Equal(400, ex.StatusCode);
// STEP 5: Remove after client and contributor removed.
var fallbackRole = "Developer";
await _.Apps.PutClientAsync(_.AppName, roleClient, new UpdateClientDto { Role = fallbackRole });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor1, Role = fallbackRole });
await _.Apps.PostContributorAsync(_.AppName, new AssignContributorDto { ContributorId = roleContributor2, Role = fallbackRole });
await _.Apps.DeleteRoleAsync(_.AppName, roleName);
var roles_4 = await _.Apps.GetRolesAsync(_.AppName);
// Should not return deleted role.
Assert.DoesNotContain(roles_4.Items, x => x.Name == roleName);
}
public UpdateRoleCommand(UpdateRoleDto updateDto)
{
UpdateRoleDto = updateDto;
}
