public async Task ShouldBeHttpStatusCodeOK()
{
// Arrange
var user = TestData.FileStorage.GetUsers().First();
var factory = TestHost;
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var service = scope.GetRequiredService <IUserService>();
await service.CreateAsync(user, Password);
});
var request = new LoginAccountRequest
{
Email = user.Email,
Password = Password,
RememberMe = false,
ReturnUrl = "/"
};
// Act
using var response = await this.ExecuteAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.OK);
// Francis: Est-ce que je dois vérifier si il est connecté ???
}
public async Task <IActionResult> LoginAccountAsync([FromBody] LoginAccountRequest request)
{
var context = await _interactionService.GetAuthorizationContextAsync(request.ReturnUrl);
if (context != null)
{
var user = await _userService.FindByEmailAsync(request.Email);
if (user != null)
{
var result = await _signInService.PasswordSignInAsync(
user,
request.Password,
request.RememberMe,
true);
if (result.Succeeded)
{
await _eventService.RaiseAsync(new UserLoginSuccessEvent(user.UserName, user.Id.ToString(), user.UserName));
return(this.Ok(request.ReturnUrl));
}
var errorMessage = AccountErrorDescriber.PasswordInvalid();
await _eventService.RaiseAsync(new UserLoginFailureEvent(user.UserName, errorMessage));
ModelState.AddModelError(DomainValidationError.FailedPreconditionPropertyName, errorMessage);
return(this.BadRequest(new ValidationProblemDetails(ModelState)));
}
}
return(this.Unauthorized());
}
public async Task ShouldBeHttpStatusCodeBadRequest()
{
// Arrange
var user = TestData.FileStorage.GetUsers().First();
var factory = TestHost.WithClaimsFromDefaultAuthentication(new Claim(JwtClaimTypes.Subject, user.Id.ToString()));
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
await testServer.UsingScopeAsync(
async scope =>
{
var service = scope.GetRequiredService <IUserService>();
await service.CreateAsync(user, Password);
});
var request = new LoginAccountRequest
{
Email = user.Email,
Password = "******",
RememberMe = false,
ReturnUrl = "/"
};
// Act
using var response = await this.ExecuteAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
// Francis: Est-ce que je devrais checker si le message derreur est le bon ???
}
public async Task ShouldBeHttpStatusCodeUnauthorized()
{
// Arrange
var user = TestData.FileStorage.GetUsers().First();
var factory = TestHost;
_httpClient = factory.CreateClient();
var testServer = factory.Server;
testServer.CleanupDbContext();
var request = new LoginAccountRequest
{
Email = user.Email,
Password = Password,
RememberMe = false,
ReturnUrl = "/"
};
// Act
using var response = await this.ExecuteAsync(request);
// Assert
response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
}
public Guid Login(LoginAccountRequest request)
{
var response = ExecuteRequest <LoginAccountRequest, LoginAccountResponse>(request);
Client.DefaultRequestHeaders.Add(response.Coockie.Key, new List <string> {
response.Coockie.Value
});
return(response.UserId);
}
public string LoginUser([FromBody] LoginAccountRequest loginAccountRequest)
{
var loginResponse = _loginService.LoginUser(loginAccountRequest);
if (loginResponse.StatusCode == (int)HttpStatusCode.OK)
{
loginResponse.AccessToken = TokenManager.GenerateAccessToken(loginAccountRequest.Email);
}
return(loginResponse.ToString());
}
public LoginAccountResponse Login(LoginAccountRequest request)
{
this.Assert(request.UserName);
if (!WebSecurity.Login(request.UserName, request.Password, request.RememberMe))
{
throw new AuthenticationException("Bad login or password");
}
var cookie = FormsAuthentication.GetAuthCookie(request.UserName, request.RememberMe);
var userId = Context.Accounts.FirstOrDefault(u => string.Compare(u.AccountName, request.UserName, StringComparison.OrdinalIgnoreCase) == 0).UserId.Value;
return(new LoginAccountResponse(userId, cookie));
}
public async Task <AccountLoginResult> PostLoginAccount([FromBody] LoginAccountRequest loginAccountRequest)
{
Account account = await _accountRepository.LoginAccount(loginAccountRequest.Email, loginAccountRequest.Password);
AccountLoginResult accountLoginResult = new AccountLoginResult();
accountLoginResult.Token = _tokenJwtService.GenerateToken(account);
accountLoginResult.Expires = DateTime.UtcNow.AddHours(int.Parse(AppSettingsProvider.Settings["TimeExpirationTokenJwtBearer"]));
accountLoginResult.Type = "Bearer";
return(accountLoginResult);
}
public LoginRequestResponse LoginUser(LoginAccountRequest loginAccountRequest)
{
LoginRequestResponse loginRequestResponse = new LoginRequestResponse();
if (_authRepository.CustomerAccountExists(loginAccountRequest.Email, loginAccountRequest.Password))
{
loginRequestResponse = CreateLoginResponse(loginAccountRequest, (int)HttpStatusCode.OK);
}
else
{
loginRequestResponse = CreateLoginResponse(loginAccountRequest, (int)HttpStatusCode.NotFound);
}
return(loginRequestResponse);
}
public async Task <IActionResult> Login(LoginAccountRequest loginAccountRequest)
{
if (!ModelState.IsValid)
{
return(View(loginAccountRequest));
}
var user = await _userManager.FindByNameAsync(loginAccountRequest.UserName);
if (user == null)
{
loginAccountRequest.LoginSuccess = false;
loginAccountRequest.Error = "Sai ten dang nhap";
return(View(loginAccountRequest));
}
var result = await _signInManager.PasswordSignInAsync(user, loginAccountRequest.Passwword, false, false);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
loginAccountRequest.LoginSuccess = false;
loginAccountRequest.Error = "Sai mat khau";
return(View());
}
public LoginRequestResponse CreateLoginResponse(LoginAccountRequest loginAccountRequest, int statusCode)
{
return(_authRepository.CreateLoginResponse(loginAccountRequest.Email, loginAccountRequest.Password, statusCode));
}
public Task <HttpResponseMessage> Login([FromBody] LoginAccountRequest request)
{
return(ExecuteAction(request, Repository.Login));
}
private async Task <HttpResponseMessage> ExecuteAsync(LoginAccountRequest request)
{
return(await _httpClient.PostAsJsonAsync("api/account/login", request));
}
