Develop

.gitignore

@@ -57,6 +57,9 @@ PRD.md
 ### Uploads ###
 uploads/
 
+### Python migration scripts (로컬 일회성 작업용) ###
+scripts/
+
 ### Static seed images (로컬에서만 사용, ready_image.png는 예외) ###
 src/main/resources/static/images/*
 !src/main/resources/static/images/ready_image.png

Dockerfile

@@ -13,6 +13,9 @@ RUN ./gradlew bootJar --no-daemon -x test
 
 # ── 2단계: 실행 ────────────────────────────────────────────
 FROM eclipse-temurin:21.0.6_7-jre-noble
+
+ENV TZ=Asia/Seoul
+
 WORKDIR /app
 
 # HEALTHCHECK용 wget 설치 (eclipse-temurin jre-noble 이미지에 미포함)

build.gradle

@@ -14,6 +14,13 @@ java {
     }
 }
 
+// spring-ai-bom을 dependencyManagement 블록으로 이동
+dependencyManagement {
+    imports {
+        mavenBom "org.springframework.ai:spring-ai-bom:1.1.4"
+    }
+}
+
 configurations {
     compileOnly {
         extendsFrom annotationProcessor
@@ -25,7 +32,6 @@ repositories {
 }
 
 dependencies {
-    implementation platform('org.springframework.ai:spring-ai-bom:1.1.4')
     implementation 'org.springframework.ai:spring-ai-starter-model-google-genai'
     implementation 'org.jetbrains.kotlin:kotlin-reflect'
     implementation 'org.springframework.boot:spring-boot-starter-actuator'

data/init-data.sql

@@ -54,6 +54,8 @@ CREATE TABLE IF NOT EXISTS stores (
     is_deleted BOOLEAN NOT NULL
 );
 
+DROP TABLE IF EXISTS temp_stores;
+
 CREATE TEMP TABLE temp_stores (
                                   store_name text, store_image text, category text,
                                   latitude double precision, longitude double precision,
@@ -64,7 +66,7 @@ CREATE TEMP TABLE temp_stores (
 COPY temp_stores FROM '/tmp/data/store_data.csv' WITH (FORMAT csv, HEADER true);
 
 INSERT INTO stores (store_name, store_image, category, latitude, longitude, address, district, team, open_time,
-                    close_time, status, review_count, bookmark_count, is_deleted, created_at)
+                    close_time, status, review_count, bookmark_count, average_star, is_deleted, created_at)
 SELECT store_name,
        NULLIF(store_image, ''),
        category,
@@ -78,6 +80,26 @@ SELECT store_name,
        'ACTIVE',
        0,
        0,
+       0.0,
        false,
        NOW()
 FROM temp_stores;
+
+
+-- 1. 쿠폰 템플릿 생성 (AI 테스트용 5000원 할인 쿠폰)
+INSERT INTO coupon_templates (id, coupon_name, amount, discount_rate, started_at, expired_at, remain, created_at, updated_at, is_deleted)
+VALUES (100, 'AI 테스트용 쿠폰', 5000, 10, '2026-01-01 00:00:00', '2026-12-31 23:59:59', 100, NOW(), NOW(), false)
+ON CONFLICT (id) DO NOTHING; -- 이미 100번 템플릿이 있으면 무시
+
+-- 2. 4번 사용자에게 위 템플릿으로 쿠폰 발급
+INSERT INTO coupons (user_id, coupon_template_id, status, created_at, updated_at, is_deleted)
+VALUES (4, 100, 'UNUSED', NOW(), NOW(), false)
+ON CONFLICT DO NOTHING; -- 이미 해당 유저가 이 쿠폰을 가지고 있으면 무시
+
+-- (PostgreSQL 사용 시) 시퀀스 값 업데이트
+SELECT setval('coupon_templates_id_seq', (SELECT MAX(id) FROM coupon_templates));
+SELECT setval('coupons_id_seq', (SELECT MAX(id) FROM coupons));
+
+
+-- 4번 사용자의 role을 'ADMIN'으로 업데이트
+UPDATE users SET role = 'ADMIN' WHERE id = 4;

src/main/java/com/catchtable/CatchtableApplication.java

@@ -5,8 +5,10 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
 import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @EnableAsync
+@EnableScheduling
 @EnableJpaAuditing
 @SpringBootApplication
 public class CatchtableApplication {

src/main/java/com/catchtable/chatbot/service/ChatbotService.java

@@ -1,62 +1,73 @@
 package com.catchtable.chatbot.service;
 
-import java.util.List;
-
 import com.catchtable.chatbot.dto.create.ChatMessageRequest;
 import com.catchtable.chatbot.dto.create.ChatMessageResponse;
 import com.catchtable.chatbot.dto.read.ChatMessageListResponse;
 import com.catchtable.chatbot.entity.ChatMessage;
 import com.catchtable.chatbot.entity.MessageRole;
+import com.catchtable.coupon.service.CouponService;
 import com.catchtable.global.exception.CustomException;
 import com.catchtable.global.exception.ErrorCode;
+import com.catchtable.reservation.service.ReservationService;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.ai.chat.client.ChatClient;
 import org.springframework.ai.chat.messages.AssistantMessage;
 import org.springframework.ai.chat.messages.Message;
 import org.springframework.ai.chat.messages.SystemMessage;
 import org.springframework.ai.chat.messages.UserMessage;
-import org.springframework.ai.chat.prompt.Prompt;
 import org.springframework.stereotype.Service;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class ChatbotService {
 
     private static final int MAX_HISTORY_SIZE = 20;
 
-    private static final String SYSTEM_PROMPT =
-            "너는 캐치테이블 레스토랑 예약 플랫폼의 AI 도우미야. "
-            + "사용자의 예약, 매장 검색, 맛집 추천 요청을 도와줘. "
-            + "한국어로 친절하게 답변해.";
+    private String buildSystemPrompt() {
+            return "너는 'CatchEat(캐치잇)'이라는 레스토랑 예약 플랫폼의 AI 비서야. "
+                    + "오늘 날짜는 " + java.time.LocalDate.now() + "이야. "
+                    + "사용자가 '5월 12일'처럼 연도 없이 날짜를 말하면 오늘 날짜 기준으로 가장 가까운 미래 날짜로 해석해. "
+                    + "너의 역할은 사용자의 질문을 이해하고, 주어진 도구(함수)를 사용하여 레스토랑 예약 요청을 처리하는 것이야. "
+                    + "사용자가 예약을 요청하면, 'createReservationFromAi' 함수를 호출하기 전에 반드시 'getAvailableCouponsForAi' 함수를 먼저 호출해서 사용자에게 사용 가능한 쿠폰이 있는지 확인하고, 있다면 어떤 쿠폰을 사용할지 물어봐야 해."
+                    + "만약 사용 가능한 쿠폰이 없다면, 바로 'createReservationFromAi' 함수를 호출해서 예약을 진행해. "
+                    + "사용자가 쿠폰을 사용하겠다고 하면, 답변에서 쿠폰 ID(숫자)를 정확히 추출하여 'createReservationFromAi' 함수의 'couponId' 파라미터에 반드시 포함시켜서 호출해야 해. "
+                    + "함수를 호출하기 전에 '매장 이름', '날짜', '시간', '인원수' 4가지 정보가 모두 있는지 확인해. "
+                    + "정보가 부족하면 사용자에게 추가 정보를 요청해. "
+                    + "모든 답변은 한국어로, 친절하고 명확하게 제공해야 해.";
+    }
 
     private final ChatClient chatClient;
     private final ChatbotDbService dbService;
+    private final ReservationService reservationService;
+    private final CouponService couponService;
 
-    // 트랜잭션 없음 — 흐름 제어만
     public ChatMessageResponse sendMessage(Long userId, ChatMessageRequest request) {
-        // 1단계: DB 작업 (@Transactional) — 세션 조회/생성, 일일 제한 확인, 사용자 메시지 저장
         Long sessionId = dbService.saveUserMessage(userId, request.message());
-
-        // 2단계: AI 호출 (트랜잭션 없음 — DB 커넥션 안 잡음)
         List<ChatMessage> history = dbService.getRecentHistory(sessionId, MAX_HISTORY_SIZE);
-        String reply = callAi(history);
+
+        String reply = callAi(history, userId);
+
         if (reply == null || reply.isBlank()) {
             throw new CustomException(ErrorCode.CHAT_AI_ERROR);
         }
 
-        // 3단계: DB 작업 (@Transactional) — AI 응답 저장
         ChatMessage saved = dbService.saveAssistantMessage(sessionId, reply);
-
         return new ChatMessageResponse(saved.getId(), reply);
     }
 
     public List<ChatMessageListResponse> getMessages(Long userId) {
         return dbService.getMessages(userId);
     }
 
-    private String callAi(List<ChatMessage> history) {
-        List<Message> messages = new java.util.ArrayList<>();
-        messages.add(new SystemMessage(SYSTEM_PROMPT));
+    private String callAi(List<ChatMessage> history, Long userId) {
+        List<Message> messages = new ArrayList<>();
+        messages.add(new SystemMessage(buildSystemPrompt()));
 
         for (ChatMessage msg : history) {
             if (msg.getRole() == MessageRole.USER) {
@@ -67,22 +78,33 @@ private String callAi(List<ChatMessage> history) {
         }
 
         try {
-            return chatClient.prompt(new Prompt(messages))
+            return chatClient.prompt()
+                    .messages(messages)
+                    .tools(reservationService, couponService)
+                    .toolContext(Map.of("userId", userId))
                     .call()
                     .content();
+
         } catch (Exception e) {
-            String message = getFullErrorMessage(e).toLowerCase();
-            if (message.contains("api key") || message.contains("auth") || message.contains("401")) {
-                throw new CustomException(ErrorCode.CHAT_AI_AUTH_ERROR);
-            }
-            if (message.contains("rate") || message.contains("429") || message.contains("quota")) {
-                throw new CustomException(ErrorCode.CHAT_AI_RATE_LIMIT);
-            }
-            if (message.contains("timeout") || message.contains("timed out")) {
-                throw new CustomException(ErrorCode.CHAT_AI_TIMEOUT);
-            }
-            throw new CustomException(ErrorCode.CHAT_AI_ERROR);
+            handleAiException(e);
+            return null;
+        }
+    }
+
+    private void handleAiException(Exception e) {
+        log.error("AI API 호출 중 예외 발생", e);
+
+        String message = getFullErrorMessage(e).toLowerCase();
+        if (message.contains("api key") || message.contains("auth") || message.contains("401")) {
+            throw new CustomException(ErrorCode.CHAT_AI_AUTH_ERROR);
+        }
+        if (message.contains("rate") || message.contains("429") || message.contains("quota")) {
+            throw new CustomException(ErrorCode.CHAT_AI_RATE_LIMIT);
+        }
+        if (message.contains("timeout") || message.contains("timed out")) {
+            throw new CustomException(ErrorCode.CHAT_AI_TIMEOUT);
         }
+        throw new CustomException(ErrorCode.CHAT_AI_ERROR);
     }
 
     private String getFullErrorMessage(Exception e) {

src/main/java/com/catchtable/coupon/repository/CouponRepository.java

@@ -2,9 +2,11 @@
 
 import com.catchtable.coupon.entity.Coupon;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.query.Param;
 
+import java.time.LocalDateTime;
 import java.util.List;
 
 public interface CouponRepository extends JpaRepository<Coupon, Long> {
@@ -13,4 +15,15 @@ public interface CouponRepository extends JpaRepository<Coupon, Long> {
     List<Coupon> findAllByUserId(@Param("userId") Long userId);
 
     boolean existsByUserIdAndCouponTemplateId(Long userId, Long couponTemplateId);
+
+    /**
+     * UNUSED 상태의 쿠폰 중 템플릿 만료 시각이 지난 것을 일괄 EXPIRED로 전환한다.
+     * 경로 표현식(c.couponTemplate.expiredAt) 사용 시 Hibernate가 암시적 조인을 처리한다.
+     */
+    @Modifying(clearAutomatically = true, flushAutomatically = true)
+    @Query("UPDATE Coupon c SET c.status = com.catchtable.coupon.entity.CouponStatus.EXPIRED " +
+            "WHERE c.status = com.catchtable.coupon.entity.CouponStatus.UNUSED " +
+            "AND c.isDeleted = false " +
+            "AND c.couponTemplate.expiredAt < :now")
+    int expireCoupons(@Param("now") LocalDateTime now);
 }

