no-copy/src/main/java/ru/soune/no_copy/service/AuthService.java

package ru.soune.no_copy.service;

import lombok.RequiredArgsConstructor;
import org.springframework.context.MessageSource;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import ru.soune.no_copy.dto.*;
import ru.soune.no_copy.entity.AuthToken;
import ru.soune.no_copy.entity.User;
import ru.soune.no_copy.exception.NotValidFieldException;
import ru.soune.no_copy.exception.NotValidationPasswordException;
import ru.soune.no_copy.exception.UserNotFoundException;
import ru.soune.no_copy.repository.AuthTokenRepository;
import ru.soune.no_copy.repository.UserRepository;

import java.security.SecureRandom;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.Base64;
import java.util.Map;
import java.util.Optional;

@Service
@RequiredArgsConstructor
public class AuthService {

    private final UserRepository userRepository;

    private final AuthTokenRepository authTokenRepository;

    private final PasswordEncoder passwordEncoder;

    private final MessageSource messageSource;

    private final SecureRandom secureRandom = new SecureRandom();

    @Transactional
    public AuthToken register(RegRequest registerRequest) {
        User user = new User();
        user.setFullName(registerRequest.getFullName());
        user.setEmail(registerRequest.getEmail());
        user.setPassword(passwordEncoder.encode(registerRequest.getPassword()));

        if (registerRequest.getCompanyName() != null) {
            user.setCompany(registerRequest.getCompanyName());
        }

        if (registerRequest.getPhone() != null) {
            user.setPhone(registerRequest.getPhone());
        }

        User savedUser = userRepository.save(user);

        AuthToken authToken = new AuthToken();
        authToken.setToken(generateAuthToken());
        authToken.setUser(savedUser);

        return authTokenRepository.save(authToken);
    }

    @Transactional
    public AuthToken login(LoginRequest request) {
        Optional<User> userOpt = userRepository.findByEmail(request.getEmail());
        User user = userOpt.get();

        if (!passwordEncoder.matches(request.getPassword(), user.getPassword())) {
            LoginAnswer loginAnswer = new LoginAnswer();
            loginAnswer.setFieldErrors(Arrays.asList(Map.of("password", request.getPassword())));

            throw new NotValidFieldException("Invalid password", new BaseResponse(20003,
                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getCode(),
                    MessageCode.AUTH_PASSWORD_NOT_MATCHES.getDescription(), loginAnswer));
        }

        user.setLastLoginAt(LocalDateTime.now());
        User savedUser = userRepository.save(user);

        AuthToken authToken = new AuthToken();
        authToken.setToken(generateAuthToken());
        authToken.setUser(savedUser);

        return authTokenRepository.save(authToken);
    }

    @Transactional
    public void logout(String token) {
        authTokenRepository.findByToken(token)
                .ifPresent(authTokenRepository::delete);
    }

    private String generateAuthToken() {
        byte[] bytes = new byte[32];
        secureRandom.nextBytes(bytes);
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }
}