@PostMapping("login")
    public ResponseEntity<?> login(@Valid @RequestBody AuthRequest authRequest, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            // Collect all errors into a list of strings
            List<String> errors = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + ": " + error.getRejectedValue())
                    .collect(Collectors.toList());
            throw new ValidationException(errors);
        }
        String jwt = jwtService.authentication(authRequest);
        return ResponseEntity.status(HttpStatus.OK)
                .header("Authorization", "Bearer " + jwt) // Add the token as a Bearer token
                .body("Login successful. JWT token added in the header." + jwt); }

@PostMapping("login")
    public ResponseEntity<?> login(@Valid @RequestBody AuthRequest authRequest, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            // Collect all errors into a list of strings
            List<String> errors = bindingResult.getFieldErrors().stream()
                    .map(error -> error.getField() + ": " + error.getRejectedValue())
                    .collect(Collectors.toList());
            throw new ValidationException(errors);
        }
        String jwt = jwtService.authentication(authRequest);
        return ResponseEntity.status(HttpStatus.OK)
                .header("Authorization", "Bearer " + jwt) // Add the token as a Bearer token
                .body("Login successful. JWT token added in the header." + jwt); }

const response = await axios.post("http://localhost:8080/api/auth/login" , data , {
    withCredentials: true, // Ensure credentials are included if required by the server
  });

  console.log(response.data);
  const token = response.headers["authorization"];
  if (token) {
    
    localStorage.setItem("jwtToken", token);
    
    alert("Successfully logged in!");
  } else {
    alert("Token not found in the response.");
  }

const response = await axios.post("http://localhost:8080/api/auth/login" , data , {
    withCredentials: true, // Ensure credentials are included if required by the server
  });

  console.log(response.data);
  const token = response.headers["authorization"];
  if (token) {
    
    localStorage.setItem("jwtToken", token);
    
    alert("Successfully logged in!");
  } else {
    alert("Token not found in the response.");
  }

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Autowired
    private JwtFilter jwtFilter;

    @Autowired
    private CustomAuthenticationFailureHandler customFailureHandler;

    @Bean
    SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf(csrf -> csrf.disable())
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) // Stateless
                                                                                                              // session
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers("/api/**").permitAll()
                        .anyRequest().authenticated())
                .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class) 
                .formLogin(formLogin -> formLogin
                        .loginPage("/login") // Custom login page
                        .defaultSuccessUrl("/hi", true) // Redirect after successful login
                        .failureHandler(customFailureHandler) // Set custom failure handler
                        // .failureUrl("/login?error=true") // Redirect after failed login
                        .permitAll()) // Allow all to access login endpoints
                .logout(logout -> logout
                        .logoutUrl("/logout") // Process logout requests
                        .logoutSuccessUrl("/login?logout=true") // Redirect after logout
                        .invalidateHttpSession(true) // Invalidate session on logout
                        .clearAuthentication(true)
                        .permitAll());
        return httpSecurity.build();
    }

@Configuration
@EnableWebSecurity
public class SecurityConfiguration {

    @Autowired
    private JwtFilter jwtFilter;

    @Autowired
    private CustomAuthenticationFailureHandler customFailureHandler;

    @Bean
    SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf(csrf -> csrf.disable())
                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)) // Stateless
                                                                                                              // session
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers("/api/**").permitAll()
                        .anyRequest().authenticated())
                .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class) 
                .formLogin(formLogin -> formLogin
                        .loginPage("/login") // Custom login page
                        .defaultSuccessUrl("/hi", true) // Redirect after successful login
                        .failureHandler(customFailureHandler) // Set custom failure handler
                        // .failureUrl("/login?error=true") // Redirect after failed login
                        .permitAll()) // Allow all to access login endpoints
                .logout(logout -> logout
                        .logoutUrl("/logout") // Process logout requests
                        .logoutSuccessUrl("/login?logout=true") // Redirect after logout
                        .invalidateHttpSession(true) // Invalidate session on logout
                        .clearAuthentication(true)
                        .permitAll());
        return httpSecurity.build();
    }