src/main/java/com/catchtable/coupon/scheduler/CouponExpirationScheduler.java

@@ -0,0 +1,35 @@
+package com.catchtable.coupon.scheduler;
+
+import com.catchtable.coupon.repository.CouponRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.Clock;
+import java.time.LocalDateTime;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class CouponExpirationScheduler {
+
+    private final CouponRepository couponRepository;
+    private final Clock clock;
+
+    /**
+     * 5분 주기로 만료된 쿠폰을 EXPIRED 상태로 전환한다.
+     * 벌크 UPDATE 단일 쿼리로 처리하므로 트랜잭션 부담이 작다.
+     */
+    @Scheduled(cron = "0 */5 * * * *")
+    @Transactional
+    public void expireCoupons() {
+        LocalDateTime now = LocalDateTime.now(clock);
+        int affected = couponRepository.expireCoupons(now);
+
+        if (affected > 0) {
+            log.info("[쿠폰 만료] {}건 EXPIRED 처리 완료", affected);
+        }
+    }
+}

src/main/java/com/catchtable/coupon/service/CouponService.java

@@ -6,6 +6,7 @@
 import com.catchtable.coupon.dto.read.CouponReadResponse;
 import com.catchtable.coupon.dto.read.CouponTemplateActiveResponse;
 import com.catchtable.coupon.entity.Coupon;
