public void GivenIHaveAnAddAUserToAGroupRequestForTheUserIdAndGroup(Scenario scenario) { _testContext.HttpMethod = HttpMethod.Patch; _testContext.Uri = AddUserToGroup; var addUserRequest = new AddUserToGroupRequest() { UserId = _testContext.Config.TestSettings.ExistingUserId, GroupName = _testContext.Config.TestSettings.NewGroups.First().DisplayName }; switch (scenario) { case Scenario.Valid: { break; } case Scenario.Nonexistent: { addUserRequest.UserId = Guid.NewGuid().ToString(); break; } case Scenario.Invalid: { addUserRequest.UserId = " "; break; } default: throw new ArgumentOutOfRangeException(nameof(scenario), scenario, null); } var jsonBody = RequestHelper.Serialise(addUserRequest); _testContext.HttpContent = new StringContent(jsonBody, Encoding.UTF8, "application/json"); }
public void JoinGroup(string groupName) { AddUserToGroupRequest request = new AddUserToGroupRequest(Login, groupName); connection.Post(request); groups = null; }
public ActionResult AddUserToGroup([FromBody] AddUserToGroupRequest request) { using (var client = GetMainServiceClient()) { client.AddUserToGroup(request.UserId, request.GroupId); return(Json(new {})); } }
private async Task AddUserToGroup(string adUserId, string group) { var request = new AddUserToGroupRequest { UserId = adUserId, GroupName = group }; await PollToAddUserToGroup(request); }
public void GivenIHaveAnAddAUserToAGroupRequestForAValidUserIdAndValidGroup() { var addUserRequest = new AddUserToGroupRequest() { UserId = _context.Config.TestSettings.ExistingUserId, GroupName = _context.Config.TestSettings.NewGroups.First().DisplayName }; _context.Request = _context.Patch(AddUserToGroup, addUserRequest); }
private void AddUserToExternalGroup(string userId) { var request = new AddUserToGroupRequest() { UserId = userId, GroupName = "External" }; _context.Request = _context.Patch(AddUserToGroup, request); _commonSteps.WhenISendTheRequestToTheEndpoint(); _commonSteps.ThenTheResponseShouldHaveTheStatusAndSuccessStatus(HttpStatusCode.Accepted, true); }
private static async Task AddUsersToAdminGroup(IAmazonIdentityManagementService client, CancellationToken token) { CreateGroupRequest groupRequest = new CreateGroupRequest("Admins"); CreateGroupResponse response = await client.CreateGroupAsync(groupRequest, token); AddUserToGroupRequest request = new AddUserToGroupRequest("Admins", SomeUser); var foo = await client.AddUserToGroupAsync(request, token); request = new AddUserToGroupRequest("Admins", AnotherUser); foo = await client.AddUserToGroupAsync(request, token); }
public void OnActionExecuting(ActionExecutingContext context) { foreach (var argument in context.ActionArguments.Values.Where(v => v is AddUserToGroupRequest)) { AddUserToGroupRequest command = argument as AddUserToGroupRequest; if (command.Role == Role.Admin) { _groupValidationService.RequireAuthorizedUserIsGroupAdmin(command.GroupId); } _groupValidationService.RequireUsernameIsNotGroupMember(command.Username, command.GroupId); } }
public void Setup() { _userAccountService = new Mock <IUserAccountService>(); var config = TelemetryConfiguration.CreateDefault(); var client = new TelemetryClient(config); request = Builder <AddUserToGroupRequest> .CreateNew() .With(x => x.GroupName = "TestGroup") .With(x => x.UserId = "johndoe") .Build(); _userAccountService.Setup(u => u.GetGroupByNameAsync(request.GroupName)).ReturnsAsync(new Group()); _userAccountService.Setup(u => u.GetUserByFilterAsync(It.IsAny <string>())).ReturnsAsync(new User()); _controller = new AccountController(_userAccountService.Object, client); }
private async Task AddUserToExternalGroup(string userId) { _testContext.HttpMethod = HttpMethod.Patch; _testContext.Uri = AddUserToGroup; var addUserRequest = new AddUserToGroupRequest() { UserId = userId, GroupName = TestConfig.Instance.Settings.AdGroup.External }; var jsonBody = RequestHelper.Serialise(addUserRequest); _testContext.HttpContent = new StringContent(jsonBody, Encoding.UTF8, "application/json"); _testContext.ResponseMessage = await SendPatchRequestAsync(_testContext); _testContext.ResponseMessage.StatusCode.Should().Be(HttpStatusCode.Accepted); }
/// <summary> /// 用户加入到用户组 /// </summary> /// <param name="req">参考<see cref="AddUserToGroupRequest"/></param> /// <returns>参考<see cref="AddUserToGroupResponse"/>实例</returns> public async Task <AddUserToGroupResponse> AddUserToGroup(AddUserToGroupRequest req) { JsonResponseModel <AddUserToGroupResponse> rsp = null; try { var strResp = await this.InternalRequest(req, "AddUserToGroup"); rsp = JsonConvert.DeserializeObject <JsonResponseModel <AddUserToGroupResponse> >(strResp); } catch (JsonSerializationException e) { throw new TencentCloudSDKException(e.Message); } return(rsp.Response); }
public async Task AddToGroup(AddUserToGroupRequest req) { await Groups.AddToGroupAsync(Context.ConnectionId, req.GroupName); var userInDb = _userRepository.Get(req.Id); var groupInDb = (_groupRepository as GroupManager)?.FindByName(req.GroupName); if (groupInDb == null) { var newGroupId = _groupRepository.Add(new Group { Name = req.GroupName }); groupInDb = _groupRepository.Get(newGroupId); } //check if there's an existing association between user and group that's in db. var userGroupInDb = (_userGroupRepository as UserGroupManager)?.Find(userInDb.Id, groupInDb.Id); //if no association between user and group //then create a new one if (userGroupInDb == null) { var newUserGroup = new UserGroup { UserId = userInDb.Id, GroupId = groupInDb.Id, User = userInDb, Group = groupInDb }; _userGroupRepository.Add(newUserGroup); } await Clients.Caller.SendAsync("ServerMessageOnConnectedToGroup", $"Welcome to the group {userInDb.UserName}!"); await Clients.Caller.SendAsync("ServerDataOnConnectedToGroup", new { groupId = groupInDb.Id, name = groupInDb.Name, userInDb.Id }); await Clients.OthersInGroup(req.GroupName).SendAsync("ServerToGroup", userInDb.UserName); }
public async Task <IActionResult> AddUserToGroup(AddUserToGroupRequest request) { var result = new AddUserToGroupRequestValidation().Validate(request); if (!result.IsValid) { foreach (var failure in result.Errors) { ModelState.AddModelError(failure.PropertyName, failure.ErrorMessage); } var errors = ModelState.Values.SelectMany(v => v.Errors.Select(b => b.ErrorMessage)).ToList(); _telemetryClient.TrackTrace(new TraceTelemetry( $"AddUserToGroupRequest validation failed: {string.Join(separator, errors)}", SeverityLevel.Error)); return(BadRequest(ModelState)); } var group = await _userAccountService.GetGroupByNameAsync(request.GroupName); if (group == null) { _telemetryClient.TrackTrace(new TraceTelemetry($"Group not found '{request.GroupName}'", SeverityLevel.Error)); return(NotFound()); } var user = new User { Id = request.UserId }; try { await _userAccountService.AddUserToGroupAsync(user, group); } catch (UserServiceException e) { ModelState.AddModelError(nameof(user), e.Reason); return(NotFound(ModelState)); } return(Accepted()); }
private async Task PollToAddUserToGroup(AddUserToGroupRequest request) { var policy = Policy .Handle <UserApiException>(ex => ex.StatusCode.Equals(HttpStatusCode.NotFound)) .WaitAndRetryAsync(POLLY_RETRIES, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt))); try { await policy.ExecuteAsync(async() => await _userApiClient.AddUserToGroupAsync(request)); } catch (UserApiException e) { if (e.StatusCode == (int)HttpStatusCode.InternalServerError) { _logger.LogError(e, "{exceptionCode} exception occured with message '{message}' whilst trying to add a group to a user in AAD with username '{userId}'", e.StatusCode, e.Message, request.UserId); throw; } } }
public override async Task <AddUserToGroupResponse> AddUserToGroup(AddUserToGroupRequest request, ServerCallContext context) { Guid groupId = new Guid(request.GroupId); UserGroup group = await _authDbContext.UserGroup .Include(ug => ug.Members) .SingleAsync(ug => ug.Id == groupId); Guid userId = new Guid(request.UserId); AppUser user = await _authDbContext.Users.SingleAsync(u => u.Id == userId); group.Members.Add(user); await _authDbContext.SaveChangesAsync(); return(new AddUserToGroupResponse { Success = true, }); }
static bool AddUserToGroup(string url, Credentials c, string userId, string groupId) { Console.WriteLine("Adding user to group..."); ArticulateOnline ao = new ArticulateOnline { Url = url }; AddUserToGroupRequest request = new AddUserToGroupRequest { Credentials = c, UserID = userId, GroupID = groupId }; AddUserToGroupResponse response = ao.AddUserToGroup(request); Console.WriteLine("Error: " + response.ErrorMessage); return(response.Success); }
public async Task Should_create_citizen_user_on_ad() { var createUserRequest = new CreateUserRequest { RecoveryEmail = $"Automation_{Name.First()}@hmcts.net", FirstName = $"Automation_{Name.First()}", LastName = $"Automation_{Name.Last()}" }; var createUserHttpRequest = new StringContent( RequestHelper.Serialise(createUserRequest), Encoding.UTF8, "application/json"); var createUserResponse = await SendPostRequestAsync(CreateUser, createUserHttpRequest); createUserResponse.StatusCode.Should().Be(HttpStatusCode.Created); var createUserModel = RequestHelper.Deserialise <NewUserResponse>(createUserResponse.Content .ReadAsStringAsync().Result); TestContext.WriteLine($"Response:{RequestHelper.Serialise(createUserModel)}"); createUserModel.Should().NotBeNull(); createUserModel.UserId.Should().NotBeNullOrEmpty(); createUserModel.Username.ToLower().Should() .Be($@"{createUserRequest.FirstName}.{createUserRequest.LastName}@{TestConfig.Instance.Settings.ReformEmail}".ToLower()); createUserModel.OneTimePassword.Should().NotBeNullOrEmpty(); _newUserId = createUserModel.UserId; var addExternalGroupRequest = new AddUserToGroupRequest { UserId = createUserModel.UserId, GroupName = TestConfig.Instance.Settings.AdGroup.External }; var addExternalGroupHttpRequest = new StringContent( RequestHelper.Serialise(addExternalGroupRequest), Encoding.UTF8, "application/json"); var addExternalGroupHttpResponse = await SendPatchRequestAsync(AddUserToGroup, addExternalGroupHttpRequest); addExternalGroupHttpResponse.IsSuccessStatusCode.Should().BeTrue(); }
private async Task AddGroup(string username, string groupName) { try { var addUserToGroupRequest = new AddUserToGroupRequest { UserId = username, GroupName = groupName }; await _userApiClient.AddUserToGroupAsync(addUserToGroupRequest); _logger.LogDebug("{username} to group {group}.", username, addUserToGroupRequest.GroupName); } catch (UserApiException e) { _logger.LogError(e, $"Failed to add user {username} to {groupName} in User API. " + $"Status Code {e.StatusCode} - Message {e.Message}"); throw; } }
public async Task AddUserToGroupAsyncTest() { var mockIAMClient = new Mock <AmazonIdentityManagementServiceClient>(); mockIAMClient.Setup(client => client.AddUserToGroupAsync( It.IsAny <AddUserToGroupRequest>(), It.IsAny <CancellationToken>() )).Callback <AddUserToGroupRequest, CancellationToken>((request, token) => { if (!string.IsNullOrEmpty(request.GroupName)) { Assert.Equal(request.GroupName, GroupName); } ; if (!string.IsNullOrEmpty(request.UserName)) { Assert.Equal(request.UserName, UserName); } }).Returns((AddUserToGroupRequest r, CancellationToken token) => { return(Task.FromResult(new AddUserToGroupResponse() { HttpStatusCode = System.Net.HttpStatusCode.OK, })); }); var client = mockIAMClient.Object; var request = new AddUserToGroupRequest { GroupName = GroupName, UserName = UserName, }; var response = await client.AddUserToGroupAsync(request); var ok = response.HttpStatusCode == System.Net.HttpStatusCode.OK; Assert.True(ok, "Was not able to add the user to the group."); }
protected override void ProcessRecord() { base.ProcessRecord(); AddUserToGroupRequest request; try { request = new AddUserToGroupRequest { AddUserToGroupDetails = AddUserToGroupDetails, OpcRetryToken = OpcRetryToken }; response = client.AddUserToGroup(request).GetAwaiter().GetResult(); WriteOutput(response, response.UserGroupMembership); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
public IActionResult AddUserToGroup(AddUserToGroupRequest command) { _groupUserService.AddUserToGroup(command.Username, command.Role, command.GroupId); return(NoContent()); }
public Task <AddUserToGroupResponse> AddUserToGroupAsync(AddUserToGroupRequest request, CancellationToken cancellationToken = new CancellationToken()) { throw new System.NotImplementedException(); }
public async Task <IActionResult> AddToGroup(AddUserToGroupRequest request) { await fcmRepository.AddToGroup(request); return(Ok(new ApiOkResponse("Add Thành công"))); }
public static async Task <HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "post")] AddUserToGroupRequest request, TraceWriter log) { string siteUrl = request.SiteURL; try { if (string.IsNullOrWhiteSpace(request.SiteURL)) { throw new ArgumentException("Parameter cannot be null", "SiteURL"); } if (string.IsNullOrWhiteSpace(request.Title)) { throw new ArgumentException("Parameter cannot be null", "Title"); } var clientContext = await ConnectADAL.GetClientContext(siteUrl, log); var web = clientContext.Web; var user = web.EnsureUser(request.Title); Microsoft.SharePoint.Client.Group siteGroup = null; switch (request.AssociatedGroup) { case AssociatedGroup.Member: { siteGroup = web.AssociatedMemberGroup; } break; case AssociatedGroup.Owner: { siteGroup = web.AssociatedOwnerGroup; } break; case AssociatedGroup.Visitor: { siteGroup = web.AssociatedVisitorGroup; } break; } if (siteGroup != null) { web.Context.Load(siteGroup); web.Context.Load(user); web.Context.ExecuteQueryRetry(); siteGroup.Users.AddUser(user); web.Context.ExecuteQueryRetry(); return(await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ObjectContent <AddUserToGroupResponse>(new AddUserToGroupResponse { UserAdded = true }, new JsonMediaTypeFormatter()) })); } else { return(await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ObjectContent <AddUserToGroupResponse>(new AddUserToGroupResponse { UserAdded = false }, new JsonMediaTypeFormatter()) })); } } catch (Exception e) { log.Error($"Error: {e.Message }\n\n{e.StackTrace}"); return(await Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ObjectContent <AddUserToGroupResponse>(new AddUserToGroupResponse { UserAdded = false }, new JsonMediaTypeFormatter()) })); } }
private static async Task UserAndGroupOps(IdentityClient client, string compartmentId) { // create a test user CreateUserDetails createUserDetails = new CreateUserDetails { CompartmentId = compartmentId, Name = userName, Description = "testing oci sdk for .NET" }; CreateUserRequest createUserRequest = new CreateUserRequest { CreateUserDetails = createUserDetails }; CreateUserResponse createUserResponse = await client.CreateUser(createUserRequest); User user = createUserResponse.User; logger.Info($"user created, Name : {user.Name} , ID : {user.Id}"); // create a test group CreateGroupDetails createGroupDetails = new CreateGroupDetails { CompartmentId = compartmentId, Name = "oci-dotnetsdk-testgroup", Description = "testing oci sdk for .NET" }; CreateGroupRequest createGroupRequest = new CreateGroupRequest { CreateGroupDetails = createGroupDetails }; CreateGroupResponse createGroupResponse = await client.CreateGroup(createGroupRequest); logger.Info($"new group created, Name : {createGroupResponse.Group.Name} , Id : {createGroupResponse.Group.Id}"); Group group = createGroupResponse.Group; // add the user to the group logger.Info("Adding new user to the new group"); AddUserToGroupDetails addUserToGroupDetails = new AddUserToGroupDetails { UserId = user.Id, GroupId = group.Id }; AddUserToGroupRequest addUserToGroupRequest = new AddUserToGroupRequest { AddUserToGroupDetails = addUserToGroupDetails }; AddUserToGroupResponse addUserToGroupResponse = await client.AddUserToGroup(addUserToGroupRequest); logger.Info($"Added user: {user.Name} to the group: {group.Name}"); // remove user from the group logger.Info($"removing user: {user.Name} from the group: {group.Name}"); RemoveUserFromGroupRequest removeUserFromGroupRequest = new RemoveUserFromGroupRequest { UserGroupMembershipId = addUserToGroupResponse.UserGroupMembership.Id }; await client.RemoveUserFromGroup(removeUserFromGroupRequest); // delete the user logger.Info($"deleting the user: {user.Name}"); DeleteUserRequest deleteUserRequest = new DeleteUserRequest { UserId = user.Id }; await client.DeleteUser(deleteUserRequest); // delete the group logger.Info($"deleting the group: {group.Name}"); DeleteGroupRequest deleteGroupRequest = new DeleteGroupRequest { GroupId = group.Id }; await client.DeleteGroup(deleteGroupRequest); logger.Info("Finished delete user and group"); }