Error: Exceeded maxRedirects. Probably stuck in a redirect loop http://localhost:8080/login

Error: Exceeded maxRedirects. Probably stuck in a redirect loop http://localhost:8080/login

package com.demo.journalApp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.MongoTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@Configuration
@EnableAutoConfiguration
public class JournalApplication {

    public static void main(String[] args) {
        SpringApplication.run(JournalApplication.class, args);
    }

    @Bean
    PlatformTransactionManager add(MongoDatabaseFactory db) {
        return new MongoTransactionManager(db);
    }

}

package com.demo.journalApp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDatabaseFactory;
import org.springframework.data.mongodb.MongoTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement
@Configuration
@EnableAutoConfiguration
public class JournalApplication {

    public static void main(String[] args) {
        SpringApplication.run(JournalApplication.class, args);
    }

    @Bean
    PlatformTransactionManager add(MongoDatabaseFactory db) {
        return new MongoTransactionManager(db);
    }

}

@Override
    public Optional<BooksDetails> addBooks(BooksDetailsDto booksDetailsDto, Long roll_no) {

        Optional<StudentDetails> studentObj = detailsRepository.findById(roll_no);
        Optional<BooksDetails> existingBook = bookDetailsRepository.findByBookId(booksDetailsDto.getBookId());

        if (!studentObj.isPresent()) {
            throw new StudentNotFound("No Student Has been Founded with this roll_no");
        }

        if (existingBook.isPresent()) {
            throw new BookAlreadyExist("This Book is Already Present");
        }
        BooksDetails booksDetails = BookDetailsDtoMapper.toEntity(booksDetailsDto, studentObj.get(),
                apiService);
        BooksDetails savedBook = bookDetailsRepository.save(booksDetails);
        return Optional.of(savedBook);
    }

@Override
    public Optional<BooksDetails> addBooks(BooksDetailsDto booksDetailsDto, Long roll_no) {

        Optional<StudentDetails> studentObj = detailsRepository.findById(roll_no);
        Optional<BooksDetails> existingBook = bookDetailsRepository.findByBookId(booksDetailsDto.getBookId());

        if (!studentObj.isPresent()) {
            throw new StudentNotFound("No Student Has been Founded with this roll_no");
        }

        if (existingBook.isPresent()) {
            throw new BookAlreadyExist("This Book is Already Present");
        }
        BooksDetails booksDetails = BookDetailsDtoMapper.toEntity(booksDetailsDto, studentObj.get(),
                apiService);
        BooksDetails savedBook = bookDetailsRepository.save(booksDetails);
        return Optional.of(savedBook);
    }

@PostMapping("/addBook/{roll_no}")
    public ResponseEntity<?> addBooksToStudent(@RequestBody BooksDetailsDto booksDetailsDto,
            @PathVariable Long roll_no) {

        Optional<BooksDetails> studentBook = detailsService.addBooks(booksDetailsDto, roll_no);
        if (studentBook.isPresent()) {
            return ResponseEntity.ok(studentBook.get()); // Return the added book
        } else {
            return ResponseEntity.badRequest().build(); // Return a 400 Bad Request if the book could not be added
        }

    }

@PostMapping("/addBook/{roll_no}")
    public ResponseEntity<?> addBooksToStudent(@RequestBody BooksDetailsDto booksDetailsDto,
            @PathVariable Long roll_no) {

        Optional<BooksDetails> studentBook = detailsService.addBooks(booksDetailsDto, roll_no);
        if (studentBook.isPresent()) {
            return ResponseEntity.ok(studentBook.get()); // Return the added book
        } else {
            return ResponseEntity.badRequest().build(); // Return a 400 Bad Request if the book could not be added
        }

    }

package com.ShelfSpace.ShelfSpace.exception;

