5 - rank system

build.gradle

@@ -43,6 +43,8 @@ dependencies {
 
     //redis
     implementation ("org.springframework.boot:spring-boot-starter-data-redis")
+    implementation ("org.springframework.boot:spring-boot-starter-data-redis:2.3.1.RELEASE")
+
 
     // aws
     implementation("org.springframework.cloud:spring-cloud-starter-aws:2.2.6.RELEASE")

src/main/java/com/example/domaserver/domain/rank/config/RedisConfig.java

@@ -0,0 +1,23 @@
+package com.example.domaserver.domain.rank.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
+
+@EnableRedisRepositories
+@Configuration
+public class RedisConfig {
+    @Value("${spring.redis.host}")
+    private String redisHost;
+
+    @Value("${spring.redis.port}")
+    private int redisPort;
+
+    @Bean
+    public RedisConnectionFactory redisConnectionFactory() {
+        return new LettuceConnectionFactory(redisHost, redisPort);
+    }
+}

src/main/java/com/example/domaserver/domain/rank/entity/Rank.java

@@ -0,0 +1,31 @@
+package com.example.domaserver.domain.rank.entity;
+
+import com.example.domaserver.domain.user.entity.User;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Entity
+@Getter
+@Builder
+@NoArgsConstructor
+@AllArgsConstructor
+public class Rank {
+
+    @Id
+    @GeneratedValue(strategy =GenerationType.IDENTITY)
+    private Long RankId;
+    private int PenaltyPoints;
+    private double RankScore;
+
+    @ManyToOne
+    @JoinColumn(name = "user_id")
+    private User user;
+
+    public Rank(Long rankId, Double rankScore) {
+        RankId = rankId;
+        RankScore = rankScore;
+    }
+}

src/main/java/com/example/domaserver/domain/rank/presentation/RankController.java

@@ -0,0 +1,46 @@
+package com.example.domaserver.domain.rank.presentation;
+
+
+import com.example.domaserver.domain.rank.entity.Rank;
+import com.example.domaserver.domain.rank.service.RankService;
+import com.example.domaserver.domain.user.entity.User;
+import com.example.domaserver.domain.user.service.UserService;
+import com.example.domaserver.global.security.jwt.JwtService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/home")
+public class RankController {
+    private final RankService rankService;
+    private final UserService userService;
+    private final JwtService jwtService;
+
+    @Autowired
+    public RankController(RankService rankService, UserService userService, JwtService jwtService) {
+        this.rankService = rankService;
+        this.userService = userService;
+        this.jwtService = jwtService;
+    }
+
+    @GetMapping("/rank")
+    public ResponseEntity<List<Rank>> getRanks() {
+        List<Rank> topRanks = rankService.getTopRanking(25);
+        return ResponseEntity.ok(topRanks);
+    }
+
+    @GetMapping("/my-rank")
+    public ResponseEntity<Long> getMyRank(@RequestHeader("Authorization") String token) {
+        User user = jwtService.getUserFromToken(token.substring(7));
+        Long rank = rankService.getRanking(user);
+        return ResponseEntity.ok(rank);
+    }
+
+
+}

src/main/java/com/example/domaserver/domain/rank/presentation/dto/response/RankResponse.java

@@ -0,0 +1,16 @@
+package com.example.domaserver.domain.rank.presentation.dto.response;
+
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.UUID;
+
+@Builder
+@Getter
+public class RankResponse {
+    private UUID Id;
+    private String name;
+    private String profileImageUrl;
+    private int penaltyPoints;
+    private double RankScore;
+}

src/main/java/com/example/domaserver/domain/rank/service/RankService.java

@@ -0,0 +1,11 @@
+package com.example.domaserver.domain.rank.service;
+
+import com.example.domaserver.domain.rank.entity.Rank;
+import com.example.domaserver.domain.user.entity.User;
+import java.util.List;
+
+public interface RankService {
+    Long getRanking(User user);
+    void updateRank(Rank rank);
+    List<Rank> getTopRanking(int topN);
+}

src/main/java/com/example/domaserver/domain/rank/service/impl/RankServiceImpl.java

@@ -0,0 +1,52 @@
+package com.example.domaserver.domain.rank.service.impl;
+
+import com.example.domaserver.domain.rank.entity.Rank;
+import com.example.domaserver.domain.rank.service.RankService;
+import com.example.domaserver.domain.user.entity.User;
+import com.example.domaserver.global.annotation.ServiceWithTransaction;
+import jakarta.transaction.Transactional;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ZSetOperations;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+
+@ServiceWithTransaction
+public class RankServiceImpl implements RankService {
+
+    private static final String RANK_KEY = "USER_RANKING";
+
+    private final RedisTemplate redisTemplate;
+
+    public RankServiceImpl(@Qualifier("redisTemplate") RedisTemplate redisTemplate) {
+        this.redisTemplate = redisTemplate;
+    }
+
+    @Transactional
+    public Long getRanking(User user) {
+        Long rank = redisTemplate.opsForZSet().rank(RANK_KEY, user.getId());
+        return (rank != null) ? rank + 1 : null;
+    }
+
+    @Transactional
+    public void updateRank(Rank rank) {
+        redisTemplate.opsForZSet().add(RANK_KEY, rank.getUser().getId(), rank.getPenaltyPoints());
+    }
+
+    @Transactional
+    public List<Rank> getTopRanking(int topN) {
+        Set<ZSetOperations.TypedTuple<Long>> rankedUsers =
+                redisTemplate.opsForZSet().reverseRangeWithScores(RANK_KEY, 0, topN - 1);
+
+        List<Rank> userRanks = new ArrayList<>();
+        for (ZSetOperations.TypedTuple<Long> entry : rankedUsers) {
+            Long RankId = entry.getValue();
+            Double RankScore = entry.getScore();
+            userRanks.add(new Rank(RankId, RankScore));
+        }
+        return userRanks;
+    }
+
+}

src/main/java/com/example/domaserver/domain/user/entity/User.java

@@ -14,10 +14,9 @@ public class User {
     @Id
     @GeneratedValue(generator = "UUID4")
     private UUID id;
-
     private String name;
-
     private String email;
+    private int penaltyPoint;
 
     @Embedded
     private StudentNum studentNum;

src/main/java/com/example/domaserver/domain/user/repository/UserRepository.java

@@ -8,4 +8,5 @@
 
 public interface UserRepository extends JpaRepository<User, UUID> {
     Optional<User> findByEmail(String email);
+    Optional<User> findByUsername(String Username);
 }

src/main/java/com/example/domaserver/domain/user/service/UserService.java

@@ -0,0 +1,10 @@
+package com.example.domaserver.domain.user.service;
+
+import com.example.domaserver.domain.user.entity.User;
+
+import java.util.UUID;
+
+public interface UserService {
+    User findByUsername(String name);
+    User findById(UUID id);
+}

src/main/java/com/example/domaserver/domain/user/service/impl/UserServiceImpl.java

@@ -0,0 +1,34 @@
+package com.example.domaserver.domain.user.service.impl;
+
+import com.example.domaserver.domain.user.entity.User;
+import com.example.domaserver.domain.user.repository.UserRepository;
+import com.example.domaserver.domain.user.service.UserService;
+import com.example.domaserver.global.annotation.ServiceWithTransaction;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+
+import java.util.UUID;
+
+@ServiceWithTransaction
+public class UserServiceImpl implements UserService {
+
+    private final UserRepository userRepository;
+
+    @Autowired
+    public UserServiceImpl(UserRepository userRepository) {
+        this.userRepository = userRepository;
+    }
+
+    @Override
+    public User findByUsername(String username) {
+        return userRepository.findByUsername(username)
+                .orElseThrow(() -> new UsernameNotFoundException("User not found with username: " + username));
+    }
+
+    @Override
+    public User findById(UUID id) {
+        return userRepository.findById(id)
+                .orElseThrow(() -> new UsernameNotFoundException("User not found with id: " + id));
+    }
+
+}

src/main/java/com/example/domaserver/global/security/jwt/JwtService.java

@@ -0,0 +1,62 @@
+package com.example.domaserver.global.security.jwt;
+
+
+import com.example.domaserver.domain.user.entity.User;
+import com.example.domaserver.domain.user.service.UserService;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.stereotype.Service;
+import org.springframework.beans.factory.annotation.Value;
+
+import java.util.Date;
+import java.util.function.Function;
+
+@Service
+@Slf4j
+public class JwtService {
+
+    private final UserService userService;
+
+    @Value("${jwt.secret}")
+    private String secretKey;
+
+    public JwtService(UserService userService) {
+        this.userService = userService;
+    }
+
+    public String extractUsername(String token) {
+        return extractClaim(token, Claims::getSubject);
+    }
+
+    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
+        final Claims claims = extractAllClaims(token);
+        return claimsResolver.apply(claims);
+    }
+
+    private Claims extractAllClaims(String token) {
+        return Jwts.parser()
+                .setSigningKey(secretKey)
+                .parseClaimsJws(token)
+                .getBody();
+    }
+
+    public boolean isTokenValid(String token, UserDetails userDetails) {
+        final String username = extractUsername(token);
+        return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
+    }
+
+    private boolean isTokenExpired(String token) {
+        return extractExpiration(token).before(new Date());
+    }
+
+    public Date extractExpiration(String token) {
+        return extractClaim(token, Claims::getExpiration);
+    }
+
+    public User getUserFromToken(String token) {
+        String username = extractUsername(token);
+        return userService.findByUsername(username);
+    }
+}

src/main/resources/application.yml

@@ -1,4 +1,8 @@
 server:
+  redis:
+    port: 6739
+    host: localhost
+
   port: 8090
   servlet:
     context-path: /
@@ -33,9 +37,9 @@ spring:
       port: ${REDIS_PORT}
 
 jwt:
-  secret: ${JWT_SECRET}
+  secret: "your_secret_key_here"
 
 gauth:
   clientId: ${GAUTH_CLIENT}
   clientSecret: ${GAUTH_SECRET}
-  redirectUri: ${GAUTH_REDIRECT_URI}
+  redirectUri: ${GAUTH_REDIRECT_URI}