allfree-springboot-backend / src / main / java / com / allfree / allfreespringbackend / service / UserService.java
UserService.java
Raw
package com.allfree.allfreespringbackend.service;

import com.allfree.allfreespringbackend.auth.model.Role;
import com.allfree.allfreespringbackend.auth.repository.RoleRepository;
import com.allfree.allfreespringbackend.controlller.exception.ResourceNotFoundException;
import com.allfree.allfreespringbackend.repository.UserRepository;
import com.allfree.allfreespringbackend.user.User;
import com.allfree.allfreespringbackend.user.dto.NewUserDTO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RoleRepository roleRepository;
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Autowired
    public UserService() {
        this.userRepository = userRepository;
    }

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

    public User saveUser(User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userRepository.save(user);
    }

    public User saveUserFromDTO(NewUserDTO newUserResponse) throws Exception {
        var newUser = User.loadFromUserDTO(newUserResponse);
        Set<Role> newUserRole = newUserResponse.getRoles().stream()
                .map(role -> roleRepository.findByName(role.getName()))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(Collectors.toSet());
        newUser.setRoles(newUserRole);
        newUser.setPassword(passwordEncoder.encode(newUser.getPassword()));
        return userRepository.save(newUser);
    }

    public User getUserById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
    }

    public User getUserByEmail(String email) throws UsernameNotFoundException {
        return userRepository.findByEmail(email).orElseThrow(() -> new UsernameNotFoundException("User with email " + email + " not found"));
    }

    public User getUserByUsername(String username) throws UsernameNotFoundException {
        return userRepository.findByUsername(username).orElseThrow(() -> new UsernameNotFoundException("Username not found"));
    }

    public User updateUser(Long id, User userUpdated) {
        User userForUpdate = getUserById(id);
        Set<Role> updatedUserRole = userUpdated.getRoles().stream()
                .map(role -> roleRepository.findByName(role.getName()))
                .filter(Optional::isPresent)
                .map(Optional::get)
                .collect(Collectors.toSet());
        userForUpdate.setUserDetails(userUpdated.getFirstName(),
                userUpdated.getLastName(),
                userUpdated.getEmail(),
                userUpdated.getUsername(),
                userUpdated.getPassword(),
                updatedUserRole);
//        if(!userForUpdate.getRoles().stream().map(Role::getName).collect(Collectors.toList()).contains(userUpdatedRole.get(0))){
//            userForUpdate.getRoles().add(new Role(userUpdatedRole.get(0).toString()));
//        }
        return userRepository.save(userForUpdate);
    }

    public void deleteUser(User user) {
        userRepository.delete(user);
    }
}