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