develop → main

src/main/java/com/recordmanagement/habitlog/domain/auth/application/service/AuthApplicationService.java

@@ -88,19 +88,20 @@ public AuthApplicationService(SocialLoginService socialLoginService,
     public SocialLoginResult socialLogin(SocialLoginCommand command) {
         SocialUserInfo socialUserInfo = socialLoginService.getUserInfo(command.getSocialType(), command.getAccessToken());
 
-        // socialId로 기존 사용자 조회 (단순하고 안정적)
-        Optional<UserResponse> existingUser = userRegistrationService.findBySocialLogin(command.getSocialType(), socialUserInfo.getSocialId());
+        // 1. 탈퇴한 사용자 복구 시도 (7일 이내면 자동 복구)
+        Optional<UserResponse> restoredUser = userLifecycleService.restoreWithdrawnUser(
+                command.getSocialType(),
+                socialUserInfo.getSocialId()
+        );
 
         UserResponse user;
         boolean isNewUser = false;
 
-        if (existingUser.isPresent()) {
-            user = existingUser.get();
-
-            // 탈퇴 사용자 복구는 UserLifecycleService에서 처리됨 (이미 위에서 처리됨)
-            log.info("기존 사용자 로그인: userId={}, socialType={}", user.getId(), command.getSocialType());
+        if (restoredUser.isPresent()) {
+            user = restoredUser.get();
+            log.info("사용자 로그인 (탈퇴 복구 포함): userId={}, socialType={}", user.getId(), command.getSocialType());
         } else {
-            // 신규 사용자 가입
+            // 2. 복구할 사용자가 없으면 신규 가입
             user = createNewUser(socialUserInfo, command.getSocialType());
             isNewUser = true;
             log.info("신규 사용자 가입: userId={}, socialType={}", user.getId(), command.getSocialType());

src/main/java/com/recordmanagement/habitlog/domain/calendar/presentation/controller/CalendarController.java

@@ -35,54 +35,75 @@ public CalendarController(RecordApplicationService recordApplicationService) {
 
     @Operation(summary = "캘린더 조회", description = """
             월별 기록 현황을 조회합니다. 타입별 필터링이 가능합니다.
-            
+
             ### 캘린더 표시 로직 (v1.8.6) - 프론트 분기처리 최적화
-            
+
             **과거 날짜**: 작성된 기록만 표시, 미작성은 빈 배열
             - 작성된 기록: `records: [실제기록객체]` → 색상 아이콘
             - 미작성 기록: `records: []` → 프론트에서 `length === 0 && 과거날짜`로 회색 아이콘 처리
             - 장점: 플레이스홀더 객체 없어서 타입 분기처리 불필요
-            
+
             **현재 날짜 (오늘)**: 작성된 기록만 표시, 미작성은 빈 배열
             - 작성된 기록: `records: [실제기록객체]` → 색상/회색 아이콘
             - 미작성 기록: `records: []` → 프론트에서 `length === 0 && 현재날짜`로 빈 공간 처리
             - 습관: 3단계 시스템 (미작성=빈공간, 작성=isCompleted:false, 완료=isCompleted:true)
             - 홈 화면: `records.length >= 2`로 간단한 작성 제한 체크
-            
+
             **미래 날짜**: 완전 빈 배열
             - `records: []` → 프론트에서 `length === 0 && 미래날짜`로 빈 공간 처리
             - DB에 미래 자동생성 기록이 있어도 API 응답에서 제외
-            
+
             ### 메인 기록 타입 표시 (v1.9.0)
             - 각 날짜에 `mainRecordTypeForDate` 필드가 추가되어 해당 날짜의 메인 기록 타입을 표시합니다
             - **목표 기간 내**: 해당 목표의 메인 기록 타입 반환 (HABIT/EXERCISE/DAILY)
             - **목표 미설정 기간**: `null` 반환 (목표가 설정되지 않은 기간)
             - 클라이언트는 이 값을 기준으로 캘린더 아이콘을 결정할 수 있습니다
-            
+
             ### 습관 기록 특별 처리 (v1.9.1)
             - **메인 습관 자동 생성**: 메인 습관 기록 생성 시 목표 종료일까지 DB에 자동 생성
             - **오늘까지만 응답**: DB의 미래 기록은 API에서 제외 (실제 행동 기반)
             - **메인 습관 표시 로직** (mainRecordTypeForDate = HABIT인 경우):
               * 미작성 (자동생성 그대로): records 빈 배열
-              * 작성 (사용자 수정): isCompleted=false로 표시  
+              * 작성 (사용자 수정): isCompleted=false로 표시
               * 완료: isCompleted=true로 표시
             - **다른 타입 사용자**: 모든 습관 기록 표시 (서브 기록으로)
-            
+
             ### isCompleted 필드 상태
             - **습관 기록**: 실제 완료 체크 여부 (true=완료, false=미완료, null=미작성)
             - **일상/운동 기록**: 기록 존재 자체가 완료 (항상 true)
-            
+
             ### 사용자 타입별 특징
             **습관 타입 사용자 (HABIT)**:
             - 과거: 모든 습관 기록 + 미작성 회색 표시
             - 현재: 작성된 습관만 표시 (3단계: 빈공간→회색→색상)
             - 미래: 표시하지 않음
-            
+
             **운동/일상 타입 사용자 (EXERCISE/DAILY)**:
-            - 과거: 모든 기록 + 미작성 회색 표시  
+            - 과거: 모든 기록 + 미작성 회색 표시
             - 현재: 작성된 기록만 표시
             - 미래: 표시하지 않음
             - 메인 기록 + 서브 습관 기록 조합 가능
+
+            ### 일정 표시 로직 (v1.5.1)
+
+            **일정 요약 정보** (schedules 필드):
+            - **title**: 대표 일정명 (첫 번째 일정)
+            - **extraScheduleCount**: 추가 일정 개수 (표시되지 않은 일정 수)
+              * 일정 1개: `null` ("+N" 표시 안 함)
+              * 일정 2개: `1` ("+1" 표시)
+              * 일정 3개: `2` ("+2" 표시)
+            - **color**: 대표 일정 색상
+
+            **반복 일정 표시**:
+            - **NONE**: 반복 없음 (startDate ~ endDate 범위만 표시)
+            - **DAY**: 매일 반복 (startDate부터 매일 표시)
+            - **WEEK**: 매주 반복 (startDate와 같은 요일에만 표시)
+            - **MONTH**: 매월 반복 (startDate와 같은 날짜에만 표시, 31일 일정은 30일까지 있는 달 자동 스킵)
+            - **YEAR**: 매년 반복 (startDate와 같은 월-일에만 표시, 2월 29일 일정은 평년 자동 스킵)
+
+            **반복 종료일** (repeatEndsOn):
+            - 설정 시: 해당 날짜까지만 반복 (이후 캘린더에서 제외)
+            - 미설정 시: 계속 반복
             """,
             security = @SecurityRequirement(name = "bearerAuth"))
     @io.swagger.v3.oas.annotations.responses.ApiResponse(
@@ -112,12 +133,18 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "HABIT",
                                             "isCompleted": true
                                         }
-                                    ]
+                                    ],
+                                    "schedules": {
+                                        "title": "회의",
+                                        "extraScheduleCount": 2,
+                                        "color": "BLUE"
+                                    }
                                 },
                                 {
                                     "date": "2025-11-18",
                                     "mainRecordTypeForDate": "HABIT",
-                                    "records": []
+                                    "records": [],
+                                    "schedules": null
                                 },
                                 {
                                     "date": "2025-11-19",
@@ -128,12 +155,18 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "HABIT",
                                             "isCompleted": false
                                         }
-                                    ]
+                                    ],
+                                    "schedules": {
+                                        "title": "점심 약속",
+                                        "extraScheduleCount": null,
+                                        "color": "PINK"
+                                    }
                                 },
                                 {
                                     "date": "2025-11-20",
                                     "mainRecordTypeForDate": "HABIT",
-                                    "records": []
+                                    "records": [],
+                                    "schedules": null
                                 }
                             ]
                         }
