feat(order): Just Pick-up 주문내역 Feign 클라이언트 로직 추가

- 아이템 id와 유저 id들을 Set으로 묶어 한번에 통신하게 변경
- Map을 사용하여 id를 key로 map을 name으로 가지게 생성

order-service/src/main/java/com/justpickup/orderservice/domain/order/dto/OrderHistoryDto.java

@@ -0,0 +1,61 @@
+package com.justpickup.orderservice.domain.order.dto;
+
+import com.justpickup.orderservice.domain.order.entity.Order;
+import com.justpickup.orderservice.domain.order.entity.OrderStatus;
+import com.justpickup.orderservice.domain.orderItem.entity.OrderItem;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class OrderHistoryDto {
+    private Long id;
+    private LocalDateTime orderTime;
+    private long price;
+    private OrderStatus orderStatus;
+    private Long storeId;
+    private String storeName;
+    private List<_OrderHistoryItem> orderItems = new ArrayList<>();
+
+    @Getter
+    public static class _OrderHistoryItem {
+        private Long id;
+        private Long itemId;
+        private String itemName;
+
+        public static _OrderHistoryItem of(OrderItem orderItem) {
+            _OrderHistoryItem orderHistoryItem = new _OrderHistoryItem();
+            orderHistoryItem.id = orderItem.getId();
+            orderHistoryItem.itemId = orderItem.getItemId();
+            return orderHistoryItem;
+        }
+
+        public void changeItemName(String itemName) {
+            this.itemName = itemName;
+        }
+    }
+
+    public static OrderHistoryDto of(Order order) {
+        OrderHistoryDto orderHistoryDto = new OrderHistoryDto();
+        orderHistoryDto.id = order.getId();
+        orderHistoryDto.orderTime = order.getOrderTime();
+        orderHistoryDto.price = order.getOrderPrice();
+        orderHistoryDto.orderStatus = order.getOrderStatus();
+        orderHistoryDto.storeId = order.getUserId();
+
+        orderHistoryDto.orderItems = order.getOrderItems().stream()
+                .map(_OrderHistoryItem::of)
+                .collect(Collectors.toList());
+        return orderHistoryDto;
+    }
+
+    public void changeStoreName(String storeName) {
+        this.storeName = storeName;
+    }
+}

order-service/src/main/java/com/justpickup/orderservice/domain/order/repository/OrderRepositoryCustom.java

