public async Task <ServiceResponse <GetUserDto> > AuthenticateUser(AuthenticateUserDto authUser) { ServiceResponse <GetUserDto> serviceResponse = new ServiceResponse <GetUserDto>(); try { User user = await(from u in _context.Users where u.Name == authUser.Email select u).FirstOrDefaultAsync(); //if (user == null || !BC.Verify(authUser.Password, user.Password)) if (user == null || !customPasswordHasher.VerifyPassword(user.PasswordHash, authUser.Password)) { serviceResponse.Data = null; serviceResponse.Success = false; serviceResponse.Message = "Wrong user and/or password"; } else { serviceResponse.Data = _mapper.Map <GetUserDto>(user); serviceResponse.Message = "JWT Token goes here!"; } } catch (System.Exception ex) { serviceResponse.Success = false; serviceResponse.Message = ex.Message; } return(serviceResponse); }
public IActionResult Authenticate([FromBody] AuthenticateModel authenticateModel) { AuthenticateUserDto authenticateUserDto = _usersService.Authenticate(authenticateModel.Email, authenticateModel.Password); if (authenticateUserDto == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_appSettings.Secret); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, authenticateUserDto.Id.ToString()) }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; SecurityToken token = tokenHandler.CreateToken(tokenDescriptor); string tokenString = tokenHandler.WriteToken(token); return(Ok(new { authenticateUserDto.Id, authenticateUserDto.Email, authenticateUserDto.FirstName, authenticateUserDto.LastName, Token = tokenString })); }
public async Task <IActionResult> AuthenticateUser([FromBody] AuthenticateUserDto user) { var authUser = await _userRepository.AuthenticateUserAsync(user.Username, user.Password); if (authUser == null) { return(BadRequest(new { message = "Username or Password is incorrect" })); } var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.ASCII.GetBytes(_config["JwtSettings:Secret"]); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, authUser.Id.ToString()), }), Expires = DateTime.UtcNow.AddDays(7), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var token = tokenHandler.CreateToken(tokenDescriptor); var tokenString = tokenHandler.WriteToken(token); authUser.Token = tokenString; var userToReturn = _mapper.Map <UserForAuthenticationDto> (authUser); return(Ok(userToReturn)); }
public AuthenticatedUserDto AuthenticateUser(AuthenticateUserDto authenticateUser) { if (authenticateUser == null) { return(new AuthenticatedUserDto($"{nameof(authenticateUser)} not found.")); } if (string.IsNullOrEmpty(authenticateUser.Email)) { return(new AuthenticatedUserDto("Email is required.")); } if (string.IsNullOrEmpty(authenticateUser.Password)) { return(new AuthenticatedUserDto("Password is required.")); } string passwordDecrypt = this.EncryptionService.Decrypt(authenticateUser.Password); UserSystemDto userSystem = this.UserService.Find(authenticateUser.Email, passwordDecrypt); if (userSystem == null) { return(new AuthenticatedUserDto("The email and/or password entered is invalid. Please try again.")); } return(new AuthenticatedUserDto(userSystem)); }
public async Task <IActionResult> AuthenticateUser([FromBody] AuthenticateUserDto authUser) { ServiceResponse <GetUserDto> response = await _userService.AuthenticateUser(authUser); if (response.Data == null) { return(Unauthorized(response)); } else { ServiceResponse <JwtTokens> respjwtTokens = new ServiceResponse <JwtTokens>(); _jwtAuthManager.RemoveRefreshTokenByUserName(authUser.Email); var claims = new[] { new Claim("Email", authUser.Email), new Claim("Role", "role"), new Claim("Activated", response.Data.Status == UserStatus.Disabled ? "False": "True") }; var jwtResult = _jwtAuthManager.GenerateTokens(authUser.Email, claims, DateTime.Now); _logger.LogInformation($"User [{authUser.Email}] logged in the system."); JwtTokens jwtTokens = new JwtTokens(); jwtTokens.AccessToken = jwtResult.AccessToken.ToString(); jwtTokens.RefreshToken = jwtResult.RefreshToken.TokenString; respjwtTokens.Data = jwtTokens; respjwtTokens.Message = "Validated"; return(Ok(jwtResult)); } }
public IActionResult Authenticate([FromBody] AuthenticateUserDto authenticateUserDto) => _mapper.Map <User>(authenticateUserDto) .Map(_userService.Authenticate) .Map(x => AllOk(new KeyDto() { Key = x.Key })) .Reduce(AuthenticationErrorHandler, err => err is AuthenticationError) .Reduce(InternalServisErrorHandler);
public async Task <IActionResult> AuthenticateAsync([FromBody] AuthenticateUserDto credentials) { if (await userService.AuthenticateUserAsync(credentials)) { return(Ok(jwtService.GenerateToken(credentials.UserName, Roles.Admin))); } return(BadRequest(ValidationResultFactory(nameof(credentials), credentials, UserControllerResources.AuthenticationFailed))); }
public IActionResult Authenticate([FromBody] AuthenticateUserDto authenticateUserDto) { var token = _userService.Authenticate(authenticateUserDto.Username, authenticateUserDto.Password); if (token == null) { return(BadRequest(new { message = "Username of password incorrect" })); } return(Ok(new { Token = token })); }
public async Task <IActionResult> Login(AuthenticateUserDto request) { ServiceResponse <string> response = await _authRepo.Login( request.Email, request.Password); if (!response.Success) { return(BadRequest(response)); } return(Ok(response)); }
public async Task <ActionResult> Authenticate(AuthenticateUserDto authenticationUserDto) { try { string token = await _business.Authenticate(authenticationUserDto); return(Ok(token)); } catch (AuthenticationFailedException exception) { return(Unauthorized(exception.Message)); } }
public async Task <IActionResult> Login(AuthenticateUserDto apiRequest) { var result = await _signInManager.PasswordSignInAsync( apiRequest.UserName, apiRequest.Password, true, true); if (result.Succeeded) { return(Ok()); } return(BadRequest()); }
public IActionResult Authentication([FromBody] AuthenticateUserDto userAuthentication) { if (userAuthentication == null) { return(this.BadRequest(this.NotificationFactory.Error($"{nameof(userAuthentication)} not found."))); } AuthenticatedUserDto authenticatedUserDto = this.AuthenticationService.AuthenticateUser(userAuthentication); if (!authenticatedUserDto.Authenticated) { return(this.BadRequest(this.NotificationFactory.Error(authenticatedUserDto.Error))); } return(this.Ok(this.NotificationFactory.Success(authenticatedUserDto.UserSystem))); }
public IActionResult Authenticate([FromBody] AuthenticateUserDto userLoginDTO) { return(_mapper.Map <User>(userLoginDTO) //form AuthUserDto to User .Map(_userService.Authenticate) .Map(_mapper.Map <UserDto>) .Map(InsertToken) .Map(_userService.AddAuthenticatedUser) .Map(x => AllOk(new KeyDto() { Key = x.Key })) .Reduce(AuthenticationErrorHandler, err => err is AuthenticationError) .Reduce(InternalServisErrorHandler)); //KeyDto keyData = _mapper.Map<KeyDto>(userData); //return Ok(keyData); }
public Task <string> Authenticate(AuthenticateUserDto authenticationUserDto) { User user = null; try { user = _repository.GetAll().Where(user => user.Mail == authenticationUserDto.Mail).Include(user => user.RoleNavigation).Single(); } finally { if (user == null || !_passwordHasher.Check(authenticationUserDto.Password, user.HashedPassword)) { throw new AuthenticationFailedException(); } } string token = _jwtGenerator.GenerateToken(user.Id, user.RoleNavigation.Name); return(Task.FromResult(token)); }
public async Task <IActionResult> AuthenticateUser(AuthenticateUserDto userDto) { try { var authenticationResult = await userService.AuthenticateUser(userDto); return(Ok(authenticationResult)); } catch (System.Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, new ResponseDto <UserDto> { Errors = new List <ErrorDto> { new ErrorDto { ErrorCode = 1, ErrorMessage = ex.Message } } })); } }
public async Task <IActionResult> AuthenticateUser([FromBody] AuthenticateUserDto user) { if (user == null) { return(BadRequest("The body is empty.")); } var filter = Builders <BsonDocument> .Filter.Eq("Email", user.Email); var query_res = await userCollection.Find(filter).FirstOrDefaultAsync(); if (query_res == null) { return(BadRequest(user.Email + " is not a user.")); } if (HashString(user.Password) == query_res["Password"]) { return(Ok(query_res["_id"].ToString())); } return(BadRequest("Incorrect password.")); }
public async Task <ResponseDto <UserDto> > AuthenticateUser(AuthenticateUserDto userDto) { var userEntity = await userRepository.GetUserByEmail(userDto.Email); if (userEntity != null) { userEntity.LastLogin = DateTime.Now; } var updatedUserEntity = await userRepository.UpdateUser(userEntity); if (updatedUserEntity != null) { return(new ResponseDto <UserDto> { Results = new UserDto { Email = updatedUserEntity.Email, Id = updatedUserEntity.Id, FullName = updatedUserEntity.FullName, ActivationId = updatedUserEntity.ActivationId, LastLogin = updatedUserEntity.LastLogin } }); } return(null); }
public async Task <bool> AuthenticateUserAsync(AuthenticateUserDto credentials) { var user = await userRepository.GetByUserName(credentials.UserName); return(user != null && encypterService.GetHash(credentials.Password, user.Salt) == user.Password ? true : false); }