feat(order): 점주 서비스 지난 주문 Feign 클라이언트 로직 추가

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

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

@@ -0,0 +1,69 @@
+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;
+
+import static java.util.stream.Collectors.toList;
+
+@Getter
+@NoArgsConstructor(access = AccessLevel.PROTECTED)
+public class PrevOrderDto {
+    private Long id;
+    private OrderStatus orderStatus;
+    private LocalDateTime orderTime;
+    private long orderPrice;
+    private Long userId;
+    private String userName;
+
+    private List<_PrevOrderItem> orderItems = new ArrayList<>();
+
+    @Getter
+    public static class _PrevOrderItem {
+        private Long id;
+        private Long itemId;
+        private String name;
+
+        // 생성 메소드
+        static _PrevOrderItem of(OrderItem orderItem) {
+            _PrevOrderItem prevOrderItem = new _PrevOrderItem();
+            prevOrderItem.id = orderItem.getId();
+            prevOrderItem.itemId = orderItem.getItemId();
+            return prevOrderItem;
+        }
+
+        public void changeName(String name) {
+            this.name = name;
+        }
+    }
+
+    // 생성 메소드
+    public static PrevOrderDto of(Order order) {
+        PrevOrderDto prevOrder = new PrevOrderDto();
+        prevOrder.id = order.getId();
+        prevOrder.orderStatus = order.getOrderStatus();
+        prevOrder.orderTime = order.getOrderTime();
+        prevOrder.orderPrice = order.getOrderPrice();
+        prevOrder.userId = order.getUserId();
+
+        prevOrder.orderItems = order.getOrderItems()
+                .stream()
+                .map(_PrevOrderItem::of)
+                .collect(toList());
+
+        return prevOrder;
+    }
+
+    public void changeUserName(String userName) {
+        this.userName = userName;
+    }
+
+}

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

