public async Task <IActionResult> PostRole(string app, [FromBody] AddRoleDto request) { var command = request.ToCommand(); var context = await CommandBus.PublishAsync(command); return(NoContent()); }
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.Find(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, role) in model.Roles) { var existing = current.Items.Find(x => x.Name == roleName); if (existing == null || existing.IsDefaultRole) { continue; } await log.DoSafeAsync($"Role '{roleName}' updating", async() => { var request = role.ToUpdate(); await session.Apps.PutRoleAsync(session.App, roleName, request); }); } }
public async Task <IActionResult> PostRole(string app, [FromBody] AddRoleDto request) { var command = request.ToCommand(); var response = await InvokeCommandAsync(command); return(CreatedAtAction(nameof(GetRoles), new { app }, response)); }
public async Task <JsonResult> Add(AddRoleDto model) { var result = await _roleAppService.AddAsync(model); OutputModel outputModel = new OutputModel(); outputModel.Data = result; return(new JsonResult(outputModel)); }
public async Task AddRoleAsyncTest() { var addRoleDto = new AddRoleDto { Name = DefaultApplicationRoles.Basic }; var rs = await _roleService.AddRoleAsync(addRoleDto); Assert.AreEqual(true, rs.Succeeded); }
public async Task <ActionResult> AddDepartment([FromBody] AddRoleDto roleDto) { if (!IsAvailableOperation()) { return(BadRequest()); } await _roleService.Add(roleDto); AddLog(Enums.LogType.Create, LogMessage.CreateSuccessByNameMessage(LogMessage.RoleEntityName, roleDto.Name, LogMessage.CreateAction, UserId)); return(Ok()); }
public IActionResult Post([FromBody] AddRoleDto dto) { try { _addRoleCommand.Execute(dto); return(StatusCode(201, "Successfully added a new role.")); } catch { return(StatusCode(422, "Error while trying to add a new role.")); } }
private async Task <RoleDto> CreateRoleAsync(string name) { var createRequest = new AddRoleDto { Name = name }; var roles = await _.Apps.PostRoleAsync(_.AppName, createRequest); var role = roles.Items.Find(x => x.Name == name); return(role); }
public async Task <Response <string> > AddRoleAsync(AddRoleDto addRoleDto) { if (await _roleManager.GetRoleAsync(addRoleDto.Name) != null) { return(Response <string> .Fail("The role already exists. Please try a different one!")); } var appRole = _mapper.Map <ApplicationRole>(addRoleDto); var rs = await _roleManager.AddRoleAsync(appRole); return(rs.Succeeded ? Response <string> .Success(appRole.Id, "New role has been created") : Response <string> .Fail("Failed to create new role")); }
public IActionResult Put(int id, [FromBody] AddRoleDto dto) { try { dto.Id = id; _editRoleCommand.Execute(dto); return(StatusCode(204, "Successfully updated user.")); } catch { return(StatusCode(422, "Error while trying to update user.")); } }
public async Task AddRole(AddRoleDto data) { var user = _userManager.FindByNameAsync(data.UserName).Result; if (user == null) { throw new ValidationException($"User: {data.UserName} is not found."); } await EnsureRoleIsExists(data.RoleName); await _userManager.AddToRoleAsync(user, data.RoleName); }
public void Execute(AddRoleDto request) { if (Context.Roles.Any(r => r.Name == request.Name)) { throw new EntityAlreadyExistsException(); } Context.Roles.Add(new Role { Name = request.Name }); Context.SaveChanges(); }
public async Task <ActionResult <RoleDto> > AddRole(AddRoleDto addRole) { addRole.ThrowBusinessExceptionIfNull("AddRole was null"); addRole.Role.ThrowBusinessExceptionIfNull("Role was null"); if (!addRole.PermissionIds.Any()) { throw new BusinessLayerException("Permission Ids was empty"); } var entity = addRole.Role.Adapt <Role>(); var createdRole = await RoleService.AddRole(entity, addRole.PermissionIds); return(Ok(createdRole.Adapt <RoleDto>())); }
public IActionResult Post([FromBody] AddRoleDto dto , [FromServices] IAddRoleCommand command , [FromServices] AddRoleValidator addRoleValidator) { var result = addRoleValidator.Validate(dto); if (result.IsValid) { Role role = _mapper.Map <Role>(dto); _useCaseExecutor.ExecuteCommand(command, role); return(Ok("Role created successfully")); } return(UnprocessableEntity(UnprocessableEntityResponse.Message(result.Errors))); }
public async Task <IActionResult> PostRoleAsync([FromBody] AddRoleDto dto) { string openId = GetOpenId(); try { await _roleServices.PostRoleAsync(dto, openId); return(AddSuccessMsg()); } catch (Exception err) { _logger.Error(typeof(SettingController), "添加角色失败!", new Exception(err.Message)); return(FailedMsg("添加角色失败!" + err.Message)); } }
public async Task <IActionResult> Add(AddRoleDto addRoleDto) { if (!ModelState.IsValid) { return(View(addRoleDto)); } var rs = await _roleService.AddRoleAsync(addRoleDto); if (rs.Succeeded) { return(RedirectToAction("Index", "Role", new { area = "Admin", id = rs.Data, succeeded = rs.Succeeded, message = rs.Message })); } ModelState.AddModelError(string.Empty, rs.Message); return(View(addRoleDto)); }
/// <summary> /// 修改角色 /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <HeaderResult <string> > EditRole(AddRoleDto input) { var role = await _roleRepository.WhereLoadEntityAsync(e => e.Id == input.RoleId); role?.EditRole(input.RoleName, input.RoleType, input.RoleDescription); _roleRepository.UpdateEntity(role); await _roleRepository.CommitAsync(); HeaderResult <string> result = new HeaderResult <string> { IsSucceed = true, Message = "修改成功!" }; return(result); }
public void Execute(AddRoleDto request) { var role = Context.Roles.Find(request.Id); if (role == null) { throw new EntityNotFoundException(); } if (request.Name != role.Name && Context.Roles.Any(r => r.Name == request.Name)) { throw new EntityAlreadyExistsException(); } role.Name = request.Name; Context.SaveChanges(); }
public async Task <IActionResult> AddRole(AddRoleDto addRole) { try { var add = await mediator.Send(new CreateRoleCommand(addRole.Name, addRole.Description)); if (add.Success) { return(Ok(_localizer[RoleControllerShared.AddSuccessRole].Value)); } return(BadRequest(add.ErrorMessage)); } catch (Exception ex) { return(BadRequest(ex)); } }
public async Task Add(AddRoleDto roleDto) { var role = await _roleManager.Roles.FirstOrDefaultAsync(x => x.Name.Equals(roleDto.Name) && x.IsActive); if (role != null) { throw new FoundSameObjectException("Role", roleDto.Name); } role = new Role { Name = roleDto.Name, RoleType = Enums.RoleType.Employee, IsActive = true }; var result = await _roleManager.CreateAsync(role); if (!result.Succeeded) { throw new RoleManagerException("add", role.Name); } }
/// <summary> /// 添加角色 /// </summary> /// <param name="input"></param> /// <returns></returns> public async Task <HeaderResult <string> > AddRole(AddRoleDto input) { var roleInfo = await _roleRepository.LoadEntityMaxSortAsync(e => e.RoleShot); var shotIndex = 1; if (roleInfo != null) { shotIndex = roleInfo.RoleShot + 1; } var userRoleEntity = new RoleInfo().CreateRole(input.RoleName, input.RoleType, input.RoleDescription, shotIndex); await _roleRepository.AddEntityAsync(userRoleEntity); await _roleRepository.CommitAsync(); HeaderResult <string> result = new HeaderResult <string> { IsSucceed = true, Message = "添加成功!" }; return(result); }
/// <summary> /// 添加角色 /// </summary> /// <param name="dto"></param> /// <param name="openId"></param> /// <returns></returns> public async Task <bool> PostRoleAsync(AddRoleDto dto, string openId) { if (dto.TeamId == null) { throw new Exception("团队Id为空!"); } var UserId = db.Queryable <Wx_UserInfo>().Where(a => a.OpenId == openId).First()?.ID; //找到UserId Role role = iMapper.Map <Role>(dto); role.ID = IdHelper.CreateGuid(); role.CreatorUserId = UserId; role.IsDeleted = false; role.IsEnabled = true; return(await Task.Run(() => { var result = db.Insertable(role).ExecuteCommand(); return result > 0; })); }
public async Task AddRole() { var roleDto = new RoleDto { Description = "Super Role", Name = "Super Super" }; var addRoleDto = new AddRoleDto() { Role = roleDto, PermissionIds = new List <int> { 1 } }; var controllerResult = await _controller.AddRole(addRoleDto); var response = HttpResponseTest.CheckForValid200HttpResponseAndReturnValue(controllerResult); Assert.Equal(roleDto.Description, response.Description); Assert.Equal(roleDto.Name, response.Name); Assert.NotEqual(roleDto.Id, response.Id); }
public async Task <HeaderResult <string> > EditRole([FromBody] AddRoleDto input) { return(await _userAppService.EditRole(input)); }
public void AddRole([FromBody] AddRoleDto addRoleDto) { this.personManagementRepository.AddRoleToPerson(addRoleDto.role, addRoleDto.PersonId); }
/// <summary> /// 添加角色 /// </summary> /// <param name="dto"></param> /// <param name="openId"></param> /// <returns></returns> public async Task <bool> PostRoleAsync(AddRoleDto dto, string openId) { return(await _roleDal.PostRoleAsync(dto, openId)); }
public async Task <IActionResult> AddRole([FromBody] AddRoleDto data) { await _userService.AddRole(data); return(Ok()); }
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 async Task <Result> AddAsync(AddRoleDto dto) { return(await _roleService.Add(_mapper.Map <Rolepermission>(dto))); }