@@ -103,7 +103,7 @@ public class OrderRepositoryCustom {
     public SliceImpl<Order> findOrderHistory(Pageable pageable, Long userId) {
         List<Order> contents = queryFactory
                 .selectFrom(order)
-                .join(order.transaction).fetchJoin()
+                .leftJoin(order.transaction).fetchJoin()
                 .where(
                         order.userId.eq(userId)
                 )

order-service/src/main/java/com/justpickup/orderservice/domain/order/service/OrderService.java

@@ -10,10 +10,9 @@ import org.springframework.data.domain.SliceImpl;
 public interface OrderService {
     OrderMainDto findOrderMain(OrderSearchCondition condition, Long userId);
     Page<PrevOrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long userId);
-    SliceImpl<OrderDto> findOrderHistory(Pageable pageable, Long userId);
+    SliceImpl<OrderHistoryDto> findOrderHistory(Pageable pageable, Long userId);
     void addItemToBasket(OrderItemDto orderItemDto,Long storeId, Long userId);
     FetchOrderDto fetchOrder(Long userId);
     void saveOrder(Long userId);
-
     void modifyOrder(Long userId, OrderStatus orderStatus);
 }

order-service/src/main/java/com/justpickup/orderservice/domain/order/service/OrderServiceImpl.java

@@ -10,6 +10,7 @@ import com.justpickup.orderservice.domain.orderItem.dto.OrderItemDto;
 import com.justpickup.orderservice.domain.orderItem.entity.OrderItem;
 import com.justpickup.orderservice.domain.orderItemOption.entity.OrderItemOption;
 import com.justpickup.orderservice.global.client.store.GetItemsResponse;
+import com.justpickup.orderservice.global.client.store.GetStoreResponse;
 import com.justpickup.orderservice.global.client.store.StoreByUserIdResponse;
 import com.justpickup.orderservice.global.client.store.StoreClient;
 import com.justpickup.orderservice.global.client.user.GetCustomerResponse;
@@ -139,17 +140,45 @@ public class OrderServiceImpl implements OrderService {
     }
 
     @Override
-    public SliceImpl<OrderDto> findOrderHistory(Pageable pageable, Long userId) {
+    public SliceImpl<OrderHistoryDto> findOrderHistory(Pageable pageable, Long userId) {
         SliceImpl<Order> orderHistory = orderRepositoryCustom.findOrderHistory(pageable, userId);
 
-        List<OrderDto> contents = orderHistory.getContent()
+        List<OrderHistoryDto> orderHistoryDtoList = orderHistory.getContent()
                 .stream()
-                .map(OrderDto::createFullField)
+                .map(OrderHistoryDto::of)
                 .collect(toList());
 
-        // TODO: 2022/03/07 Feign Client 통신
+        Set<Long> storeIds = new HashSet<>();
+        Set<Long> itemIds = new HashSet<>();
+        for (OrderHistoryDto orderHistoryDto : orderHistoryDtoList) {
+            storeIds.add(orderHistoryDto.getStoreId());
+            for (OrderHistoryDto._OrderHistoryItem orderItem : orderHistoryDto.getOrderItems()) {
+                itemIds.add(orderItem.getItemId());
+            }
+        }
 
-        return new SliceImpl<>(contents, pageable, orderHistory.hasNext());
+        Map<Long, String> storeNameMap = this.getStoreNameMap(storeIds);
+        Map<Long, String> itemNameMap = this.getItemNameMap(itemIds);
+
+        for (OrderHistoryDto orderHistoryDto : orderHistoryDtoList) {
+            String userName = storeNameMap.get(orderHistoryDto.getStoreId());
+            orderHistoryDto.changeStoreName(userName);
+            for (OrderHistoryDto._OrderHistoryItem orderItem : orderHistoryDto.getOrderItems()) {
+                String itemName = itemNameMap.get(orderItem.getItemId());
+                orderItem.changeItemName(itemName);
+            }
+        }
+
+        return new SliceImpl<>(orderHistoryDtoList, pageable, orderHistory.hasNext());
+    }
+
+    private Map<Long, String> getStoreNameMap(Set<Long> storeIds) {
+        List<GetStoreResponse> storeResponses = storeClient.getStoreAllById(storeIds).getData();
+        Map<Long, String> storeMap = storeResponses.stream()
+                .collect(
+                        toMap(GetStoreResponse::getId, GetStoreResponse::getName)
+                );
+        return storeMap;
     }
 
     @Override

order-service/src/main/java/com/justpickup/orderservice/domain/order/web/OrderCustomerApiController.java

@@ -1,7 +1,7 @@
 package com.justpickup.orderservice.domain.order.web;
 
 import com.justpickup.orderservice.domain.order.dto.FetchOrderDto;
-import com.justpickup.orderservice.domain.order.dto.OrderDto;
+import com.justpickup.orderservice.domain.order.dto.OrderHistoryDto;
 import com.justpickup.orderservice.domain.order.entity.OrderStatus;
 import com.justpickup.orderservice.domain.order.service.OrderService;
 import com.justpickup.orderservice.domain.orderItem.dto.OrderItemDto;
@@ -36,7 +36,7 @@ public class OrderCustomerApiController {
                                                   @PageableDefault(page = 0, size = 3) Pageable pageable) {
         Long userId = Long.parseLong(userHeader);
 
-        SliceImpl<OrderDto> orderHistory = orderService.findOrderHistory(pageable, userId);
+        SliceImpl<OrderHistoryDto> orderHistory = orderService.findOrderHistory(pageable, userId);
 
         OrderHistoryResponse orderHistoryResponse =
                 new OrderHistoryResponse(orderHistory.getContent(), orderHistory.hasNext());
@@ -47,45 +47,45 @@ public class OrderCustomerApiController {
 
     @Data @NoArgsConstructor
     static class OrderHistoryResponse {
-        private List<_Order> orders;
+        private List<_OrderResponse> orders;
         private boolean hasNext;
 
-        public OrderHistoryResponse(List<OrderDto> orders, boolean hasNext) {
+        public OrderHistoryResponse(List<OrderHistoryDto> orders, boolean hasNext) {
-            this.orders = orders.stream().map(_Order::new).collect(Collectors.toList());
+            this.orders = orders.stream().map(_OrderResponse::new).collect(Collectors.toList());
             this.hasNext = hasNext;
         }
 
         @Data
-        static class _Order {
+        static class _OrderResponse {
             private Long orderId;
             private String orderTime;
             private OrderStatus orderStatus;
             private String storeName;
             private Long orderPrice;
-            private List<_OrderItem> orderItems;
+            private List<_OrderItemResponse> orderItems;
 
-            public _Order(OrderDto orderDto) {
+            public _OrderResponse(OrderHistoryDto orderHistoryDto) {
-                this.orderId = orderDto.getId();
+                this.orderId = orderHistoryDto.getId();
-                this.orderTime = orderDto.getOrderTime()
+                this.orderTime = orderHistoryDto.getOrderTime()
                         .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
-                this.orderStatus = orderDto.getOrderStatus();
+                this.orderStatus = orderHistoryDto.getOrderStatus();
-                this.storeName = orderDto.getStoreId().toString();
+                this.storeName = orderHistoryDto.getStoreName();
-                this.orderPrice = orderDto.getOrderPrice();
+                this.orderPrice = orderHistoryDto.getPrice();
-                this.orderItems = orderDto.getOrderItemDtoList()
+                this.orderItems = orderHistoryDto.getOrderItems()
                         .stream()
-                        .map(_OrderItem::new)
+                        .map(_OrderItemResponse::new)
                         .collect(Collectors.toList());
             }
         }
 
         @Data
-        static class _OrderItem {
+        static class _OrderItemResponse {
             private Long orderItemId;
             private String orderItemName;
 
-            public _OrderItem(OrderItemDto orderItemDto) {
+            public _OrderItemResponse(OrderHistoryDto._OrderHistoryItem orderHistoryItem) {
-                this.orderItemId = orderItemDto.getItemId();
+                this.orderItemId = orderHistoryItem.getItemId();
-                this.orderItemName = orderItemDto.getItemId().toString();
+                this.orderItemName = orderHistoryItem.getItemName();
             }
         }
     }
@@ -174,6 +174,4 @@ public class OrderCustomerApiController {
         return ResponseEntity.status(HttpStatus.CREATED).body(Result.createSuccessResult(null));
     }
 
-
-
 }

order-service/src/main/java/com/justpickup/orderservice/global/SqlCommandLineRunner.java

@@ -52,8 +52,8 @@ public class SqlCommandLineRunner implements CommandLineRunner {
         Long userCouponId = null;
 
         for (int i = 0; i <= 100; i++) {
-//            if (i % 2 == 0) userId = 2L;
+            if (i % 2 == 0) userId = 2L;
-//            else userId = 3L;
+            else userId = 3L;
 
             List<Order> orders = new ArrayList<>();
             _Store[] stores = objectMapper.readValue(storeJson, _Store[].class);

order-service/src/main/java/com/justpickup/orderservice/global/client/store/GetStoreResponse.java

@@ -0,0 +1,10 @@
+package com.justpickup.orderservice.global.client.store;
+
+import lombok.Data;
+
+@Data
+public class GetStoreResponse {
+    private Long id;
+    private String name;
+    private String phoneNumber;
+}

order-service/src/main/java/com/justpickup/orderservice/global/client/store/StoreClient.java

@@ -19,4 +19,7 @@ public interface StoreClient {
 
     @GetMapping("/api/owner/store/")
     Result<StoreByUserIdResponse> getStoreByUserId(@RequestHeader(value="user-id") Long userId);
+
+    @GetMapping("/stores/{storeId}")
+    Result<List<GetStoreResponse>> getStoreAllById(@PathVariable("storeId") Iterable<Long> storeIds);
 }