+import com.catchtable.coupon.entity.CouponStatus;
 import com.catchtable.coupon.entity.CouponTemplate;
 import com.catchtable.coupon.repository.CouponRepository;
 import com.catchtable.coupon.repository.CouponTemplateRepository;
@@ -14,12 +15,17 @@
 import com.catchtable.user.entity.User;
 import com.catchtable.user.repository.UserRepository;
 import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.ai.tool.annotation.Tool;
+import org.springframework.ai.chat.model.ToolContext;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.stream.Collectors;
 
+@Slf4j
 @Service
 @RequiredArgsConstructor
 public class CouponService {
@@ -96,4 +102,35 @@ public void returnCoupon(Long couponId) {
 
         coupon.returnCoupon();
     }
+
+    @Tool(description = "사용자가 예약 시 사용할 수 있는 쿠폰 목록을 조회합니다. " +
+            "쿠폰 ID와 할인 정보를 포함하여 사용자에게 어떤 쿠폰을 사용할지 물어볼 때 사용됩니다.")
+    @Transactional(readOnly = true)
+    public String getAvailableCouponsForAi(ToolContext toolContext) {
+        Long userId = (Long) toolContext.getContext().get("userId");
+        log.info("AI Tool 호출: getAvailableCouponsForAi, userId={}", userId);
+
+        List<Coupon> availableCoupons = couponRepository.findAllByUserId(userId).stream()
+                .filter(coupon -> coupon.getStatus() == CouponStatus.UNUSED && coupon.getCouponTemplate().getExpiredAt().isAfter(LocalDateTime.now()))
+                .collect(Collectors.toList());
+
+        if (availableCoupons.isEmpty()) {
+            return "사용 가능한 쿠폰이 없습니다.";
+        }
+
+        return availableCoupons.stream()
+                .map(coupon -> {
+                    String discountInfo;
+                    if (coupon.getCouponTemplate().getDiscountRate() != null) {
+                        discountInfo = coupon.getCouponTemplate().getDiscountRate() + "% 할인";
+                    } else {
+                        discountInfo = coupon.getCouponTemplate().getAmount() + "원 할인";
+                    }
+                    return String.format("%s (ID: %d, %s)",
+                            coupon.getCouponTemplate().getCouponName(),
+                            coupon.getId(),
+                            discountInfo);
+                })
+                .collect(Collectors.joining(", "));
+    }
 }

src/main/java/com/catchtable/global/config/SchedulerConfig.java

@@ -0,0 +1,23 @@
+package com.catchtable.global.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+import java.time.Clock;
+import java.time.ZoneId;
+
+@Configuration
+@EnableScheduling
+public class SchedulerConfig {
+
+    /**
+     * 스케줄러 및 시간 비교 로직에서 사용할 Clock.
+     * KST(Asia/Seoul) 기준으로 고정하여 Docker 컨테이너 기본 타임존(UTC) 영향을 받지 않도록 한다.
+     * LocalDateTime.now(clock) 형태로 사용하면 타임존 일관성과 테스트 가능성이 모두 확보된다.
+     */
+    @Bean
+    public Clock clock() {
+        return Clock.system(ZoneId.of("Asia/Seoul"));
+    }
+}

src/main/java/com/catchtable/global/config/SecurityConfig.java

@@ -47,7 +47,8 @@ public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
                                 "/v3/api-docs/**",
                                 "/swagger-resources/**",
                                 "/actuator/health",
-                                "/actuator/info"
+                                "/actuator/info",
+                                "/images/**"
                         ).permitAll()
                         .requestMatchers(HttpMethod.GET,
                                 "/api/v1/stores/**",