public class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException() {
        super();
    }

    public ResourceNotFoundException(String message) {
        super(message);
    }

    public ResourceNotFoundException(String message, Throwable throwable) {
        super(message, throwable);
    }
}

package com.ShelfSpace.ShelfSpace.exception;

public class ResourceNotFoundException extends RuntimeException {

    public ResourceNotFoundException() {
        super();
    }

    public ResourceNotFoundException(String message) {
        super(message);
    }

    public ResourceNotFoundException(String message, Throwable throwable) {
        super(message, throwable);
    }
}

@RestController
@RequestMapping("/api/Student")
@CrossOrigin(origins = "http://localhost:3000")
public class RestApplication {

    @Autowired
    private StudentDetailsService detailsService;
    @Autowired
    private BookDetailsRepository booksRepositrory;

    //// Get All The Students

    @GetMapping("/getAllStudents")
    public ResponseEntity<List<StudentDetails>> getAllStudents() {
        Iterable<StudentDetails> studentDetailsIt = detailsService.getAllStudent();
        List<StudentDetails> studentDetails = new ArrayList<StudentDetails>();
        studentDetailsIt.forEach(studentDetails::add);

        if (studentDetails.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(studentDetails, HttpStatus.OK);

    }

@RestController
@RequestMapping("/api/Student")
@CrossOrigin(origins = "http://localhost:3000")
public class RestApplication {

    @Autowired
    private StudentDetailsService detailsService;
    @Autowired
    private BookDetailsRepository booksRepositrory;

    //// Get All The Students

    @GetMapping("/getAllStudents")
    public ResponseEntity<List<StudentDetails>> getAllStudents() {
        Iterable<StudentDetails> studentDetailsIt = detailsService.getAllStudent();
        List<StudentDetails> studentDetails = new ArrayList<StudentDetails>();
        studentDetailsIt.forEach(studentDetails::add);

        if (studentDetails.isEmpty()) {
            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
        }
        return new ResponseEntity<>(studentDetails, HttpStatus.OK);

    }

SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf(csrf -> csrf.disable())
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers("/", "/signup", "/processRegister", "/Login", "/login", "/forgot-password/**",
                                "/css/emailVerification.css", "/css/newpassword.css", "css/home.css",
                                "/css/otpchecker.css", "/css/signup.css", "/css/login.css", "/css/resetpassword.css",
                                "/api/Student/**")

SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
        httpSecurity.csrf(csrf -> csrf.disable())
                .authorizeHttpRequests(auth -> auth
                        .requestMatchers("/", "/signup", "/processRegister", "/Login", "/login", "/forgot-password/**",
                                "/css/emailVerification.css", "/css/newpassword.css", "css/home.css",
                                "/css/otpchecker.css", "/css/signup.css", "/css/login.css", "/css/resetpassword.css",
                                "/api/Student/**")

if (forgotPassword.getOtpExpireDate().before(Date.from(Instant.now()))) {
            
            if (forgotPassword.getOtpExpireDate().before(Date.from(Instant.now()))) {
                
                 Long fId = forgotPassword.getForgotpasswordId();
                 System.out.println("The Password id is "+ fId);
                 
                emailService.deleteForgotPasswordById(fId);
                logger.warn("The Time is expired", forgotPassword.getOtpExpireDate());
                throw new OtpNotFoundExcpetion("Otp Expired");
            }
        }

if (forgotPassword.getOtpExpireDate().before(Date.from(Instant.now()))) {
            
            if (forgotPassword.getOtpExpireDate().before(Date.from(Instant.now()))) {
                
                 Long fId = forgotPassword.getForgotpasswordId();
                 System.out.println("The Password id is "+ fId);
                 
                emailService.deleteForgotPasswordById(fId);
                logger.warn("The Time is expired", forgotPassword.getOtpExpireDate());
                throw new OtpNotFoundExcpetion("Otp Expired");
            }
        }

Failed messages: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: smtp.gmail.com , 587; timeout -1;
  nested exception is:
    java.net.UnknownHostException: smtp.gmail.com ; message exceptions (1) are:
Failed message 1: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: smtp.gmail.com , 587; timeout -1;
  nested exception is:
    java.net.UnknownHostException: smtp.gmail.com ] with root cause

java.net.UnknownHostException: smtp.gmail.com 
    at java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:572) ~

Failed messages: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: smtp.gmail.com , 587; timeout -1;
  nested exception is:
    java.net.UnknownHostException: smtp.gmail.com ; message exceptions (1) are:
Failed message 1: org.eclipse.angus.mail.util.MailConnectException: Couldn't connect to host, port: smtp.gmail.com , 587; timeout -1;
  nested exception is:
    java.net.UnknownHostException: smtp.gmail.com ] with root cause

java.net.UnknownHostException: smtp.gmail.com 
    at java.base/sun.nio.ch.NioSocketImpl.connect(NioSocketImpl.java:572) ~

@Component
public class CustomAuthenticationHandler implements AuthenticationFailureHandler {

