Merge pull request #92 from Move-Log/develop

[FEAT] 전체 사용자 기준 기록 통계 정보 조회 기능 구현

Author: EunbeenDev

src/main/java/com/movelog/MoveLogApplication.java

@@ -1,12 +1,16 @@
 package com.movelog;
 
+import com.movelog.domain.record.application.DataMigrationService;
 import com.movelog.global.config.YamlPropertySourceFactory;
+import jakarta.annotation.PostConstruct;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.cloud.openfeign.EnableFeignClients;
 import org.springframework.context.annotation.PropertySource;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 
+@Slf4j
 @SpringBootApplication
 @EnableJpaAuditing
 @EnableFeignClients
@@ -18,7 +22,22 @@
 @PropertySource(value = { "classpath:webclient/application-webclient.yml" }, factory = YamlPropertySourceFactory.class)
 @PropertySource(value = { "classpath:redis/application-redis.yml" }, factory = YamlPropertySourceFactory.class)
 public class MoveLogApplication {
+
+    private final DataMigrationService dataMigrationService;
+
+    // 생성자를 통한 의존성 주입
+    public MoveLogApplication(DataMigrationService dataMigrationService) {
+        this.dataMigrationService = dataMigrationService;
+    }
+
     public static void main(String[] args) {
         SpringApplication.run(MoveLogApplication.class, args);
     }
+
+    @PostConstruct
+    public void init() {
+        log.info("Redis data migration start!");
+        dataMigrationService.migrateDataToRedis();
+        log.info("Redis data migration complete!");
+    }
 }

src/main/java/com/movelog/domain/record/application/DataMigrationService.java

@@ -0,0 +1,50 @@
+package com.movelog.domain.record.application;
+
+
+import com.movelog.domain.record.domain.Record;
+import com.movelog.domain.record.domain.VerbType;
+import com.movelog.domain.record.domain.repository.RecordRepository;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+@Service
+@RequiredArgsConstructor
+public class DataMigrationService {
+
+    private final RecordRepository recordRepository; // 기존 DB 조회용
+    private final RedisTemplate<String, String> redisTemplate;
+
+    /**
+     * 기존 DB 데이터를 Redis로 마이그레이션
+     */
+    @Transactional
+    public void migrateDataToRedis() {
+        List<Record> records = recordRepository.findAllWithKeyword(); // 모든 데이터 한 번에 조회
+
+        for (Record record : records) {
+            if (record.getKeyword() == null) continue;
+
+            String action = record.getKeyword().getKeyword(); // 키워드 (명사)
+            LocalDate date = record.getActionTime().toLocalDate(); // 날짜
+            VerbType verbType = record.getKeyword().getVerbType(); // 동사 유형
+
+            if (verbType == null) continue; // Null 체크
+
+            // Redis 키 설정 (날짜별, 전체 통계)
+            String dailyKey = "stats:daily:" + verbType.getVerbType() + ":" + date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+            String totalKey = "stats:total:" + verbType.getVerbType();
+
+            // Redis에 데이터 저장
+            redisTemplate.opsForZSet().incrementScore(dailyKey, action, 1);
+            redisTemplate.opsForZSet().incrementScore(totalKey, action, 1);
+        }
+
+        System.out.println("✅ Redis 데이터 마이그레이션 완료!");
+    }
+}

src/main/java/com/movelog/domain/record/application/RecordService.java

@@ -18,14 +18,15 @@
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.ZSetOperations;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.web.multipart.MultipartFile;
 
 import java.text.Collator;