@@ -44,7 +44,7 @@ public class OrderRepositoryCustom {
 
         List<Order> orders = queryFactory
                 .selectFrom(order)
-                .leftJoin(order.transaction).fetchJoin()
+                .leftJoin(order.transaction)
                 .where(
                         orderIdLt(condition.getLastOrderId()),
                         order.orderTime.between(start, end),
@@ -75,7 +75,7 @@ public class OrderRepositoryCustom {
         Long count = queryFactory
                 .select(order.countDistinct())
                 .from(order)
-                .innerJoin(order.transaction)
+                .leftJoin(order.transaction)
                 .where(
                         order.orderTime.between(search.getStartDateTime(), search.getEndDateTime()),
                         order.storeId.eq(storeId)
@@ -85,7 +85,7 @@ public class OrderRepositoryCustom {
         // 데이터 가져오기
         List<Order> orders = queryFactory
                 .selectFrom(order)
-                .join(order.transaction).fetchJoin()
+                .leftJoin(order.transaction).fetchJoin()
                 .where(
                         order.orderTime.between(search.getStartDateTime(), search.getEndDateTime()),
                         order.storeId.eq(storeId)

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

@@ -1,10 +1,6 @@
 package com.justpickup.orderservice.domain.order.service;
 
-import com.justpickup.orderservice.domain.order.dto.FetchOrderDto;
+import com.justpickup.orderservice.domain.order.dto.*;
-import com.justpickup.orderservice.domain.order.dto.OrderDto;
-import com.justpickup.orderservice.domain.order.dto.OrderMainDto;
-import com.justpickup.orderservice.domain.order.dto.OrderSearchCondition;
-import com.justpickup.orderservice.domain.order.dto.PrevOrderSearch;
 import com.justpickup.orderservice.domain.order.entity.OrderStatus;
 import com.justpickup.orderservice.domain.orderItem.dto.OrderItemDto;
 import org.springframework.data.domain.Page;
@@ -13,7 +9,7 @@ import org.springframework.data.domain.SliceImpl;
 
 public interface OrderService {
     OrderMainDto findOrderMain(OrderSearchCondition condition, Long userId);
-    Page<OrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long storeId);
+    Page<PrevOrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long userId);
     SliceImpl<OrderDto> findOrderHistory(Pageable pageable, Long userId);
     void addItemToBasket(OrderItemDto orderItemDto,Long storeId, Long userId);
     FetchOrderDto fetchOrder(Long userId);

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

@@ -22,7 +22,6 @@ import org.springframework.data.domain.SliceImpl;
 import org.springframework.data.support.PageableExecutionUtils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
-import org.springframework.util.StopWatch;
 
 import java.util.*;
 
@@ -49,9 +48,6 @@ public class OrderServiceImpl implements OrderService {
         // 주문 가져오기
         OrderMainResult orderMainResult = orderRepositoryCustom.findOrderMain(condition, storeResponse.getId());
 
-        StopWatch stopWatch = new StopWatch();
-        stopWatch.start();
-        int count = 0;
         // 사용자 고유번호 및 아이템 고유번호 필터링
         Set<Long> userIds = new HashSet<>();
         Set<Long> itemIds = new HashSet<>();
@@ -68,20 +64,10 @@ public class OrderServiceImpl implements OrderService {
         }
 
         // item name 가져오기
-        count += 1;
+        Map<Long, String> itemNameMap = getItemNameMap(itemIds);
-        List<GetItemsResponse> itemResponses = storeClient.getItems(itemIds).getData();
-        Map<Long, String> itemNameMap = itemResponses.stream()
-                .collect(
-                        toMap(GetItemsResponse::getId, GetItemsResponse::getName)
-                );
 
         // user name 가져오기
-        count += 1;
+        Map<Long, String> userNameMap = getUserNameMap(userIds);
-        List<GetCustomerResponse> userResponses = userClient.getCustomers(userIds).getData();
-        Map<Long, String> userNameMap = userResponses.stream()
-                .collect(
-                        toMap(GetCustomerResponse::getUserId, GetCustomerResponse::getUserName)
-                );
 
         // 해당 ID에 맞게 이름 설정해주기
         for (OrderMainDto._Order order : orders) {
@@ -92,26 +78,64 @@ public class OrderServiceImpl implements OrderService {
                 orderItem.changeItemName(itemName);
             }
         }
-        stopWatch.stop();
-        log.info("order count = {}, Feign count = {}, [StopWatch] {}",
-                returnDto.getOrders().size(), count, stopWatch.prettyPrint());
 
         return returnDto;
     }
 
-    @Override
+    private Map<Long, String> getUserNameMap(Iterable<Long> userIds) {
-    public Page<OrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long storeId) {
+        List<GetCustomerResponse> userResponses = userClient.getCustomers(userIds).getData();
-        Page<Order> orderPage = orderRepositoryCustom.findPrevOrderMain(search, pageable, storeId);
+        return userResponses.stream()
+                .collect(
+                        toMap(GetCustomerResponse::getUserId, GetCustomerResponse::getUserName)
+                );
+    }
 
-        List<OrderDto> orderDtoList = orderPage.getContent()
+    private Map<Long, String> getItemNameMap(Iterable<Long> itemIds) {
+        List<GetItemsResponse> itemResponses = storeClient.getItems(itemIds).getData();
+        return itemResponses.stream()
+                .collect(
+                        toMap(GetItemsResponse::getId, GetItemsResponse::getName)
+                );
+    }
+
+    @Override
+    public Page<PrevOrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long userId) {
+        StoreByUserIdResponse store = storeClient.getStoreByUserId(userId).getData();
+
+        Page<Order> orderPage = orderRepositoryCustom.findPrevOrderMain(search, pageable, store.getId());
+
+        List<PrevOrderDto> prevOrderDtoList = orderPage.getContent()
                 .stream()
-                .map(OrderDto::createFullField)
+                .map(PrevOrderDto::of)
                 .collect(toList());
 
         // 사용자명 및 아이템 이름 가져오기
-//        getUserNameAndItemName(orderDtoList);
+        Set<Long> userIds = new HashSet<>();
+        Set<Long> itemIds = new HashSet<>();
 
-        return PageableExecutionUtils.getPage(orderDtoList, pageable, orderPage::getTotalElements);
+        for (PrevOrderDto prevOrderDto : prevOrderDtoList) {
+            userIds.add(prevOrderDto.getUserId());
+            for (PrevOrderDto._PrevOrderItem orderItem : prevOrderDto.getOrderItems()) {
+                itemIds.add(orderItem.getItemId());
+            }
+        }
+
+        // item name 가져오기
+        Map<Long, String> itemNameMap = getItemNameMap(itemIds);
+
+        // user name 가져오기
+        Map<Long, String> userNameMap = getUserNameMap(userIds);
+
+        for (PrevOrderDto prevOrderDto : prevOrderDtoList) {
+            String userName = userNameMap.get(prevOrderDto.getUserId());
+            prevOrderDto.changeUserName(userName);
+            for (PrevOrderDto._PrevOrderItem orderItem : prevOrderDto.getOrderItems()) {
+                String itemName = itemNameMap.get(orderItem.getItemId());
+                orderItem.changeName(itemName);
+            }
+        }
+
+        return PageableExecutionUtils.getPage(prevOrderDtoList, pageable, orderPage::getTotalElements);
     }
 
     @Override

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

@@ -1,13 +1,12 @@
 package com.justpickup.orderservice.domain.order.web;
 
-import com.justpickup.orderservice.domain.order.dto.OrderDto;
 import com.justpickup.orderservice.domain.order.dto.OrderMainDto;
 import com.justpickup.orderservice.domain.order.dto.OrderSearchCondition;
+import com.justpickup.orderservice.domain.order.dto.PrevOrderDto;
 import com.justpickup.orderservice.domain.order.dto.PrevOrderSearch;
 import com.justpickup.orderservice.domain.order.entity.OrderStatus;
 import com.justpickup.orderservice.domain.order.service.OrderService;
 import com.justpickup.orderservice.domain.order.validator.PrevOrderSearchValidator;
-import com.justpickup.orderservice.domain.orderItem.dto.OrderItemDto;
 import com.justpickup.orderservice.global.dto.Result;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -101,6 +100,7 @@ public class OrderOwnerApiController {
     @GetMapping("/prev-order")
     public ResponseEntity<Result> findPrevOrder(@Valid PrevOrderSearch prevOrderSearch,
                                                 @PageableDefault(page = 0, size = 10) Pageable pageable,
+                                                @RequestHeader(value="user-id") String userHeader,
                                                 BindingResult bindingResult) throws BindException {
         // validation
         if (bindingResult.hasErrors()) throw new BindException(bindingResult);
@@ -108,7 +108,8 @@ public class OrderOwnerApiController {
         if (bindingResult.hasErrors()) throw new BindException(bindingResult);
 
         // get data
-        Page<OrderDto> prevOrderMain = orderService.findPrevOrderMain(prevOrderSearch, pageable, 1L);
+        Long userId = Long.valueOf(userHeader);
+        Page<PrevOrderDto> prevOrderMain = orderService.findPrevOrderMain(prevOrderSearch, pageable, userId);
 
         // format data
         ResponsePrevOrder responsePrevOrder =
@@ -118,42 +119,42 @@ public class OrderOwnerApiController {
 
     @Data @AllArgsConstructor @NoArgsConstructor
     static class ResponsePrevOrder {
-        private List<OrderVo> orders;
+        private List<_Order> orders;
         private Page page;
 
-        public ResponsePrevOrder(List<OrderDto> orderDtoList, int startPage, int totalPage) {
+        public ResponsePrevOrder(List<PrevOrderDto> orderDtoList, int startPage, int totalPage) {
-            orders = orderDtoList.stream().map(OrderVo::new).collect(toList());
+            orders = orderDtoList.stream().map(_Order::new).collect(toList());
             page = new Page(startPage, totalPage);
         }
 
         @Data
-        static class OrderVo {
+        static class _Order {
             private Long orderId;
             private OrderStatus orderStatus;
             private String orderTime;
             private Long orderPrice;
             private String userName;
-            private List<OrderItemVo> orderItems;
+            private List<_OrderItem> orderItems;
 
-            public OrderVo(OrderDto orderDto) {
+            public _Order(PrevOrderDto prevOrderDto) {
-                this.orderId = orderDto.getId();
+                this.orderId = prevOrderDto.getId();
-                this.orderStatus = orderDto.getOrderStatus();
+                this.orderStatus = prevOrderDto.getOrderStatus();
-                this.orderTime = orderDto.getOrderTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+                this.orderTime = prevOrderDto.getOrderTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
-                this.orderPrice = orderDto.getOrderPrice();
+                this.orderPrice = prevOrderDto.getOrderPrice();
-                this.userName = orderDto.getUserName();
+                this.userName = prevOrderDto.getUserName();
-                this.orderItems = orderDto.getOrderItemDtoList()
+                this.orderItems = prevOrderDto.getOrderItems()
-                        .stream().map(OrderItemVo::new).collect(toList());
+                        .stream().map(_OrderItem::new).collect(toList());
             }
         }
 
         @Data
-        static class OrderItemVo {
+        static class _OrderItem {
             private Long orderItemId;
             private String orderItemName;
 
-            public OrderItemVo(OrderItemDto orderItemDto) {
+            public _OrderItem(PrevOrderDto._PrevOrderItem orderItemDto) {
                 this.orderItemId = orderItemDto.getId();
-                this.orderItemName = orderItemDto.getItemName();
+                this.orderItemName = orderItemDto.getName();
             }
         }
 

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

@@ -19,5 +19,4 @@ public interface StoreClient {
 
     @GetMapping("/api/owner/store/")
     Result<StoreByUserIdResponse> getStoreByUserId(@RequestHeader(value="user-id") Long userId);
-
 }