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

- 아이템 id와 유저 id들을 Set으로 묶어 한번에 통신하게 변경 - Map을 사용하여 id를 key로 map을 name으로 가지게 생성
2022-03-15 18:57:55 +09:00
parent 4a874da830
commit e562d9d2b3
6 changed files with 144 additions and 55 deletions
--- a/order-service/src/main/java/com/justpickup/orderservice/domain/order/dto/PrevOrderDto.java
+++ b/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;
+    }
+
+}
--- a/order-service/src/main/java/com/justpickup/orderservice/domain/order/repository/OrderRepositoryCustom.java
+++ b/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)
--- a/order-service/src/main/java/com/justpickup/orderservice/domain/order/service/OrderService.java
+++ b/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.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.dto.*;
 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);
--- a/order-service/src/main/java/com/justpickup/orderservice/domain/order/service/OrderServiceImpl.java
+++ b/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;
-        List<GetItemsResponse> itemResponses = storeClient.getItems(itemIds).getData();
-        Map<Long, String> itemNameMap = itemResponses.stream()
-                .collect(
-                        toMap(GetItemsResponse::getId, GetItemsResponse::getName)
-                );
+        Map<Long, String> itemNameMap = getItemNameMap(itemIds);

        // user name 가져오기
-        count += 1;
-        List<GetCustomerResponse> userResponses = userClient.getCustomers(userIds).getData();
-        Map<Long, String> userNameMap = userResponses.stream()
-                .collect(
-                        toMap(GetCustomerResponse::getUserId, GetCustomerResponse::getUserName)
-                );
+        Map<Long, String> userNameMap = getUserNameMap(userIds);

        // 해당 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
-    public Page<OrderDto> findPrevOrderMain(PrevOrderSearch search, Pageable pageable, Long storeId) {
-        Page<Order> orderPage = orderRepositoryCustom.findPrevOrderMain(search, pageable, storeId);
+    private Map<Long, String> getUserNameMap(Iterable<Long> userIds) {
+        List<GetCustomerResponse> userResponses = userClient.getCustomers(userIds).getData();
+        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
--- a/order-service/src/main/java/com/justpickup/orderservice/domain/order/web/OrderOwnerApiController.java
+++ b/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) {
-            orders = orderDtoList.stream().map(OrderVo::new).collect(toList());
+        public ResponsePrevOrder(List<PrevOrderDto> orderDtoList, int startPage, int totalPage) {
+            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) {
-                this.orderId = orderDto.getId();
-                this.orderStatus = orderDto.getOrderStatus();
-                this.orderTime = orderDto.getOrderTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
-                this.orderPrice = orderDto.getOrderPrice();
-                this.userName = orderDto.getUserName();
-                this.orderItems = orderDto.getOrderItemDtoList()
-                        .stream().map(OrderItemVo::new).collect(toList());
+            public _Order(PrevOrderDto prevOrderDto) {
+                this.orderId = prevOrderDto.getId();
+                this.orderStatus = prevOrderDto.getOrderStatus();
+                this.orderTime = prevOrderDto.getOrderTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+                this.orderPrice = prevOrderDto.getOrderPrice();
+                this.userName = prevOrderDto.getUserName();
+                this.orderItems = prevOrderDto.getOrderItems()
+                        .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();
            }
        }

--- a/order-service/src/main/java/com/justpickup/orderservice/global/client/store/StoreClient.java
+++ b/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);
-
 }