-import java.time.LocalDate;
-import java.time.LocalDateTime;
-import java.time.LocalTime;
+import java.time.*;
+import java.time.format.DateTimeFormatter;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -40,11 +41,19 @@ public class RecordService {
     private final KeywordRepository keywordRepository;
     private final S3Util s3Util;
     private final UserRepository userRepository;
+    private final RedisTemplate<String, String> redisTemplate;
+
+
+    private static final String DAILY_PREFIX = "stats:daily:";
+    private static final String WEEKLY_PREFIX = "stats:weekly:";
+    private static final String MONTHLY_PREFIX = "stats:monthly:";
+    private static final String TOTAL_PREFIX = "stats:total";
+
 
     @Transactional
     public void createRecord(UserPrincipal userPrincipal, CreateRecordReq createRecordReq, MultipartFile img) {
-        User user = validUserById(userPrincipal);
-        // User user = userRepository.findById(5L).orElseThrow(UserNotFoundException::new);
+        // User user = validUserById(userPrincipal);
+        User user = userRepository.findById(5L).orElseThrow(UserNotFoundException::new);
         validateCreateRecordReq(createRecordReq);
 
         String recordImgUrl;
@@ -201,6 +210,247 @@ public List<Recent5RecordImagesRes> retrieveCurrentRecordImages(UserPrincipal us
                 .toList();
     }
 
+    /**
+     * 전체 사용자 기록 통계 조회 (월별 조회 및 일간 조회 개선)
+     */
+    public AllUserRecordStatsRes getAllUserRecordStats(UserPrincipal userPrincipal, String category, String period, String month) {
+        validUserById(userPrincipal);
+        String redisKey = getRedisKey(period);
+
+        // 총 기록 횟수 조회
+        int totalRecords = getTotalRecords(redisKey, category);
+
+        // 최고 연속 기록 조회
+        int maxConsecutiveDays = getMaxConsecutiveDays(category);
+
+        // 평균 일간 기록 계산
+        double avgDailyRecord = calculateAvgDailyRecord(category);
+
+        // 하루 동안 가장 많이 기록한 횟수 조회
+        int maxDailyRecord = getMaxDailyRecord(redisKey, category);
+
+        // TOP 5 키워드 조회
+        List<Map<String, Object>> topRecords = getTopRecords(category);
+
+        // 날짜별 기록 개수 조회 (달력 표시용, 월별인지 확인 후 호출)
+        Map<LocalDate, Integer> dailyRecords = "monthly".equals(period) ?
+                getMonthlyRecords(category, month) :
+                getDailyRecords(category);
+
+        return AllUserRecordStatsRes.builder()
+                .category(category)
+                .totalRecords(totalRecords)
+                .maxConsecutiveDays(maxConsecutiveDays)
+                .avgDailyRecord(avgDailyRecord)
+                .maxDailyRecord(maxDailyRecord)
+                .topRecords(topRecords)
+                .dailyRecords(dailyRecords)
+                .build();
+    }
+
+
+    /**
+     * Redis Key 생성
+     */
+    private String getRedisKey(String period) {
+        String today = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        String week = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-ww"));
+        String month = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM"));
+
+        return switch (period) {
+            case "daily" -> DAILY_PREFIX + today;
+            case "weekly" -> WEEKLY_PREFIX + week;
+            case "monthly" -> MONTHLY_PREFIX + month;
+            default -> TOTAL_PREFIX;
+        };
+    }
+
+    /**
+     * 총 기록 횟수 조회 (Redis 조회 개선)
+     */
+    private int getTotalRecords(String redisKey, String category) {
+        Set<String> records = redisTemplate.opsForZSet().reverseRange(redisKey, 0, -1);
+
+        // Redis에서 데이터가 없을 경우 DB 데이터 기반으로 계산
+        if (records == null || records.isEmpty()) {
+            System.out.println("⚠️ Redis is empty for key: " + redisKey + " → Fetching from DB");
+
+            // DB에서 전체 기록 횟수 계산
+            List<Record> recordsFromDb = recordRepository.findAllWithKeyword();
+            return (int) recordsFromDb.stream()
+                    .filter(record -> record.getKeyword() != null && record.getKeyword().getVerbType().getVerbType().equals(category))
+                    .count();
+        }
+
+        return records.size();
+    }
+
+
+    /**
+     * 최대 연속 기록일 계산
+     */
+    private int getMaxConsecutiveDays(String category) {
+        VerbType verbType = VerbType.fromValue(category);
+        List<Record> records = recordRepository.findAllWithKeyword();
+
+        // `VerbType`에 맞는 데이터만 필터링하여 날짜만 추출
+        List<LocalDate> recordDates = records.stream()
+                .filter(record -> record.getKeyword() != null && record.getKeyword().getVerbType() == verbType)
+                .map(record -> record.getActionTime().toLocalDate())
+                .distinct() // 중복 제거
+                .sorted() // 날짜순 정렬
+                .collect(Collectors.toList());
+
+        if (recordDates.isEmpty()) return 0; // 기록이 없으면 0 반환
+
+        int maxStreak = 1;
+        int currentStreak = 1;
+
+        for (int i = 1; i < recordDates.size(); i++) {
+            if (recordDates.get(i).equals(recordDates.get(i - 1).plusDays(1))) {
+                currentStreak++;
+                maxStreak = Math.max(maxStreak, currentStreak);
+            } else {
+                currentStreak = 1;
+            }
+        }
+
+        return maxStreak;
+    }
+
+
+    /**
+     * 평균 일간 기록 계산 (DB 데이터 기반)
+     */
+    private double calculateAvgDailyRecord(String category) {
+        Map<LocalDate, Integer> dailyRecords = getDailyRecords(category); // 날짜별 기록 개수 조회
+
+        if (dailyRecords.isEmpty()) return 0.0; // 기록이 없으면 0 반환
+
+        int totalRecords = dailyRecords.values().stream().mapToInt(Integer::intValue).sum();
+        int totalDays = dailyRecords.size();
+
+        // 반올림
+        return Math.round((double) totalRecords / totalDays * 10) / 10.0;
+
+    }
+
+
+    /**
+     * 하루 동안 가장 많이 기록한 횟수 조회 (Redis + DB 조회)
+     */
+    private int getMaxDailyRecord(String redisKey, String category) {
+        Set<String> records = redisTemplate.opsForZSet().reverseRange(redisKey, 0, -1);
+
+        if (records == null || records.isEmpty()) {
+            System.out.println("⚠️ Redis is empty for key: " + redisKey + " → Fetching from DB");
+
+            // DB에서 날짜별 기록 개수 가져와서 최대값 찾기
+            Map<LocalDate, Integer> dailyRecords = getDailyRecords(category);
+            return dailyRecords.values().stream().max(Integer::compareTo).orElse(0);
+        }
+
+        return records.size();
+    }
+
+
+    /**
+     * TOP 5 키워드 조회 (모든 데이터 가져온 후 서비스 단에서 필터링)
+     */
+    private List<Map<String, Object>> getTopRecords(String category) {
+        // 한글 문자열을 VerbType Enum으로 변환
+        VerbType verbType = VerbType.fromValue(category);
+
+        // 모든 데이터 한 번에 조회
+        List<Record> records = recordRepository.findAllWithKeyword();
+        Map<String, Integer> keywordCounts = new HashMap<>();
+
+        for (Record record : records) {
+            if (record.getKeyword() != null && record.getKeyword().getVerbType() == verbType) {
+                String keyword = record.getKeyword().getKeyword();
+                keywordCounts.put(keyword, keywordCounts.getOrDefault(keyword, 0) + 1);
+            }
+        }
+
+        return keywordCounts.entrySet().stream()
+                .sorted((a, b) -> b.getValue().compareTo(a.getValue())) // 내림차순 정렬
+                .limit(5)
+                .map(entry -> {
+                    Map<String, Object> map = new HashMap<>();
+                    map.put("record", entry.getKey());
+                    map.put("count", entry.getValue());
+                    return map;
+                })
+                .collect(Collectors.toList());
+    }
+
+
+    /**
+     * 날짜별 기록 개수 조회 (평균 일간 기록 정보 조회를 위함)
+     */
+    private Map<LocalDate, Integer> getDailyRecords(String category) {
+        // 한글 문자열을 VerbType Enum으로 변환
+        VerbType verbType = VerbType.fromValue(category);
+
+        // 모든 데이터를 조회 후, 서비스 단에서 필터링
+        List<Record> records = recordRepository.findAllWithKeyword();
+        Map<LocalDate, Integer> dailyRecordCount = new HashMap<>();
+
+        // `VerbType`에 맞는 데이터만 필터링하여 날짜별 개수 카운트
+        for (Record record : records) {
+            if (record.getKeyword() != null && record.getKeyword().getVerbType() == verbType) {
+                LocalDate date = record.getActionTime().toLocalDate();
+                dailyRecordCount.put(date, dailyRecordCount.getOrDefault(date, 0) + 1);
+            }
+        }
+        return dailyRecordCount;
+    }
+
+    private Map<LocalDate, Integer> getMonthlyRecords(String category, String month) {
+        VerbType verbType = VerbType.fromValue(category);
+        Map<LocalDate, Integer> dailyRecordCount = new LinkedHashMap<>();
+
+        if (month == null || month.isBlank()) {
+            log.info("⚠️ Invalid month input: [{}]", month);
+            return dailyRecordCount;
+        }
+
+        // month 값 정리: 공백 제거 + 숫자와 '-'만 유지
+        month = month.trim().replaceAll("[^0-9-]", "");
+
+        // 🕒 월 시작일 & 종료일 설정
+        YearMonth yearMonth = YearMonth.parse(month, DateTimeFormatter.ofPattern("yyyy-MM"));
+        LocalDateTime startDate = yearMonth.atDay(1).atStartOfDay(); // ex) 2025-02-01 00:00:00
+        LocalDateTime endDate = yearMonth.atEndOfMonth().atTime(23, 59, 59); // ex) 2025-02-28 23:59:59
+
+        log.info("🔍 Fetching records for category: [{}] between [{}] and [{}]", category, startDate, endDate);
+
+        // 📌 DB에서 해당 월의 데이터만 필터링하여 조회
+        List<Record> records = recordRepository.findRecordsByMonth(verbType, startDate, endDate);
+        log.info("📊 Retrieved {} records from DB", records.size());
+
+        if (records.isEmpty()) {
+            log.info("⚠️ No records found for category: {}", category);
+            return dailyRecordCount;
+        }
+
+        // 📅 날짜별 개수 카운트 (타임존 변환 추가)
+        for (Record record : records) {
+            log.info("⏳ Raw ActionTime: {}", record.getActionTime());
+            ZonedDateTime zonedDateTime = record.getActionTime().atZone(ZoneId.of("UTC"))
+                    .withZoneSameInstant(ZoneId.of("Asia/Seoul"));
+            LocalDate date = zonedDateTime.toLocalDate();
+            log.info("📅 Converted LocalDate: {}", date);
+
+            dailyRecordCount.put(date, dailyRecordCount.getOrDefault(date, 0) + 1);
+        }
+
+        log.info("✅ Final Monthly Records: {}", dailyRecordCount);
+
+        return dailyRecordCount;
+    }
+
+
 
     private User validUserById(UserPrincipal userPrincipal) {
         Optional<User> userOptional = userService.findById(userPrincipal.getId());