Files
mtusi2026lab2/Lido/src/main/java/org/example/service/AuthService.java
T
2026-10-21 20:31:42 +03:00

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();
}
}