@@ -166,12 +199,18 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "HABIT",
                                             "isCompleted": true
                                         }
-                                    ]
+                                    ],
+                                    "schedules": null
                                 },
                                 {
                                     "date": "2025-11-18",
                                     "mainRecordTypeForDate": "EXERCISE",
-                                    "records": []
+                                    "records": [],
+                                    "schedules": {
+                                        "title": "병원 예약",
+                                        "extraScheduleCount": 1,
+                                        "color": "GREEN"
+                                    }
                                 },
                                 {
                                     "date": "2025-11-19",
@@ -182,12 +221,14 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "HABIT",
                                             "isCompleted": false
                                         }
-                                    ]
+                                    ],
+                                    "schedules": null
                                 },
                                 {
                                     "date": "2025-11-20",
                                     "mainRecordTypeForDate": "EXERCISE",
-                                    "records": []
+                                    "records": [],
+                                    "schedules": null
                                 }
                             ]
                         }
@@ -215,12 +256,18 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "DAILY",
                                             "isCompleted": true
                                         }
-                                    ]
+                                    ],
+                                    "schedules": null
                                 },
                                 {
                                     "date": "2025-10-23",
                                     "mainRecordTypeForDate": null,
-                                    "records": []
+                                    "records": [],
+                                    "schedules": {
+                                        "title": "여행",
+                                        "extraScheduleCount": 4,
+                                        "color": "ORANGE"
+                                    }
                                 },
                                 {
                                     "date": "2025-11-08",
@@ -231,7 +278,8 @@ public CalendarController(RecordApplicationService recordApplicationService) {
                                             "type": "HABIT",
                                             "isCompleted": false
                                         }
-                                    ]
+                                    ],
+                                    "schedules": null
                                 }
                             ]
                         }

