Géstion des requete REST-API JAVA

Bonjour à tous,
Je ne comprends pas une réaction que mon rest a.
Avant que j’installe JWT tout fonctionnait correctement avec le client (front-end) de depuis, il ne veut rien savoir.
Pour les requetes qui ne nécessitent pas une autorisation tout ce passe bien mais dès que’il y a une requete de connexion nécessitent une authentification via JWT alors plus de réponse (error 403).
J’ai testé avec POSTMAN la même manipulation et bizarre tout c’est bien passé…

Mon client est une application Angular.

Merci d’avance pour vos futures réactions
Belle journée.
Voilà mon code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
@EnableWebSecurity
public class SecurityConfigurer extends WebSecurityConfigurerAdapter {
 
    @Autowired
    private MyUserDetailsservice myUserDetailsService;
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;
    @Autowired
    private JwtRequestFilter jwtRequestFilter;
 
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(myUserDetailsService).passwordEncoder(bCryptPasswordEncoder);
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .cors().and()
                .authorizeRequests().antMatchers("/personne/user").permitAll()
                .and()
                .authorizeRequests().antMatchers("/bien").permitAll()
                .and()
                .authorizeRequests().antMatchers("/province").permitAll()
                .and()
                .authorizeRequests().antMatchers("/ville").permitAll()
                .and()
                .authorizeRequests().antMatchers("/type_bien").permitAll()
                .anyRequest().authenticated()
                .and().sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS);
 
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
 
    @Override
    @Bean
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
 
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration corsConfiguration = new CorsConfiguration();
        corsConfiguration.setAllowCredentials(true);
        corsConfiguration.addAllowedOrigin("http://localhost:4200");
        corsConfiguration.addAllowedMethod("*");
        corsConfiguration.addAllowedHeader("*");
        corsConfiguration.addExposedHeader(constParam.JWT_NAME);
        corsConfiguration.applyPermitDefaultValues();
        return request -> corsConfiguration;
    }
 
 
    @Bean
    public PasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
@Service
public class JwtRequestFilter extends OncePerRequestFilter {
 
    @Autowired
    private MyUserDetailsservice userDetailsService;
    @Autowired
    private JwtUtil jwtUtil;
    @Autowired
    private ContactUserRepository contactUserRepository;
    private Personne client;
 
    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        final String authorizationHeader = request.getHeader(constParam.JWT_NAME);
 
        String username = null;
        String jwt = null;
 
        if (authorizationHeader != null && authorizationHeader.startsWith(constParam.HEADER_PREFIX)){
            jwt = authorizationHeader.substring(7);
            username = jwtUtil.extractUsername(jwt);
        }
 
        if (username != null && SecurityContextHolder.getContext().getAuthentication() == null){
            UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
            if (jwtUtil.validateToken(jwt, userDetails)){
                UsernamePasswordAuthenticationToken usernamePasswordAuthenticationToken = new UsernamePasswordAuthenticationToken(
                        userDetails, constParam.EXPIRATION, userDetails.getAuthorities());
                usernamePasswordAuthenticationToken
                        .setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(usernamePasswordAuthenticationToken);
 
                Optional<ContactUser> contactUser = contactUserRepository.findByEmail(username);
                this.client = contactUser.get().getAppartienA();
            }
        }
        filterChain.doFilter(request, response);
    }
 
 
    public Personne personneDetails() {
        return this.client;
    }
 
 
}