    @Autowired
    private UserRepository userRepository;
    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(CustomAuthenticationHandler.class);

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException exception) throws IOException, ServletException {

        logger.info("CustomAuthenticationFailureHandler invoked");

        if (exception instanceof BadCredentialsException) {

            String email = request.getParameter("username");
            boolean emailExists = checkEmail(email);

            if (!emailExists) {
                logger.warn(" User not registered with email : {}", email);
                response.sendRedirect("/login?error=email");
            } else {
                logger.warn(" Incorrect password for email: {}", email);
                response.sendRedirect("/login?error=password");
            }
        } else {
            logger.error("Authentication failed due to: {}", exception.getMessage());
            response.sendRedirect("/login?error");
        }
    }

    private boolean checkEmail(String email) {
        Optional<User> user = userRepository.findByEmail(email);
        return user.isPresent();
    }

}

@Component
public class CustomAuthenticationHandler implements AuthenticationFailureHandler {

    @Autowired
    private UserRepository userRepository;
    private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(CustomAuthenticationHandler.class);

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
            AuthenticationException exception) throws IOException, ServletException {

        logger.info("CustomAuthenticationFailureHandler invoked");

        if (exception instanceof BadCredentialsException) {

            String email = request.getParameter("username");
            boolean emailExists = checkEmail(email);

            if (!emailExists) {
                logger.warn(" User not registered with email : {}", email);
                response.sendRedirect("/login?error=email");
            } else {
                logger.warn(" Incorrect password for email: {}", email);
                response.sendRedirect("/login?error=password");
            }
        } else {
            logger.error("Authentication failed due to: {}", exception.getMessage());
            response.sendRedirect("/login?error");
        }
    }

    private boolean checkEmail(String email) {
        Optional<User> user = userRepository.findByEmail(email);
        return user.isPresent();
    }

}

Error starting ApplicationContext. To display the condition evaluation report re-run your application with 'debug' enabled.
2024-07-03T11:11:21.350+05:30 ERROR 11748 --- [  restartedMain] o.s.boot.SpringApplication               : Application run failed

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'securityConfiguration': Requested bean is currently in creation: Is there an unresolvable circular reference?
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:355) ~[spring-beans-6.1.10.jar:6.1.10]
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:227) ~[spring-beans-6.1.10.jar:6.1.10]
    

Error starting ApplicationContext. To display the condition evaluation report re-run your application with 'debug' enabled.
2024-07-03T11:11:21.350+05:30 ERROR 11748 --- [  restartedMain] o.s.boot.SpringApplication               : Application run failed

org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'securityConfiguration': Requested bean is currently in creation: Is there an unresolvable circular reference?
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:355) ~[spring-beans-6.1.10.jar:6.1.10]
    at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:227) ~[spring-beans-6.1.10.jar:6.1.10]
    

