UserService.java

package com.projet.projetIndu.services;

import com.projet.projetIndu.dto.UserRegistrationDTO;
import com.projet.projetIndu.entities.*;
import com.projet.projetIndu.repositories.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;


@Service
public class UserService implements UserDetailsService {
    private final UserRepository userRepository;
    private final BCryptPasswordEncoder passwordEncoder;

    @Autowired
    public UserService(UserRepository userRepository, BCryptPasswordEncoder passwordEncoder) {
        this.userRepository = userRepository;
        this.passwordEncoder = passwordEncoder;
    }

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public Optional<User> getUserByUsername(String email) {
        return userRepository.findByEmail(email);
    }

    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }

    public User saveUser(User user) {
        return userRepository.save(user);
    }

    public void deleteUserById(Long id) {
        userRepository.deleteById(id);
    }

    public User registerUser(UserRegistrationDTO userDTO) {
        if (userRepository.existsByEmail(userDTO.getEmail())) {
            throw new IllegalArgumentException("Email already taken");
        }

        String encodedPassword = passwordEncoder.encode(userDTO.getPassword());
        User user;

        Role role;
        try {
            role = Role.valueOf(String.valueOf(userDTO.getRole()));

            switch (role) {
                case DOCTOR -> {
                    Doctor doctor = new Doctor();
                    doctor.setSpeciality(userDTO.getSpeciality());
                    user = doctor;
                }
                case PATIENT -> {
                    Patient patient = new Patient();
                    patient.setDateOfBirth(userDTO.getDateOfBirth());
                    patient.setAddress(userDTO.getAddress());
                    user = patient;
                }
                case ADMIN -> {
                    user = new Admin();
                }
                default -> throw new IllegalArgumentException("Invalid role");
            }
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid role provided: " + userDTO.getRole());
        }

        user.setFirstName(userDTO.getFirstName());
        user.setLastName(userDTO.getLastName());
        user.setPhoneNumber(userDTO.getPhoneNumber());
        user.setEmail(userDTO.getEmail());
        user.setPassword(encodedPassword);
        user.setRole(role);


        return userRepository.save(user);
    }


    @Override
    public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
        User user = userRepository.findByEmail(email)
                .orElseThrow(() -> new UsernameNotFoundException("User not found"));

        return org.springframework.security.core.userdetails.User
                .withUsername(user.getEmail())
                .password(user.getPassword())
                .authorities(user.getClass().getSimpleName())
                .build();
    }

}