public async Task <CreateUser.Response> CreateUser(CreateUser.Request request, CancellationToken cancellationToken = default)
{
var existedUser = await _userManager.FindByNameAsync(request.Username);
if (existedUser != null)
{
throw new ConflictException("Пользователь с таким именем уже существует");
}
var identityUser = new IdentityUser {
UserName = request.Username
};
var identityResult = await _userManager.CreateAsync(identityUser, request.Password);
if (identityResult.Succeeded)
{
await _userManager.AddToRoleAsync(identityUser, request.Role);
return(new CreateUser.Response
{
UserId = identityUser.Id,
IsSuccess = true
});
}
return(new CreateUser.Response
{
IsSuccess = false,
Errors = identityResult.Errors.Select(x => x.Description).ToArray()
});
}
public async Task <Result <Unit> > AuthorizeUser(ClaimsPrincipal user)
{
if (!user.Identity.IsAuthenticated)
{
SetCurrentContext(GetAnonymousVisitor(_predefinedAnonymousUserId));
return(Unit.Value);
}
var idValue = GetUserIdFromClaims(user);
if (idValue == null)
{
return(Error.NotAuthorized("UserId claim is missing"));
}
if (IsPredefinedSystemId(idValue))
{
return(Error.NotAuthorized("User Id is invalid"));
}
Result <Unit> result;
var getRequest = new GetUser.Request
{
UserId = new UserId(idValue),
Tenant = TenantId.Default
};
var getUser = await _getUserHandler.Handle(getRequest);
if (getUser.IsSuccessful)
{
result = Unit.Value;
SetCurrentContext(getUser.Value);
}
else if (getUser.Error.Type == ErrorType.NotFound)
{
var createRequest = new CreateUser.Request
{
UserId = new UserId(idValue),
Tenant = TenantId.Default,
Role = VisitorRole
};
var createUser = await _createUserHandler.Handle(createRequest);
if (createUser.IsSuccessful)
{
result = Unit.Value;
SetCurrentContext(createUser.Value);
}
else
{
result = createUser.Error;
}
}
else
{
result = getUser.Error;
}
return(result);
}
public void ScenarioSetup()
{
_authFixture.SetTestUserPermission(IdentityAndAccessConstants.Context, nameof(CreateUser));
_expectedUser = UserBuilder.New();
_request = new CreateUser.Request();
}
public async Task <IActionResult> AddUser([FromBody] CreateUser.Request request)
{
request.ActionBy = UserId.GetValueOrDefault();
var result = await Mediator.Send(request);
return(Respond(result));
}
public void ScenarioSetup()
{
_expectedRequest = new CreateUser.Request
{
Tenant = TenantId.Default,
Role = _visitorRole
};
}
public async void SearchUser_ShouldReturn_Response(CreateUser.Request request)
{
var mediator = host.Services.GetService <IMediator>();
var response = await mediator.Send(new GetUserList.Request {
Name = request.Email
});
Assert.NotNull(response);
}
private void MockCreateUserSuccess()
{
_createHandler.Handle(Arg.Any <CreateUser.Request>())
.Returns(ci => Task.FromResult(
(Result <User>) new User(
ci.Arg <CreateUser.Request>().UserId,
ci.Arg <CreateUser.Request>().Tenant)))
.AndDoes(ci => { _actualRequest = ci.Arg <CreateUser.Request>(); });
}
public async void CreateUser_ShouldCreate_User(CreateUser.Request request)
{
var mediator = host.Services.GetService <IMediator>();
var response = await mediator.Send(request);
Assert.NotNull(response);
Assert.True(response.Id > 0);
Assert.Equal(request.Email, response.Email);
Assert.Equal(request.Gender, response.Gender);
Assert.Equal(request.Status, response.Status);
Assert.Equal(request.Name, response.Name);
}
public async Task <ActionResult <CreateUser.Response> > CreateUserAsnyc(CreateUser.Request request)
{
CreateUser.Response response = await new CreateUser(_userManager).DoModelAsync(request);
if (response.isSucceeded)
{
return(Ok(response));
}
else
{
return(BadRequest(response));
}
}
public async Task <CreateUser.Response> CreateUser(CreateUser.Request request, CancellationToken cancellationToken = default)
{
var existedUser = await _userManager.FindByEmailAsync(request.Email);
if (existedUser != null)
{
throw new DuplicateException("Пользователь с почтой уже существует");
}
var newUser = new IdentityUser
{
Email = request.Email,
UserName = request.Username
};
var identityResult = await _userManager.CreateAsync(newUser, request.Password);
if (identityResult.Succeeded)
{
await _userManager.AddToRoleAsync(newUser, request.Role);
var confirmationToken = await _userManager.GenerateEmailConfirmationTokenAsync(newUser);
var encodedToken = HttpUtility.UrlEncode(confirmationToken);
var message = MessageToConfirmEmail.Message(newUser.Id, newUser.Id, encodedToken, _configuration["ApiUri"]);
try
{
await _mailService.Send(request.Email, "Подтвердите Email!", message, cancellationToken);
}
catch (Exception ex)
{
await _userManager.DeleteAsync(newUser);
throw new SendingMailException("Произошла ошибка!" + ex.Message);
}
return(new CreateUser.Response
{
IsSuccess = true,
UserId = newUser.Id
});
}
return(new CreateUser.Response
{
IsSuccess = false,
Errors = identityResult.Errors.Select(x => x.Description).ToArray()
});
}
public async void GetUser_ShouldReturn_User(CreateUser.Request request)
{
var mediator = host.Services.GetService <IMediator>();
// Create a user
var created = await mediator.Send(request);
Assert.NotNull(created);
Assert.True(created.Id > 0);
var user = await mediator.Send(new GetUser.Request {
Id = created.Id
});
Assert.NotNull(user);
Assert.NotEmpty(user.Email);
Assert.Equal(request.Email, user.Email);
}
public async void UpdateUser_ShouldUpdate_UserName(CreateUser.Request request)
{
var mediator = host.Services.GetService <IMediator>();
// Create a user
var created = await mediator.Send(request);
Assert.NotNull(created);
Assert.True(created.Id > 0);
const string name = "George Who Knows";
var response = await mediator.Send(new UpdateUser.Request {
Id = created.Id,
Name = name
});
Assert.Equal(created.Id, response.Id);
Assert.Equal(name, response.Name);
Assert.Equal(request.Email, response.Email);
}
public async void DeleteUser_ShouldDelete_User(CreateUser.Request request)
{
var mediator = host.Services.GetService <IMediator>();
// Create a user
var created = await mediator.Send(request);
Assert.NotNull(created);
Assert.True(created.Id > 0);
// It should delete created user
await mediator.Send(new DeleteUser.Request {
Id = created.Id
});
await Assert.ThrowsAsync <GoRestApiException>((() => mediator.Send(new DeleteUser.Request()
{
Id = created.Id
})));
}
public void MockCreateUserSuccess()
{
User BuildUser(CallInfo ci)
{
var req = ci.Arg <CreateUser.Request>();
var result = new User(
req.UserId,
req.Tenant);
if (req.Role != null)
{
result.AssignRole(req.Role);
}
return(result);
}
_createHandler.Handle(Arg.Any <CreateUser.Request>())
.Returns(ci => BuildUser(ci))
.AndDoes(ci => { _actualCreateRequest = ci.Arg <CreateUser.Request>(); });
OverrideHandlerMetadata <CreateUser.Request>(
new HandlerInfo("IdentityAndAccess", "CreateUser"));
}
public async Task <IActionResult> CreateUser([FromBody] CreateUser.Request request) => Ok((await new CreateUser(_userManager).Do(request)));
public void VerifyUserCreated(CreateUser.Request expectedRequest)
{
_actualCreateRequest.Should().BeEquivalentTo(expectedRequest,
"user should be created with ID claim, with default tenant and assigned visitor role");
}
public async Task <IActionResult> CreateUser([FromBody] CreateUser.Request request)
{
await _createUser.Do(request);
return(Ok());
}
public async Task <IActionResult> CreateAsync([FromBody] CreateUser.Request request)
{
var response = await _mediator.Send(request, HttpContext.RequestAborted);
return(Created($"users/{response.User.Id}", response.User));
}