package com.ShelfSpace.ShelfSpace.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import com.ShelfSpace.ShelfSpace.UserDao.UserInfoDao;
import com.ShelfSpace.ShelfSpace.model.UserEntity;
import com.ShelfSpace.ShelfSpace.model.UserRoleEntity;
import com.ShelfSpace.ShelfSpace.repository.RoleRepository;
import com.ShelfSpace.ShelfSpace.repository.UserRepository;

import jakarta.transaction.Transactional;

public class UserService implements UserInfoDao{

    private UserRepository userRepository;
    private RoleRepository roleRepository;
    
    public UserService(UserRepository userRepository ,  RoleRepository roleRepository) {
        this.userRepository = userRepository;
        this.roleRepository = roleRepository;
    }
    
    @Transactional
    @Override
    public UserEntity addUser(UserEntity user) {
        if (user.getRoles() == null || user.getRoles().isEmpty()) {
            
        }
        userRepository.save(user);
        return null;
    }
    
}

package com.ShelfSpace.ShelfSpace.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import com.ShelfSpace.ShelfSpace.UserDao.UserInfoDao;
import com.ShelfSpace.ShelfSpace.model.UserEntity;
import com.ShelfSpace.ShelfSpace.model.UserRoleEntity;
import com.ShelfSpace.ShelfSpace.repository.RoleRepository;
import com.ShelfSpace.ShelfSpace.repository.UserRepository;

import jakarta.transaction.Transactional;

public class UserService implements UserInfoDao{

    private UserRepository userRepository;
    private RoleRepository roleRepository;
    
    public UserService(UserRepository userRepository ,  RoleRepository roleRepository) {
        this.userRepository = userRepository;
        this.roleRepository = roleRepository;
    }
    
    @Transactional
    @Override
    public UserEntity addUser(UserEntity user) {
        if (user.getRoles() == null || user.getRoles().isEmpty()) {
            
        }
        userRepository.save(user);
        return null;
    }
    
}

package com.ShelfSpace.ShelfSpace.model;

import java.util.List;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinTable;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.JoinColumn;

@Entity
@Table(name = "registered_user")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserEntity {

    
    @Column(name = "name", nullable = false)
    private String name;
    
    @Id
    @Column(name = "email", nullable = false, unique = true)
    private String email;
    
    
    @Column(name = "password", nullable = false)
    private String password;

    @ManyToMany
     @JoinTable(
                name = "user_info_user_roles",
                joinColumns = @JoinColumn(name = "user_info_email", referencedColumnName = "email"),
                inverseJoinColumns = @JoinColumn(name = "user_roles_id")
            )
    private List<UserRoleEntity> roles;

}

package com.ShelfSpace.ShelfSpace.model;

import java.util.List;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.JoinTable;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import jakarta.persistence.JoinColumn;

@Entity
@Table(name = "registered_user")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class UserEntity {

    
    @Column(name = "name", nullable = false)
    private String name;
    
    @Id
    @Column(name = "email", nullable = false, unique = true)
    private String email;
    
    
    @Column(name = "password", nullable = false)
    private String password;

    @ManyToMany
     @JoinTable(
                name = "user_info_user_roles",
                joinColumns = @JoinColumn(name = "user_info_email", referencedColumnName = "email"),
                inverseJoinColumns = @JoinColumn(name = "user_roles_id")
            )
    private List<UserRoleEntity> roles;

}

package com.ShelfSpace.ShelfSpace.model;

import java.util.List;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "user_roles")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserRoleEntity {

    @Id
    @Column(name = "role_id")
    private int roleId;
    
     @Column(name = "role_name", nullable = false, unique = true)
    private String roleName;

     @ManyToMany(mappedBy = "roles")
    private List<UserEntity> registeredUser;
}

package com.ShelfSpace.ShelfSpace.model;

import java.util.List;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Entity
@Table(name = "user_roles")
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserRoleEntity {

    @Id
    @Column(name = "role_id")
    private int roleId;
    
     @Column(name = "role_name", nullable = false, unique = true)
    private String roleName;

     @ManyToMany(mappedBy = "roles")
    private List<UserEntity> registeredUser;
}