package org.example.service; import org.example.config.TokenHasher; import org.example.dto.response.SessionInfoResponse; import org.example.dto.response.SessionResponse; import org.example.dto.response.UserResponse; import org.example.exception.UnauthorizedException; import org.example.model.Session; import org.example.model.User; import org.example.repository.SessionRepository; import org.example.repository.UserRepository; import org.springframework.beans.factory.annotation.Value; import org.springframework.security.crypto.password.PasswordEncoder; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import java.time.Instant; import java.util.List; import java.util.Optional; import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; @Service public class AuthService { private final UserRepository userRepository; private final SessionRepository sessionRepository; private final PasswordEncoder passwordEncoder; private final UserService userService; private final CacheService cacheService; private final ConcurrentHashMap locks = new ConcurrentHashMap<>(); @Value("${app.session-ttl-seconds:604800}") private long sessionTtlSeconds; public AuthService( UserRepository userRepository, SessionRepository sessionRepository, PasswordEncoder passwordEncoder, UserService userService, CacheService cacheService ) { this.userRepository = userRepository; this.sessionRepository = sessionRepository; this.passwordEncoder = passwordEncoder; this.userService = userService; this.cacheService = cacheService; } @Transactional public SessionResponse login(String username, String rawPassword) { User user = userRepository.findByUsername(username) .orElseThrow(() -> new UnauthorizedException("Unauthorized")); if (user.getPassword() == null || !passwordEncoder.matches(rawPassword, user.getPassword())) { throw new UnauthorizedException("Unauthorized"); } String rawToken = TokenHasher.newRawToken(); Instant expiresAt = Instant.now().plusSeconds(sessionTtlSeconds); Session session = Session.builder() .userId(user.getId()) .token(TokenHasher.sha256(rawToken)) .expiresAt(expiresAt) .createdAt(Instant.now()) .build(); sessionRepository.save(session); cacheService.put(session.getToken(), user.getId(), expiresAt); return SessionResponse.builder() .token(rawToken) .tokenType("Bearer") .expiresAt(expiresAt) .user(UserResponse.builder() .id(user.getId()) .username(user.getUsername()) .displayName(user.getDisplayName()) .createdAt(user.getCreatedAt()) .build()) .build(); } @Transactional public void logout(String rawToken){ if (rawToken == null || rawToken.isBlank()){ return; } sessionRepository.findByToken(TokenHasher.sha256(rawToken)) .ifPresent(s -> { s.setRevokedAt(Instant.now()); sessionRepository.save(s); }); } @Transactional public void logoutCurrent(String rawToken) { String tokenHash = TokenHasher.sha256(rawToken); var session = sessionRepository .findByToken(tokenHash) .filter(s -> s.isActive(Instant.now())) .orElseThrow(() -> new UnauthorizedException("Unauthorized")); session.setRevokedAt(Instant.now()); sessionRepository.save(session); cacheService.deleteSession(tokenHash); } public Optional resolveUserByBearer(String rawToken) { String hash = TokenHasher.sha256(rawToken); Optional cached = cacheService.get(hash); if (cached.isPresent()) { return userRepository.findById(cached.get()); } Object lock = locks.computeIfAbsent(hash, h -> new Object()); try { synchronized (lock) { cached = cacheService.get(hash); if (cached.isPresent()) { return userRepository.findById(cached.get()); } return resolveUserByBearer(hash); } } finally { locks.remove(hash, lock); } } @Transactional(readOnly = true) public List listSessionsForCurrentUser() { User user = userService.getCurrentUser(); Instant now = Instant.now(); return sessionRepository.findByUserIdOrderByCreatedAtDesc(user.getId()) .stream() .map(s -> SessionInfoResponse.builder() .id(s.getId()) .createdAt(s.getCreatedAt()) .expiresAt(s.getExpiresAt()) .revokedAt(s.getRevokedAt()) .active(s.isActive(now)) .build()) .toList(); } }