src/main/java/com/recordmanagement/habitlog/domain/exercise/application/service/ExerciseRecordApplicationService.java

@@ -5,6 +5,7 @@
 import com.recordmanagement.habitlog.global.config.exception.ErrorCode;
 import com.recordmanagement.habitlog.domain.exercise.domain.model.ExerciseRecord;
 import com.recordmanagement.habitlog.domain.exercise.domain.model.ExerciseRecordId;
+import com.recordmanagement.habitlog.domain.exercise.domain.repository.ExerciseRecordQueryRepository;
 import com.recordmanagement.habitlog.domain.exercise.domain.repository.ExerciseRecordRepository;
 import com.recordmanagement.habitlog.domain.record.domain.repository.RecordRepository;
 import com.recordmanagement.habitlog.domain.habit.domain.repository.HabitRecordRepository;
@@ -21,15 +22,19 @@
 
 import java.time.LocalDate;
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Slf4j
 @Service
 @RequiredArgsConstructor
 @Transactional
 public class ExerciseRecordApplicationService {
-
+
+    // 비즈니스 상수
+    private static final int MAX_DAILY_RECORDS = 2;
+    private static final int MAX_RECORD_TYPES_PER_DAY = 2;
+
     private final ExerciseRecordRepository exerciseRecordRepository;
+    private final ExerciseRecordQueryRepository exerciseRecordQueryRepository;
     private final RecordRepository recordRepository;
     private final HabitRecordRepository habitRecordRepository;
     private final S3FileService s3FileService;
@@ -38,20 +43,22 @@ public class ExerciseRecordApplicationService {
 
     @CacheEvict(value = "calendar", allEntries = true)
     public ExerciseRecordResponse createExerciseRecord(CreateExerciseRecordCommand command) {
-        log.info("운동기록 생성 시작: userId=[{}], exerciseType=[{}], recordDate=[{}]", 
+        log.info("운동기록 생성 시작: userId=[{}], exerciseType=[{}], recordDate=[{}]",
                 command.userId().getValue(), command.exerciseType(), command.recordDate());
-
-        // 하루 최대 2개 운동기록 제한 검증
+
+        // 하루 최대 2개 기록 제한 검증 (전체 타입 합쳐서)
+        int totalRecordCount = getTotalRecordCount(command.userId(), command.recordDate());
+
+        if (totalRecordCount >= MAX_DAILY_RECORDS) {
+            throw new CustomException(ErrorCode.EXERCISE_RECORD_LIMIT_EXCEEDED);
+        }
+
+        // 전체 기록 종류 최대 2가지 제한 검증
         int exerciseRecordCount = exerciseRecordRepository.countByUserIdAndRecordDate(
-            command.userId(), 
+            command.userId(),
             command.recordDate()
         );
-
-        if (exerciseRecordCount >= 2) {
-            throw new CustomException(ErrorCode.EXERCISE_RECORD_LIMIT_EXCEEDED);
-        }
-
-        // 전체 기록 종류 최대 2가지 제한 검증 (운동기록이 없는 경우에만)
+
         if (exerciseRecordCount == 0) {
             validateRecordTypeLimit(command.userId(), command.recordDate());
         }
@@ -137,11 +144,11 @@ public DailyExerciseRecordResponse getDailyExerciseRecords(String userIdValue, L
         List<ExerciseRecordResponse> responseList = exerciseRecords.stream()
                 .map(this::toResponse)
                 .map(this::updateImageUrls)
-                .collect(Collectors.toList());
-        
-        log.info("일일 운동기록 조회 완료: userId=[{}], date=[{}], count=[{}]", 
+                .toList();
+
+        log.info("일일 운동기록 조회 완료: userId=[{}], date=[{}], count=[{}]",
                 userIdValue, date, responseList.size());
-        
+
         return new DailyExerciseRecordResponse(date, responseList);
     }
 
@@ -157,11 +164,11 @@ public List<ExerciseRecordResponse> getExerciseRecordsBetween(String userIdValue
         List<ExerciseRecordResponse> responseList = exerciseRecords.stream()
                 .map(this::toResponse)
                 .map(this::updateImageUrls)
-                .collect(Collectors.toList());
-        
-        log.info("기간별 운동기록 조회 완료: userId=[{}], startDate=[{}], endDate=[{}], count=[{}]", 
+                .toList();
+
+        log.info("기간별 운동기록 조회 완료: userId=[{}], startDate=[{}], endDate=[{}], count=[{}]",
                 userIdValue, startDate, endDate, responseList.size());
-        
+
         return responseList;
     }
 
@@ -214,6 +221,17 @@ private ExerciseRecordResponse updateImageUrls(ExerciseRecordResponse response)
         return response.withUpdatedImageUrls(updatedUrls);
     }
 
+    /**
+     * 하루 전체 기록 개수 조회 (DAILY + EXERCISE + HABIT 합계)
+     */
+    private int getTotalRecordCount(UserId userId, LocalDate recordDate) {
+        int dailyCount = recordRepository.countByUserIdAndRecordDateAndType(userId, recordDate, RecordType.DAILY);
+        int exerciseCount = exerciseRecordRepository.countByUserIdAndRecordDate(userId, recordDate);
+        int habitCount = habitRecordRepository.countByUserIdAndRecordDate(userId, recordDate);
+
+        return dailyCount + exerciseCount + habitCount;
+    }
+
     /**
      * 하루에 등록할 수 있는 기록 종류가 최대 2가지인지 검증
      */
@@ -230,7 +248,7 @@ private void validateRecordTypeLimit(UserId userId, LocalDate recordDate) {
         if (habitCount > 0) recordTypeCount++;
 
         // 이미 2가지 기록 종류가 있다면 운동기록을 추가할 수 없음
-        if (recordTypeCount >= 2) {
+        if (recordTypeCount >= MAX_RECORD_TYPES_PER_DAY) {
             throw new CustomException(ErrorCode.RECORD_TYPE_LIMIT_EXCEEDED);
         }
     }
@@ -280,24 +298,11 @@ private void updateGoalProgress(UserId userId) {
     /**
      * 운동 목표의 완료일수 계산
      * 하루에 운동 기록이 하나라도 있으면 완료로 간주
+     * (성능 최적화: N번 쿼리 대신 1번 DISTINCT COUNT 쿼리)
      */
-    private int calculateCompletedDaysForExercise(UserId userId, 
+    private int calculateCompletedDaysForExercise(UserId userId,
                                                  java.time.LocalDate startDate, java.time.LocalDate endDate) {
-        int completedDays = 0;
-        java.time.LocalDate currentDate = startDate;
-
-        while (!currentDate.isAfter(endDate)) {
-            // 해당 날짜에 운동 기록이 있는지 확인
-            var exerciseRecords = exerciseRecordRepository.findByUserIdAndRecordDate(userId, currentDate);
-            boolean hasRecord = !exerciseRecords.isEmpty();
-
-            if (hasRecord) {
-                completedDays++;
-            }
-
-            currentDate = currentDate.plusDays(1);
-        }
-
-        return completedDays;
+        return exerciseRecordQueryRepository.countDistinctRecordDatesByUserIdAndDateRange(
+            userId, startDate, endDate);
     }
 }