aswi2022code-of-duty-gitlab/backend/src/main/java/cz/zcu/kiv/backendapi/security/jwt/JwtUsernameAndPasswordAuthenticationFilter.java @ ae654ef7

package cz.zcu.kiv.backendapi.security.jwt;

import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import com.fasterxml.jackson.databind.ObjectMapper;
import cz.zcu.kiv.backendapi.user.UserEntity;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.authentication.AuthenticationCredentialsNotFoundException;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.stream.Collectors;

/**
 * Class that checks login and provides user with tokens after successful login
 */
@Slf4j
@RequiredArgsConstructor
public class JwtUsernameAndPasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter {
    /**
     * Authentication manager
     */
    private final AuthenticationManager authenticationManager;

    /**
     * JWT utils
     */
    private final JwtUtils jwtUtils;

    /**
     * Attempts authentication - checks username and password
     *
     * @param request  request (contains username and password)
     * @param response response
     * @return authentication manager
     * @throws AuthenticationException authentication exception
     */
    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            UsernameAndPasswordAuthenticationRequest authenticationRequest = new ObjectMapper()
                    .readValue(request.getInputStream(), UsernameAndPasswordAuthenticationRequest.class);
            Authentication authentication = new UsernamePasswordAuthenticationToken(
                    authenticationRequest.getUsername(),
                    authenticationRequest.getPassword()
            );
            return authenticationManager.authenticate(authentication);
        } catch (IOException e) {
            log.error("Error getting authentication request from request: " + e.getMessage());
            throw new AuthenticationCredentialsNotFoundException(e.getMessage());
        }
    }

    /**
     * Handles successful authentication - sends tokens to client
     *
     * @param request        request
     * @param response       response
     * @param chain          filter chain
     * @param authentication authentication
     * @throws IOException I/O exception
     */
    @Override
    protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authentication) throws IOException {
        UserEntity user = (UserEntity) authentication.getPrincipal();

        Algorithm algorithm = jwtUtils.getAlgorithm();

        String access_token = JWT.create()
                .withSubject(user.getUsername())
                .withExpiresAt(Date.from((LocalDateTime.now().plusMinutes(jwtUtils.getTokenExpirationAfterMinutes())).atZone(ZoneId.systemDefault()).toInstant()))
                .withIssuer(request.getRequestURL().toString())
                .withClaim(jwtUtils.getClaimAuthoritiesName(), user.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList()))
                .sign(algorithm);

        String refresh_token = JWT.create()
                .withSubject(user.getUsername())
                .withExpiresAt(Date.from((LocalDate.now().plusMonths(jwtUtils.getRefreshTokenExpirationAfterMonths())).atStartOfDay().atZone(ZoneId.systemDefault()).toInstant()))
                .withIssuer(request.getRequestURL().toString())
                .sign(algorithm);

        jwtUtils.writeTokensToResponse(response, access_token, refresh_token);
    }
}