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; }