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