public async Task Handle_CredentialsCorrect_ShouldReturnLoggedInData()
{
// Arrange
var user = await _wolkDbContext.CreateAndSaveUser();
var request = new SignInQuery {
Email = user.Email, Password = "******"
};
_mockSignInManager
.Setup(m => m.CheckCredentialsAsync(request.Email, request.Password))
.ReturnsAsync(true);
var jwt = "dsfad.jwt.rwsdf";
_mockJwtManager
.Setup(m => m.CreateJwt(user))
.Returns(jwt);
// Act
var result = await _handler.Handle(request, CancellationToken.None);
// Assert
Assert.AreEqual(user.Email, result.Email);
Assert.AreEqual(user.Id, result.Id);
Assert.AreEqual(jwt, result.Token);
}
public async Task <ActionResult> SignIn([FromBody] SignInRequest request)
{
var query = new SignInQuery(request.Email, request.Password);
var result = await _dispatcher.QueryAsync(query);
return(Ok(result));
}
public async Task <Response <UserResponse> > Handle(SignInQuery request, CancellationToken cancellationToken)
{
try
{
var existUser = await _authRepository.GetUserByEmail(request.Email);
if (existUser is null)
{
return(Response <UserResponse> .Fail("message", "Usuário e/ou senha inválidos"));
}
var user = await _authRepository.Authenticate(request.Email, request.Password);
if (user != null)
{
user = await _authRepository.UpdateLastLogin(user);
}
return(Response <UserResponse> .Ok(new UserResponse(user)));
}
catch
{
throw;
}
}
public IList <EmployeeLog> GetEmployeeLog(SignInQuery query)
{
var criteria = Session.CreateCriteria <EmployeeLog>();
if (!string.IsNullOrEmpty(query.UserName))
{
criteria.CreateAlias("Employee", "e").Add(Expression.Like("e.Name", query.UserName + "%"));
}
if (query.LocationId.HasValue)
{
criteria.Add(Expression.Eq("LocationId", query.LocationId.Value));
}
if (query.SignInDateStart.HasValue)
{
criteria.Add(Expression.Ge("SignInDate", query.SignInDateStart.Value));
}
if (query.SignInDateEnd.HasValue)
{
criteria.Add(Expression.Le("SignInDate", query.SignInDateEnd.Value));
}
criteria.Add(Expression.IsNull("SignOutDate"));
if (string.IsNullOrEmpty(query.SortBy))
{
criteria.AddOrder(new Order("Id", true));
}
else
{
criteria.AddOrder(new Order(query.SortBy, (query.SortDirection != null && query.SortDirection.Equals("asc", StringComparison.InvariantCultureIgnoreCase))));
}
return(criteria.List <EmployeeLog>());
}
public async Task ReturnsSuccessStatusCode()
{
//Arrage
var client = _factory.GetAnonymousClient();
var query = new SignInQuery()
{
Email = "*****@*****.**",
Password = "******"
};
var content = Utilities.GetRequestContent(query);
//Act
var response = await client.PostAsync($"api/user/signin", content);
//Assert
response.EnsureSuccessStatusCode();
var responseContent = await Utilities.GetResponseContent <UserModel>(response);
Assert.NotNull(responseContent);
Assert.NotNull(responseContent.Id);
Assert.NotNull(responseContent.Email);
Assert.NotNull(responseContent.UserName);
Assert.NotNull(responseContent.AccessToken);
}
public async void Should_ThrowException_When_ConnectMongoDB_ReturnInvalidException()
{
var command = new SignInQuery {
Email = EMAIL, Password = PASSWORD
};
_authRepository
.When(x => x.GetUserByEmail(Arg.Any <string>()))
.Do(callInfo => throw new Exception());
await Assert.ThrowsAsync <Exception>(async() => await _handler.Handle(command, CancellationToken.None));
}
public IList <EmployeeLogView> GetEmployeeLog(SignInQuery query)
{
var criteria = Session.CreateCriteria <EmployeeLogView>();
criteria.Add(Expression.Between("SignInDate", query.SignInDateStart.Value, query.SignInDateEnd.Value));
if (query.LocationId.HasValue)
{
criteria.CreateAlias("Location", "l").Add(Expression.Eq("l.Id", query.LocationId.Value));
}
return(criteria.List <EmployeeLogView>());
}
public async Task <CommandResult <UserData> > Handle(SignInQuery request, CancellationToken cancellationToken)
{
var user = _userRepository.QueryAllIncluding(a => a.Address).FirstOrDefault(u => u.Email == request.Email && u.Password == request.Password);
if (user == null)
{
return(await Task.FromResult(CommandResult <UserData> .Fail("Fail to log in. Wrong email or password")));
}
return(await Task.FromResult(CommandResult <UserData> .Success(new UserData {
Id = user.Id, Address = user.Address, FullName = user.FullName, Email = user.Email
})));
}
public async Task Should_Returns_BadRequest_When_EmailDoesNotExist()
{
var command = new SignInQuery {
Email = EMAIL, Password = PASSWORD
};
_authRepository.GetUserByEmail(Arg.Any <string>()).Returns(Task.FromResult <User>(null));
var actual = await _handler.Handle(command, CancellationToken.None);
Assert.NotNull(actual);
Assert.True(actual.IsFailure);
}
public async Task <IActionResult> SignIn([FromBody] SignInQuery query)
{
var appUser = await Mediator.Send(query);
var userModel = _mapper.Map <UserModel>(appUser);
var userProfile = await Mediator.Send(new GetUserProfileQuery()
{
Id = appUser.Id
});
userModel = _mapper.Map(userProfile, userModel);
return(Ok(userModel));
}
public async Task Handle_CredentialsIncorrect_ShouldThrowUnauthorizedException()
{
// Arrange
var request = new SignInQuery {
Email = "*****@*****.**", Password = "******"
};
_mockSignInManager
.Setup(m => m.CheckCredentialsAsync(request.Email, request.Password))
.ReturnsAsync(false);
// Act / Assert
await Assert.ThrowsExceptionAsync <UnauthorizedException>(() =>
_handler.Handle(request, CancellationToken.None));
}
public async Task Should_Returns_BadRequest_When_DoesNotExistUser_OnSignIn()
{
var query = new SignInQuery {
Email = EMAIL, Password = PASSWORD
};
_mediator.Send(Arg.Any <SignInQuery>()).Returns(x =>
{
return(Response <UserResponse> .Ok(CreateResponseNull()));
});
var actual = await _controller.SignIn(query);
Assert.NotNull(actual);
Assert.Equal(((BadRequestObjectResult)actual).StatusCode, (int)HttpStatusCode.BadRequest);
}
public async Task ReturnsUnauthorizeStatusCode_WhenInvalidEmailOrPassword(string email, string password)
{
//Arrage
var client = _factory.GetAnonymousClient();
var query = new SignInQuery()
{
Email = email,
Password = password
};
var content = Utilities.GetRequestContent(query);
//Act
var response = await client.PostAsync($"api/user/signin", content);
//Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
}
public async Task Should_Returns_OK_When_SignInUser_OnSignIn()
{
var query = new SignInQuery {
Email = EMAIL, Password = PASSWORD
};
_mediator.Send(Arg.Any <SignInQuery>()).Returns(x =>
{
return(Response <UserResponse> .Ok(CreateResponse()));
});
var actual = await _controller.SignIn(query);
Assert.NotNull(actual);
Assert.Equal(((OkObjectResult)actual).StatusCode, (int)HttpStatusCode.OK);
Assert.Equal(((User)((OkObjectResult)actual).Value).Password, PASSWORD);
Assert.Equal(((User)((OkObjectResult)actual).Value).Email, EMAIL);
}
public async Task Should_Returns_User_When_SuccessOnSingIn()
{
var command = new SignInQuery {
Email = EMAIL, Password = PASSWORD
};
_authRepository.GetUserByEmail(Arg.Any <string>()).Returns(new User(OBJECT_ID, NAME, EMAIL, PASSWORD, PHONES, DateTime.UtcNow, DateTime.UtcNow, DateTime.UtcNow, TOKEN));
_authRepository.Authenticate(Arg.Any <string>(), Arg.Any <string>()).Returns(new User(OBJECT_ID, NAME, EMAIL, PASSWORD, PHONES, DateTime.UtcNow, DateTime.UtcNow, DateTime.UtcNow, TOKEN));
_authRepository.UpdateLastLogin(Arg.Any <User>()).Returns(new User(OBJECT_ID, NAME, EMAIL, PASSWORD, PHONES, DateTime.UtcNow, DateTime.UtcNow, DateTime.UtcNow, TOKEN));
var actual = await _handler.Handle(command, CancellationToken.None);
Assert.NotNull(actual);
Assert.True(actual.IsSuccess);
Assert.NotNull(actual.Value.User);
Assert.Equal(actual.Value.User.Email, EMAIL);
Assert.Equal(actual.Value.User.Name, NAME);
}
public async Task<IActionResult> SignIn([FromBody] SignInQuery userQuery)
{
if (userQuery is null)
{
return BadRequest(CreateErrorResponse("Parâmetros inválidos ou nulos"));
}
var response = await _mediator.Send(userQuery);
if (response.IsFailure)
{
return BadRequest(response.Messages);
}
if (response.Value?.User is null)
{
return BadRequest(CreateErrorResponse("Usuário e/ou senha inválidos"));
}
return Ok(response.Value.User);
}
public async Task <Response <AuthResponseData> > Handle(SignInQuery query, CancellationToken cancellationToken)
{
var response = new Response <AuthResponseData>
{
RequestCreated = query.Request.Created,
RequestId = query.Request.Id,
ResponseData = null,
};
try
{
var userOnDb = await _usersRepository.GetUser(query.Request.RequestData.Email);
if (userOnDb != null)
{
if (PasswordHelper.VerifyPasswordHash(query.Request.RequestData.Password, userOnDb.PasswordHash, userOnDb.PasswordSalt))
{
var systemAuthSecretKey = ConfigurationHelper.GetConfigSection <string>("JwtToken:SystemAuthSecretKey");
var barerTokenValidPeriodHours = ConfigurationHelper.GetConfigSection <int>("JwtToken:ValidPeriodHours");
response.ResponseData = AuthHelper.CreateAuthResponseData(
userOnDb.AppKey,
userOnDb.EMail, systemAuthSecretKey,
new JwtData
{
UserAppKey = userOnDb.AppKey,
CreateDate = DateTime.Now,
ExpirationDate = DateTime.Now.AddHours(barerTokenValidPeriodHours)
});
}
}
}
catch (Exception e)
{
Log.Error(e, e.Message);
response.Errors.Add(e.Message);
}
return(response);
}
public IActionResult SignIn([FromBody] SignInQuery query)
{
return(Ok(Dispatcher.Query(query)));
}
public async Task <ActionResult <JsonWebToken> > SignIn(SignInQuery query) => await _dispatcher.QueryAsync(query);
public async Task <string> SignIn(SignInQuery query) => await _queryBus.ExecuteAsync(query);
public async Task <ActionResult <object> > SignIn(SignInQuery query) => Result(await _identityService.SignInAsync(query));
public async Task <IActionResult> SignInWithService(SignInQuery dto) => Ok(await _identityService.SignInAsync(dto.Email, dto.Password));
public async Task <IActionResult> Post([FromBody] SignInQuery query)
{
var token = await QueryDispatcher.DispatchQueryAsync <UserSignedInDto, SignInQuery>(query);
return(Ok(token));
}
