UserService.java

Go to the documentation of this file.

package com.student_loan.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.student_loan.model.User;
import com.student_loan.model.User.DegreeType;
import com.student_loan.dtos.CredentialsDTO;
import com.student_loan.repository.UserRepository;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import com.student_loan.security.JwtUtil;
 
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
 
@Service
@Transactional
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private NotificationService notificationService;
 
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;
 
    
    @Autowired
    private JwtUtil jwtUtil;
 
    private Map<String, User> tokens = new HashMap<>();
 
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
 
    public Optional<User> getUserById(Long id) {
        return userRepository.findById(id);
    }
 
    public User updateUser(Long id, User newData) {
        User existing = userRepository.findById(id)
            .orElseThrow(() -> new RuntimeException("User not found"));
 
        if (newData.getName() != null) {
            existing.setName(newData.getName());
        }
        if (newData.getEmail() != null) {
            existing.setEmail(newData.getEmail());
        }
        if (newData.getTelephoneNumber() != null) {
            existing.setTelephoneNumber(newData.getTelephoneNumber());
        }
        if (newData.getAddress() != null) {
            existing.setAddress(newData.getAddress());
        }
        if (newData.getDegreeType() != null) {
            existing.setDegreeType(newData.getDegreeType());
        }
        if (newData.getDegreeYear() != null) {
            existing.setDegreeYear(newData.getDegreeYear());
        }
        if (newData.getAverageRating() != null) {
            existing.setAverageRating(newData.getAverageRating());
        }
 
        String rawPass = newData.getPassword();
        if (rawPass != null && !rawPass.isBlank()) {
            existing.setPassword(passwordEncoder.encode(rawPass));
        }
 
        Integer previousPenalties = existing.getPenalties();
        Integer newPenalties      = newData.getPenalties();
        
        if (newPenalties != null) {
            if (newPenalties > previousPenalties) {
                notificationService.enviarCorreo(
                    existing.getEmail(),
                    "NEW PENALTY!",
                    "Your penalty count increased to " + newPenalties
                );
            }
            existing.setPenalties(newPenalties);
        } else {
            existing.setPenalties(previousPenalties);
        }
        existing.setAdmin(newData.getAdmin());
 
        return userRepository.save(existing);
    }
 
 
    public boolean register(User user) {
        if(userRepository.findByEmail(user.getEmail())!=null) {
            return false;
        }else {
            user.setPassword(passwordEncoder.encode(user.getPassword())); // Encrypts the password
            userRepository.save(user);
            return true;
        }
    }
 
    
    public String login(CredentialsDTO credentials) {
        User user = userRepository.findByEmail(credentials.getEmail());
        if (tokens.containsValue(user)) {
            return "User already logged in";
        } else if (user != null && passwordEncoder.matches(credentials.getPassword(), user.getPassword())) {
            String token = jwtUtil.generateToken(credentials.getEmail());
            tokens.put(token, user);
            return token;
        } else {
            return "Invalid credentials";
        }
    }
    
    public boolean logout(String token) {
        if(tokens.containsKey(token)) {
            tokens.remove(token);
            return true;
        }else{
            return false;}
    }
    
    public void deleteUser(Long id) {
        Optional<User> user = userRepository.findById(id);
        if (user.isPresent()) {
            userRepository.deleteById(id);
        } else {
            throw new RuntimeException("User not found");
        }
    }
    public User getUserByToken(String token) {
        return tokens.get(token);
    }
 
    public User getUserByEmail(String email) {
        return userRepository.findByEmail(email);
    }
}