[REFACTOR] 주문 내부 API 사용 수정 및 페이징 기능 추가

order-service/build.gradle

@@ -45,6 +45,11 @@ dependencies {
 	implementation 'org.springframework.boot:spring-boot-starter-web'
 	implementation 'org.springframework.boot:spring-boot-starter-amqp'
 
+	// 6. OpenFeign + Retry
+	implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
+	implementation 'org.springframework.retry:spring-retry'
+	implementation 'org.springframework.boot:spring-boot-starter-aop'
+
 	// 5. Redis
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
 

order-service/src/main/java/com/shipflow/orderservice/OrderserviceApplication.java

@@ -2,8 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cloud.openfeign.EnableFeignClients;
+import org.springframework.retry.annotation.EnableRetry;
 
 @SpringBootApplication(scanBasePackages = "com.shipflow")
+@EnableFeignClients(basePackages = "com.shipflow.orderservice.infrastructure.client")
+@EnableRetry
 public class OrderserviceApplication {
 
 	public static void main(String[] args) {

order-service/src/main/java/com/shipflow/orderservice/application/dto/CreateOrderCommand.java

@@ -5,13 +5,18 @@
 
 public record CreateOrderCommand(
         UUID ordererId,
+        String ordererName,
         UUID productId,
+        String productName,
         UUID supplierCompanyId,
+        String supplierCompanyName,
         UUID receiverCompanyId,
+        String receiverCompanyName,
         UUID departureHubId,
         UUID arrivalHubId,
         int quantity,
         LocalDateTime requestDeadline,
-        String requestNote
+        String requestNote,
+        String deliveryAddress
 ) {
 }

order-service/src/main/java/com/shipflow/orderservice/application/dto/OrderResult.java

@@ -20,6 +20,7 @@ public record OrderResult(
         String cancelReason,
         LocalDateTime requestDeadline,
         String requestNote,
+        String deliveryAddress,
         UUID createdBy,
         LocalDateTime createdAt,
         UUID updatedBy,
@@ -40,6 +41,7 @@ public static OrderResult from(Order order) {
                 order.getCancelReason(),
                 order.getRequestDeadline(),
                 order.getRequestNote(),
+                order.getDeliveryAddress(),
                 order.getCreatedBy(),
                 order.getCreatedAt(),
                 order.getUpdatedBy(),

order-service/src/main/java/com/shipflow/orderservice/application/dto/OrderSearchCondition.java

@@ -0,0 +1,21 @@
+package com.shipflow.orderservice.application.dto;
+
+import com.shipflow.orderservice.domain.model.OrderStatus;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+
+public record OrderSearchCondition(
+        OrderStatus status,
+        UUID ordererId,
+        UUID productId,
+        UUID supplierCompanyId,
+        UUID receiverCompanyId,
+        LocalDateTime createdFrom,
+        LocalDateTime createdTo
+) {
+    public OrderSearchCondition withOrdererId(UUID forcedOrdererId) {
+        return new OrderSearchCondition(status, forcedOrdererId, productId,
+                supplierCompanyId, receiverCompanyId, createdFrom, createdTo);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/application/service/OrderCommandService.java

@@ -4,6 +4,7 @@
 import com.shipflow.orderservice.application.dto.CreateOrderCommand;
 import com.shipflow.orderservice.application.dto.OrderResult;
 import com.shipflow.orderservice.application.dto.UpdateOrderCommand;
+import com.shipflow.orderservice.presentation.dto.CreateOrderRequest;
 import com.shipflow.common.messaging.publisher.EventPublisher;
 import com.shipflow.orderservice.domain.event.*;
 import com.shipflow.orderservice.domain.model.ShipmentStatus;
@@ -29,8 +30,14 @@ public class OrderCommandService {
     private final OrderRepository orderRepository;
     private final EventPublisher rabbitPublisher;
     private final ApplicationEventPublisher domainEventPublisher;
+    private final OrderFetchService orderFetchService;
+
+    public OrderResult createOrder(CreateOrderRequest request, UUID ordererId) {
+        CreateOrderCommand cmd = orderFetchService.fetchAndBuild(
+                ordererId, request.productId(), request.quantity(),
+                request.requestDeadline(), request.requestNote()
+        );
 
-    public OrderResult createOrder(CreateOrderCommand cmd, UUID requesterId) {
         Order order = Order.create(
                 cmd.ordererId(),
                 cmd.productId(),
@@ -39,14 +46,16 @@ public OrderResult createOrder(CreateOrderCommand cmd, UUID requesterId) {
                 new Quantity(cmd.quantity()),
                 cmd.requestDeadline(),
                 cmd.requestNote(),
-                requesterId
+                cmd.deliveryAddress(),
+                ordererId
         );
         Order saved = orderRepository.save(order);
 
         domainEventPublisher.publishEvent(new OrderCreatingEvent(
-                saved.getId(), saved.getOrdererId(), saved.getProductId(),
-                saved.getCompanyInfo().getSupplierCompanyId(),
-                saved.getCompanyInfo().getReceiverCompanyId(),
+                saved.getId(), saved.getOrdererId(), cmd.ordererName(),
+                saved.getProductId(), cmd.productName(),
+                saved.getCompanyInfo().getSupplierCompanyId(), cmd.supplierCompanyName(),
+                saved.getCompanyInfo().getReceiverCompanyId(), cmd.receiverCompanyName(),
                 saved.getHubInfo().getDepartureHubId(),
                 saved.getHubInfo().getArrivalHubId(),
                 saved.getQuantity().getValue(),
@@ -71,13 +80,16 @@ public void confirmCreation(UUID orderId, String productName) {
         rabbitPublisher.publish(
                 new OrderCreatedEvent(
                         saved.getId(),
+                        saved.getOrdererId(),
                         saved.getCompanyInfo().getSupplierCompanyId(),
                         saved.getCompanyInfo().getReceiverCompanyId(),
                         saved.getProductId(),
                         saved.getQuantity().getValue(),
                         saved.getHubInfo().getDepartureHubId(),
                         saved.getHubInfo().getArrivalHubId(),
-                        saved.getRequestDeadline()
+                        saved.getRequestDeadline(),
+                        saved.getRequestNote(),
+                        saved.getDeliveryAddress()
                 )
         );
     }

order-service/src/main/java/com/shipflow/orderservice/application/service/OrderFetchService.java

@@ -0,0 +1,70 @@
+package com.shipflow.orderservice.application.service;
+
+import com.shipflow.orderservice.application.dto.CreateOrderCommand;
+import com.shipflow.orderservice.infrastructure.client.adapter.CompanyClientAdapter;
+import com.shipflow.orderservice.infrastructure.client.adapter.ProductClientAdapter;
+import com.shipflow.orderservice.infrastructure.client.adapter.UserClientAdapter;
+import com.shipflow.orderservice.infrastructure.client.dto.ProductInfo;
+import com.shipflow.orderservice.infrastructure.client.dto.ReceiverCompanyInfo;
+import com.shipflow.orderservice.infrastructure.client.dto.UserInfo;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.util.UUID;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+@Service
+@RequiredArgsConstructor
+public class OrderFetchService {
+
+    private final ProductClientAdapter productAdapter;
+    private final UserClientAdapter userAdapter;
+    private final CompanyClientAdapter companyAdapter;
+
+    public CreateOrderCommand fetchAndBuild(UUID ordererId, UUID productId,
+                                            int quantity, LocalDateTime deadline, String note) {
+        // Step 1: product, user 병렬 호출
+        CompletableFuture<ProductInfo> productFuture = CompletableFuture.supplyAsync(
+                () -> productAdapter.fetch(ordererId.toString(), productId, quantity));
+        CompletableFuture<UserInfo> userFuture = CompletableFuture.supplyAsync(
+                () -> userAdapter.fetch(ordererId));
+
+        try {
+            CompletableFuture.allOf(productFuture, userFuture).join();
+        } catch (CompletionException e) {
+            Throwable cause = e.getCause();
+            if (cause instanceof RuntimeException re) {
+                throw re;
+            }
+            if (cause instanceof Error err) {
+                throw err;
+            }
+            throw e;
+        }
+
+        ProductInfo product = productFuture.join();
+        UserInfo user = userFuture.join();
+
+        // Step 2: receiverCompanyId 확보 후 company 호출
+        ReceiverCompanyInfo company = companyAdapter.fetch(user.receiverCompanyId());
+
+        return new CreateOrderCommand(
+                ordererId,
+                user.ordererName(),
+                productId,
+                product.productName(),
+                product.supplierCompanyId(),
+                product.supplierCompanyName(),
+                user.receiverCompanyId(),
+                company.companyName(),
+                product.departureHubId(),
+                company.hubId(),
+                quantity,
+                deadline,
+                note,
+                company.address()
+        );
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/application/service/OrderProjectionService.java

@@ -24,9 +24,13 @@ public void on(OrderCreatingEvent e) {
                 .orderId(e.orderId())
                 .orderStatus(OrderStatus.CREATING)
                 .ordererId(e.ordererId())
+                .ordererName(e.ordererName())
                 .productId(e.productId())
+                .productName(e.productName())
                 .supplierCompanyId(e.supplierCompanyId())
+                .supplierCompanyName(e.supplierCompanyName())
                 .receiverCompanyId(e.receiverCompanyId())
+                .receiverCompanyName(e.receiverCompanyName())
                 .departureHubId(e.departureHubId())
                 .arrivalHubId(e.arrivalHubId())
                 .quantity(e.quantity())

order-service/src/main/java/com/shipflow/orderservice/application/service/OrderQueryService.java

@@ -1,23 +1,32 @@
 package com.shipflow.orderservice.application.service;
 
 import com.shipflow.orderservice.application.dto.OrderResult;
+import com.shipflow.orderservice.application.dto.OrderSearchCondition;
 import com.shipflow.orderservice.domain.exception.OrderNotFoundException;
+import com.shipflow.orderservice.domain.exception.UnauthorizedException;
 import com.shipflow.orderservice.domain.model.Order;
 import com.shipflow.orderservice.domain.model.OrderReadModel;
+import com.shipflow.orderservice.domain.model.UserRole;
 import com.shipflow.orderservice.domain.repository.OrderReadModelRepository;
 import com.shipflow.orderservice.domain.repository.OrderRepository;
 import lombok.RequiredArgsConstructor;
+import org.springframework.data.domain.*;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
 public class OrderQueryService {
 
+    private static final Set<Integer> ALLOWED_PAGE_SIZES = Set.of(10, 30, 50);
+    private static final Sort DEFAULT_SORT = Sort.by(Sort.Direction.DESC, "createdAt");
+    private static final Set<String> ALLOWED_SORT_FIELDS = Set.of("createdAt", "updatedAt");
+
     private final OrderRepository orderRepository;
     private final OrderReadModelRepository orderReadModelRepository;
 
@@ -31,6 +40,14 @@ public OrderResult getOrder(UUID orderId) {
         return OrderResult.from(order);
     }
 
+    public OrderResult getOrder(UUID orderId, UUID requesterId, UserRole role) {
+        OrderResult result = getOrder(orderId);
+        if (role.isRestrictedToOwnOrders() && !result.ordererId().equals(requesterId)) {
+            throw new UnauthorizedException();
+        }
+        return result;
+    }
+
     /**
      * 전체 주문 목록을 조회합니다.
      * 데이터 양이 적거나, 시스템 내부의 배치 작업/동기화 작업 시 사용합니다.
@@ -49,4 +66,23 @@ public OrderReadModel getReadModel(UUID orderId) {
         return orderReadModelRepository.findById(orderId)
                 .orElseThrow(() -> new OrderNotFoundException(orderId));
     }
+
+    /**
+     * 검색 조건, 정렬, 페이지네이션을 적용하여 주문 목록을 조회합니다.
+     * 허용된 페이지 크기(10·30·50) 이외의 값은 10으로 정규화되며,
+     * 허용된 정렬 필드(createdAt·updatedAt) 이외의 값은 createdAt DESC로 폴백됩니다.
+     */
+    public Slice<OrderReadModel> searchOrders(OrderSearchCondition condition, Pageable pageable) {
+        int pageSize = ALLOWED_PAGE_SIZES.contains(pageable.getPageSize())
+                ? pageable.getPageSize()
+                : 10;
+
+        Sort sort = pageable.getSort().isSorted()
+                && pageable.getSort().stream().allMatch(o -> ALLOWED_SORT_FIELDS.contains(o.getProperty()))
+                ? pageable.getSort()
+                : DEFAULT_SORT;
+
+        Pageable normalized = PageRequest.of(pageable.getPageNumber(), pageSize, sort);
+        return orderReadModelRepository.search(condition, normalized);
+    }
 }

order-service/src/main/java/com/shipflow/orderservice/domain/event/OrderCreatingEvent.java

@@ -6,9 +6,13 @@
 public record OrderCreatingEvent(
         UUID orderId,
         UUID ordererId,
+        String ordererName,
         UUID productId,
+        String productName,
         UUID supplierCompanyId,
+        String supplierCompanyName,
         UUID receiverCompanyId,
+        String receiverCompanyName,
         UUID departureHubId,
         UUID arrivalHubId,
         int quantity,

order-service/src/main/java/com/shipflow/orderservice/domain/exception/CompanyNotFoundException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class CompanyNotFoundException extends BusinessException {
+
+    public CompanyNotFoundException() {
+        super(OrderErrorCode.COMPANY_NOT_FOUND);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/domain/exception/ExternalServiceException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class ExternalServiceException extends BusinessException {
+
+    public ExternalServiceException(Throwable cause) {
+        super(OrderErrorCode.EXTERNAL_SERVICE_ERROR, cause);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/domain/exception/InsufficientStockException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class InsufficientStockException extends BusinessException {
+
+    public InsufficientStockException() {
+        super(OrderErrorCode.PRODUCT_INSUFFICIENT_STOCK);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/domain/exception/OrderErrorCode.java

@@ -5,8 +5,14 @@
 
 public enum OrderErrorCode implements ErrorCode {
 
+    UNAUTHORIZED("UNAUTHORIZED", HttpStatus.FORBIDDEN, "접근 권한이 없습니다."),
     ORDER_NOT_FOUND("ORDER_NOT_FOUND", HttpStatus.NOT_FOUND, "주문을 찾을 수 없습니다."),
-    INVALID_ORDER_STATE("INVALID_ORDER_STATE", HttpStatus.CONFLICT, "유효하지 않은 주문 상태입니다.");
+    INVALID_ORDER_STATE("INVALID_ORDER_STATE", HttpStatus.CONFLICT, "유효하지 않은 주문 상태입니다."),
+    PRODUCT_NOT_FOUND("PRODUCT_NOT_FOUND", HttpStatus.NOT_FOUND, "상품을 찾을 수 없습니다."),
+    PRODUCT_INSUFFICIENT_STOCK("PRODUCT_INSUFFICIENT_STOCK", HttpStatus.CONFLICT, "재고가 부족합니다."),
+    USER_NOT_FOUND("USER_NOT_FOUND", HttpStatus.NOT_FOUND, "사용자를 찾을 수 없습니다."),
+    COMPANY_NOT_FOUND("COMPANY_NOT_FOUND", HttpStatus.NOT_FOUND, "업체를 찾을 수 없습니다."),
+    EXTERNAL_SERVICE_ERROR("EXTERNAL_SERVICE_ERROR", HttpStatus.SERVICE_UNAVAILABLE, "외부 서비스 오류가 발생했습니다.");
 
     private final String code;
     private final HttpStatus status;

order-service/src/main/java/com/shipflow/orderservice/domain/exception/ProductNotFoundException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class ProductNotFoundException extends BusinessException {
+
+    public ProductNotFoundException() {
+        super(OrderErrorCode.PRODUCT_NOT_FOUND);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/domain/exception/UnauthorizedException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class UnauthorizedException extends BusinessException {
+
+    public UnauthorizedException() {
+        super(OrderErrorCode.UNAUTHORIZED);
+    }
+}

order-service/src/main/java/com/shipflow/orderservice/domain/exception/UserNotFoundException.java

@@ -0,0 +1,10 @@
+package com.shipflow.orderservice.domain.exception;
+
+import com.shipflow.common.exception.BusinessException;
+
+public class UserNotFoundException extends BusinessException {
+
+    public UserNotFoundException() {
+        super(OrderErrorCode.USER_NOT_FOUND);
+    }
+}