148 lines
5.2 KiB
Java
148 lines
5.2 KiB
Java
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<String, Object> 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<User> resolveUserByBearer(String rawToken) {
|
|
String hash = TokenHasher.sha256(rawToken);
|
|
|
|
Optional<UUID> 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<SessionInfoResponse> 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();
|
|
}
|
|
}
|