[refactor #112] 좌석 선점 ttl 만료 이벤트 수정

common/core/src/main/resources/application-eureka.yml

@@ -1,4 +1,10 @@
 eureka:
   client:
     service-url:
-      defaultZone: ${EUREKA_SERVER}
+      defaultZone: ${EUREKA_SERVER}
+
+spring:
+  cloud:
+    loadbalancer:
+      ribbon:
+        enabled: true

common/messaging/src/main/java/messaging/events/OrderFailedEvent.java

@@ -0,0 +1,15 @@
+package messaging.events;
+
+import java.util.UUID;
+
+public record OrderFailedEvent(
+        UUID scheduleId,
+        UUID seatId
+) {
+    public static OrderFailedEvent create(UUID scheduleId, UUID seatId) {
+        return new OrderFailedEvent(
+                scheduleId,
+                seatId
+        );
+    }
+}

common/messaging/src/main/java/messaging/events/SeatPreReserveExpiredEvent.java

@@ -0,0 +1,17 @@
+package messaging.events;
+
+import java.util.UUID;
+
+public record SeatPreReserveExpiredEvent(
+        UUID scheduleId,
+        UUID seatId
+) {
+
+    public static SeatPreReserveExpiredEvent create(UUID scheduleId, UUID seatId) {
+        return new SeatPreReserveExpiredEvent(
+                scheduleId,
+                seatId
+        );
+    }
+
+}

common/messaging/src/main/java/messaging/topics/OrderTopic.java

@@ -8,7 +8,8 @@
 public enum OrderTopic {
 
     COMPLETED_FOR_SEAT_RESERVATION("order-completed-for-seat-reservation"),
-    COMPLETED_FOR_QUEUE_TOKEN_REMOVAL("order-completed-for-queue-token-removal");
+    COMPLETED_FOR_QUEUE_TOKEN_REMOVAL("order-completed-for-queue-token-removal"),
+    FAILED("order-failed");
 
     private final String topic;
 

common/messaging/src/main/java/messaging/topics/SeatTopic.java

@@ -0,0 +1,13 @@
+package messaging.topics;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@Getter
+@RequiredArgsConstructor
+public enum SeatTopic {
+
+    PRE_RESERVE_EXPIRED("pre-reserve-expired");
+
+    private final String topic;
+}

services/order/build.gradle

@@ -38,7 +38,6 @@ dependencies {
 	implementation project(':common:core')
 	implementation project(':common:dtos')
 	implementation project(':common:rdb')
-	implementation project(':common:caching')
 	implementation project(':common:messaging')
 	implementation project(':common:monitoring')
 

services/order/src/main/java/com/ticketPing/order/OrderApplication.java

@@ -7,7 +7,7 @@
 
 @SpringBootApplication
 @EnableFeignClients
-@ComponentScan(basePackages = {"com.ticketPing.order", "aop", "exception", "audit", "caching", "messaging"})
+@ComponentScan(basePackages = {"com.ticketPing.order", "aop", "exception", "audit", "messaging"})
 public class OrderApplication {
     public static void main(String[] args) {
         SpringApplication.run(OrderApplication.class, args);

services/order/src/main/java/com/ticketPing/order/application/client/PaymentClient.java

@@ -0,0 +1,12 @@
+package com.ticketPing.order.application.client;
+
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RequestParam;
+import payment.PaymentResponse;
+import response.CommonResponse;
+
+import java.util.UUID;
+
+public interface PaymentClient {
+    ResponseEntity<CommonResponse<PaymentResponse>> getCompletedPaymentByOrderId(@RequestParam("orderId") UUID orderId);
+}

services/order/src/main/java/com/ticketPing/order/application/service/EventApplicationService.java

@@ -2,6 +2,7 @@
 
 import messaging.events.OrderCompletedForQueueTokenRemovalEvent;
 import messaging.events.OrderCompletedForSeatReservationEvent;
+import messaging.events.OrderFailedEvent;
 import messaging.utils.EventSerializer;
 import lombok.RequiredArgsConstructor;
 import org.springframework.kafka.core.KafkaTemplate;
@@ -24,4 +25,9 @@ public void publishForQueueTokenRemoval(OrderCompletedForQueueTokenRemovalEvent
         kafkaTemplate.send(OrderTopic.COMPLETED_FOR_QUEUE_TOKEN_REMOVAL.getTopic(), message);
     }
 
+    public void publishOrderFailed(OrderFailedEvent event) {
+        String message = EventSerializer.serialize(event);
+        kafkaTemplate.send(OrderTopic.FAILED.getTopic(), message);
+    }
+
 }

services/order/src/main/java/com/ticketPing/order/application/service/OrderService.java

@@ -1,5 +1,6 @@
 package com.ticketPing.order.application.service;
 
+import com.ticketPing.order.application.client.PaymentClient;
 import com.ticketPing.order.application.client.PerformanceClient;
 import com.ticketPing.order.application.dtos.OrderResponse;
 import com.ticketPing.order.common.exception.OrderExceptionCase;
@@ -9,19 +10,21 @@
 import com.ticketPing.order.domain.repository.OrderRepository;
 import com.ticketPing.order.presentation.request.CreateOrderRequest;
 import exception.ApplicationException;
+import feign.FeignException;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import lombok.val;
 import messaging.events.OrderCompletedForQueueTokenRemovalEvent;
 import messaging.events.OrderCompletedForSeatReservationEvent;
-import org.springframework.data.domain.Page;
+import messaging.events.OrderFailedEvent;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Slice;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import performance.OrderSeatResponse;
 
 import java.util.List;
+import java.util.Optional;
 import java.util.UUID;
 
 import static com.ticketPing.order.common.exception.OrderExceptionCase.DUPLICATED_ORDER;
@@ -35,6 +38,7 @@ public class OrderService {
     private final OrderRepository orderRepository;
     private final EventApplicationService eventApplicationService;
     private final PerformanceClient performanceClient;
+    private final PaymentClient paymentClient;
 
     @Transactional
     public OrderResponse createOrder(CreateOrderRequest createOrderRequest, UUID userId) {
@@ -58,6 +62,23 @@ public void validateOrderAndExtendTTL(UUID orderId, UUID userId) {
         performanceClient.extendPreReserveTTL(order.getScheduleId(), order.getOrderSeat().getSeatId());
     }
 
+    @Transactional
+    public void failOrder(UUID scheduleId, UUID seatId) {
+        Optional<Order> optionalOrder = orderRepository.findByOrderSeatSeatIdAndOrderStatus(seatId, OrderStatus.PENDING);
+
+        if (optionalOrder.isPresent()) {
+            Order order = optionalOrder.get();
+            try {
+                paymentClient.getCompletedPaymentByOrderId(order.getId());
+            } catch (FeignException.NotFound e) {
+                order.fail();
+                publishOrderFailed(scheduleId, seatId);
+            }
+        } else {
+            publishOrderFailed(scheduleId, seatId);
+        }
+    }
+
     @Transactional
     public void completeOrder(UUID orderId, UUID paymentId) {
         Order order = findOrderById(orderId);
@@ -112,4 +133,9 @@ private void publishForQueueTokenRemoval(UUID userId, UUID performanceId) {
         val event = OrderCompletedForQueueTokenRemovalEvent.create(userId, performanceId);
         eventApplicationService.publishForQueueTokenRemoval(event);
     }
+
+    private void publishOrderFailed(UUID scheduleId, UUID seatId) {
+        val event = OrderFailedEvent.create(scheduleId, seatId);
+        eventApplicationService.publishOrderFailed(event);
+    }
 }

services/order/src/main/java/com/ticketPing/order/domain/model/entity/Order.java

@@ -63,4 +63,7 @@ public void complete(UUID paymentId){
         this.paymentId =  paymentId;
     }
 
+    public void fail() {
+        this.orderStatus = OrderStatus.FAIL;
+    }
 }

services/order/src/main/java/com/ticketPing/order/domain/repository/OrderRepository.java

@@ -14,6 +14,8 @@ public interface OrderRepository {
 
     Optional<Order> findById(UUID orderId);
 
+    Optional<Order> findByOrderSeatSeatIdAndOrderStatus(UUID seatId, OrderStatus orderStatus);
+
     Optional<Order> findByIdAndOrderStatus(UUID orderId, OrderStatus orderStatus);
 
     boolean existsByOrderSeatSeatIdAndOrderStatusIn(UUID seatId, List<OrderStatus> statuses);

services/order/src/main/java/com/ticketPing/order/infrastructure/client/PaymentFeignClient.java

@@ -0,0 +1,18 @@
+package com.ticketPing.order.infrastructure.client;
+
+import com.ticketPing.order.application.client.PaymentClient;
+import org.springframework.cloud.openfeign.FeignClient;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import payment.PaymentResponse;
+import response.CommonResponse;
+
+import java.util.UUID;
+
+@FeignClient(name = "payment")
+public interface PaymentFeignClient extends PaymentClient {
+    @GetMapping("/api/v1/payments/completed")
+    ResponseEntity<CommonResponse<PaymentResponse>> getCompletedPaymentByOrderId(@RequestParam("orderId") UUID orderId);
+
+}

services/order/src/main/java/com/ticketPing/order/infrastructure/listener/EventConsumer.java

@@ -3,6 +3,7 @@
 import com.ticketPing.order.application.service.OrderService;
 import messaging.events.PaymentCompletedEvent;
 import lombok.RequiredArgsConstructor;
+import messaging.events.SeatPreReserveExpiredEvent;
 import messaging.utils.EventLogger;
 import messaging.utils.EventSerializer;
 import org.apache.kafka.clients.consumer.ConsumerRecord;
@@ -24,4 +25,12 @@ public void handlePaymentCompletedEvent(ConsumerRecord<String, String> record, A
         acknowledgment.acknowledge();
     }
 
+    @KafkaListener(topics = "pre-reserve-expired", groupId = "order-group")
+    public void handleSeatPreReserveExpiredEvent(ConsumerRecord<String, String> record, Acknowledgment acknowledgment) {
+        EventLogger.logReceivedMessage(record);
+        SeatPreReserveExpiredEvent event = EventSerializer.deserialize(record.value(), SeatPreReserveExpiredEvent.class);
+        orderService.failOrder(event.scheduleId(), event.seatId());
+        acknowledgment.acknowledge();
+    }
+
 }

services/order/src/main/resources/application.yml

@@ -12,7 +12,6 @@ spring:
     import:
       - "classpath:application-eureka.yml"
       - "classpath:application-jpa.yml"
-      - "classpath:application-redis.yml"
       - "classpath:application-kafka.yml"
       - "classpath:application-monitoring.yml"