정산지기를 향한 첫걸음 (feat. 파일럿 프로젝트)

@RequiredArgsConstructor
@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final OwnerRepository ownerRepository;

    // (1)
    public long save(final OrderSaveRequest orderSaveRequest) {
        Order order = generateOrdersBy(orderSaveRequest);

        List<OrderDetailRequest> orderDetailRequests = orderSaveRequest.getOrderDetailRequests();
        orderDetailRequests.forEach(orderDetailRequest -> registerOrderDetailInOrders(order, orderDetailRequest));

        Order savedOrder = orderRepository.save(order);
        return savedOrder.getId();
    }
    
    // (2)
    private Order generateOrdersBy(final OrderSaveRequest orderSaveRequest) {
        Long ownerId = orderSaveRequest.getOwnerId();
        Owner owner = EntityServiceUtil.findById(ownerRepository, ownerId);

        LocalDateTime occurrenceDateTime = orderSaveRequest.getOccurrenceDateTime();
        return Order.builder()
                .occurrenceDateTime(occurrenceDateTime)
                .owner(owner)
                .build();
    }

    // (2)
    private void registerOrderDetailInOrders(final Order order, final OrderDetailRequest orderDetailRequest) {
        PaymentMethod paymentMethod = orderDetailRequest.getPaymentMethod();
        long amount = orderDetailRequest.getAmount();

        OrderDetail orderDetail = generateOrderDetail(order, paymentMethod, amount);
        order.addOrderDetail(orderDetail);
    }
    
    // (2)
    private OrderDetail generateOrderDetail(final Order order, final PaymentMethod paymentMethod, final long amount) {
        return OrderDetail.builder()
                .paymentMethod(paymentMethod)
                .amount(amount)
                .order(order)
                .build();
    }
    
    // ... 생략
}

    // ... 생략

    @Transactional(readOnly = true)
    public OrderResponse findById(final long id) {
        Order order = findOrderById(id);

        return new OrderResponse(order);
    }

    // (3)
    private Order findOrderById(final long id) {
        return orderRepository.findOrderByIdWithDetails(id)
                .orElseThrow(EntityNotFoundException::new);
    }

    // ... 생략

    // ... 생략

    @Transactional(readOnly = true)
    public List<OrderResponse> searchByOccurrenceDateTimeAndOwnerId(final OrderSearchRequest orderSearchRequest) {
        // (4)
        PageRequest pageRequest = PageRequest.of(orderSearchRequest.getPage(), orderSearchRequest.getSize());
        Page<Order> orders = orderRepository.findByOwnerIdAndOccurrenceDateTimeBetweenOrderByIdDesc(orderSearchRequest.getOwnerId(),
                orderSearchRequest.getStartDateTime(), orderSearchRequest.getEndDateTime(), pageRequest);

        return transferOrdersToResponses(orders);
    }
    
    @Transactional(readOnly = true)
    public long countByOccurrenceDateTimeAndOwnerId(final OrderCountRequest orderCountRequest) {
        return orderRepository.countByOwnerIdAndOccurrenceDateTimeBetween(orderCountRequest.getOwnerId(),
                orderCountRequest.getStartDateTime(), orderCountRequest.getEndDateTime());
    }
    
    @Transactional(readOnly = true)
    public long countAll() {
        return orderRepository.count();
    }

    // ... 생략
}

public interface OrderRepository extends JpaRepository<Order, Long> {

    @Query("SELECT DISTINCT o FROM Order o JOIN FETCH o.orderDetails.details WHERE o.owner.id = :ownerId" +
     " AND o.occurrenceDateTime BETWEEN :startDateTime AND :endDateTime ORDER BY o.id DESC")
    List<Order> findByOwnerIdAndOccurrenceDateTimeBetweenOrderByIdDesc(@Param("ownerId") long ownerId, 
            @Param("startDateTime") LocalDateTime startDateTime, @Param("endDateTime") LocalDateTime endDateTime);

    @Query(value = "SELECT DISTINCT o FROM Order o JOIN FETCH o.orderDetails.details WHERE o.owner.id = :ownerId" +
     " AND o.occurrenceDateTime BETWEEN :startDateTime AND :endDateTime ORDER BY o.id DESC"
            , countQuery = "SELECT COUNT(o) FROM Order o") // (4)
    Page<Order> findByOwnerIdAndOccurrenceDateTimeBetweenOrderByIdDesc(@Param("ownerId") long ownerId, 
            @Param("startDateTime") LocalDateTime startDateTime, @Param("endDateTime") LocalDateTime endDateTime, Pageable pageable);

    long countByOwnerIdAndOccurrenceDateTimeBetween(long ownerId, LocalDateTime startDateTime, LocalDateTime endDateTime);
}

@RequiredArgsConstructor
@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final OwnerRepository ownerRepository;

    @Transactional
    public long save(OrderSaveRequest orderSaveRequest) {
        String ownerKey = orderSaveRequest.getOwnerKey();
        Owner owner = ownerRepository.findByOwnerKey(ownerKey)
                .orElseThrow(OwnerNotFoundException::new);

        Order order = orderSaveRequest.toEntity(owner);

        Order savedOrder = orderRepository.save(order);
        savedOrder.generateKeyWithId();
        return savedOrder.getId();
    }

    @Transactional(readOnly = true)
    public OrderResponse findById(long id) {
        Order order = findOrderById(id);

        return new OrderResponse(order);
    }

    @Transactional(readOnly = true)
    public OrderSearchResponse search(OrderSearchRequest orderSearchRequest) {
        OrderSearchCondition condition = generateSearchConditionFrom(orderSearchRequest);
        int offset = orderSearchRequest.getOffset();
        int limit = orderSearchRequest.getLimit();

        List<Order> orders = orderRepository.findOrdersWithCondition(condition, offset, limit);

        Long totalCount = fetchTotalCount(orderSearchRequest.getTotalCount(), condition);

        return new OrderSearchResponse(orders, totalCount);
    }

    Long fetchTotalCount(Long totalCount, OrderSearchCondition condition) {
        if (totalCount == null) {
            totalCount = orderRepository.countWithCondition(condition);
        }
        return totalCount;
    }

    // ... 생략
}

    @Test
    public void totalCount가_있는_경우_count_쿼리를_날리지_않는다() {
        OrderSearchCondition condition = OrderSearchCondition.builder().build();
        when(mockOrderRepository.countWithCondition(condition)).thenReturn(1L);

        Long totalCount = mockOrderService.fetchTotalCount(10L, condition);

        verify(mockOrderRepository, times(0)).countWithCondition(condition);
        assertThat(totalCount).isEqualTo(10L);
    }

    @Test
    public void totalCount가_없는_경우_count_쿼리를_날린다() {
        OrderSearchCondition condition = OrderSearchCondition.builder().build();
        when(mockOrderRepository.countWithCondition(condition)).thenReturn(1L);

        Long totalCount = mockOrderService.fetchTotalCount(null, condition);

        verify(mockOrderRepository, times(1)).countWithCondition(condition);
        assertThat(totalCount).isEqualTo(1L);
    }

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private static final List<String> LOGIN_EXCLUDE_PATH_PATTERNS = Arrays.asList("/api/v1/login/**", "/api/v1/sign-up/**",
            "/api/v1/logout");
    // (1)
    private static final List<String> ADMIN_ROLE_EXCLUDE_PATH_PATTERNS = Arrays.asList("/api/v1/owners/search/**",
            "/api/v1/owners/count/**", "/api/v1/orders/search/**", "/api/v1/orders/count/**",
            "/api/v1/correction-amounts/search/**", "/api/v1/correction-amounts/count/**", "/api/v1/payouts");

    @Value("${resources.exclude.list}")
    private List<String> basicExcludePathPatterns;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns(basicExcludePathPatterns)
                .excludePathPatterns(LOGIN_EXCLUDE_PATH_PATTERNS);

        registry.addInterceptor(new AdminRoleInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns(basicExcludePathPatterns)
                .excludePathPatterns(LOGIN_EXCLUDE_PATH_PATTERNS)
                .excludePathPatterns(ADMIN_ROLE_EXCLUDE_PATH_PATTERNS);
    }

    // ... 생략
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    private static final List<String> LOGIN_EXCLUDE_PATH_PATTERNS = Arrays.asList("/api/v1/login/**", "/api/v1/sign-up/**",
            "/api/v1/logout");

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/", "/index.html", "/css/**", "/fonts/**", "https://woowabros.github.io/img/**", "/js/**")
                .excludePathPatterns(LOGIN_EXCLUDE_PATH_PATTERNS);

        registry.addInterceptor(new AdminRoleInterceptor())
                .addPathPatterns("/api/v1/owners/**", "/api/v1/orders/**", "/api/v1/correction-amounts/**", "/api/v1/payouts/**", 
            "/api/v1/search/**");
    }

    // ... 생략
}

public class AdminRoleInterceptor extends HandlerInterceptorAdapter {

    public static final String ALLOWED_HTTP_METHOD = "GET";

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        HttpSession session = request.getSession();
        SessionUser sessionUser = (SessionUser) session.getAttribute(SESSION_USER);
        if (sessionUser == null) {
            return false;
        }

        if (Role.ADMIN.equals(sessionUser.getRole())) {
            return true;
        }

        String httpMethod = request.getMethod();
        return isAllowedHttpMethod(httpMethod);
    }

    private boolean isAllowedHttpMethod(String httpMethod) {
        return ALLOWED_HTTP_METHOD.equals(httpMethod);
    }
}

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Where(clause = "deleted = 0")
@Entity
@Table(name = "order_table", indexes = { // (1)
        @Index(name = "idx_owner_occurrenceDate", columnList = "owner_id, occurrenceDate") 
})
public class Order extends BaseEntity {

    @Embedded
    private OrderKey orderKey;

    @Column(nullable = false)
    private LocalDate occurrenceDate; // (2)

    @Column(nullable = false)
    private LocalTime occurrenceTime; // (2)

    // List<OrderDetail>을 가지고 있는 @Embeddable 일급컬렉션
    private OrderDetails orderDetails = new OrderDetails(); 

    @ManyToOne(fetch = FetchType.LAZY)
    private Owner owner;

    @Column(nullable = false)
    private boolean canceled = false;

    @Column(nullable = false)
    private long amount;

    // ... 생략

    @Builder // (3)
    public Order(final LocalDate occurrenceDate, final LocalTime occurrenceTime, final Owner owner, final boolean canceled, final long amount) {
        this.occurrenceDate = occurrenceDate;
        this.occurrenceTime = occurrenceTime;
        this.owner = owner;
        this.canceled = canceled;
        this.amount = amount;
    }
    
    // (4)
    public void generateKeyWith(final long orderSequence) {
        this.orderKey = OrderKey.of(occurrenceDate, orderSequence); // (5)
    }

    @Override
    public void softDelete() {
        super.softDelete();
        orderDetails.softDelete();
    }

    // ... 생략
}

@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Where(clause = "deleted = 0")
@Entity
@Table(name = "order_table", indexes = {
        @Index(name = "idx_owner", columnList = "owner_id"),
        @Index(name = "idx_occurrenceDate", columnList = "occurrenceDate")
})
public class Order extends BaseEntity {

    @Embedded
    private OrderKey orderKey;

    @Column(nullable = false)
    private LocalDateTime occurrenceDateTime;

    @Column(nullable = false)
    private LocalDate occurrenceDate;

    private OrderDetails orderDetails = new OrderDetails();

    @ManyToOne(fetch = FetchType.LAZY)
    private Owner owner;

    @Column(nullable = false)
    private boolean canceled = false;

    @Column(nullable = false)
    private long amount;

    @Builder
    public Order(LocalDateTime occurrenceDateTime, Owner owner, boolean canceled, long amount) {
        this.occurrenceDateTime = occurrenceDateTime;
        this.occurrenceDate = occurrenceDateTime.toLocalDate();
        this.owner = owner;
        this.canceled = canceled;
        this.amount = amount;
    }

    public void generateKeyWithId() {
        this.orderKey = new OrderKey(this.occurrenceDate, this.getId());
    }

    @Override
    public void softDelete() {
        super.softDelete();
        orderDetails.softDelete();
    }

    // ... 생략
}

@RequiredArgsConstructor
public class OrderRepositoryImpl implements OrderRepositoryCustom {

    private final JPAQueryFactory queryFactory;

    @Override
    public List<Order> findUncanceledOrdersWith(LocalDateTime startDateTime, LocalDateTime endDateTime, Owner foundOwner) {
        if (isEmptyOneOf(startDateTime, endDateTime, foundOwner)) {
            throw new LackQueryConditionException();
        }

        return queryFactory
                .selectDistinct(order)
                .from(order)
                .join(order.orderDetails.details, orderDetail).fetchJoin()
                .join(order.owner, owner).fetchJoin()
                .where(occurrenceDateTimeBetween(startDateTime, endDateTime),
                        owner.eq(foundOwner),
                        order.canceled.isFalse())
                .orderBy(order.id.desc())
                .fetch();
    }

    @Override
    public List<Order> findOrdersWithCondition(OrderSearchCondition condition, int offset, int limit) {
        return queryFactory
                .selectDistinct(order)
                .from(order)
                .join(order.orderDetails.details, orderDetail).fetchJoin()
                .join(order.owner, owner).fetchJoin()
                .where(occurrenceDateTimeBetween(condition.getStartDateTime(), condition.getEndDateTime()),
                        ownerKeyEq(condition.getOwnerKey()))
                .offset(offset)
                .limit(limit)
                .orderBy(order.id.desc())
                .fetch();
    }

    @Override
    public Long countWithCondition(OrderSearchCondition condition) {
        return queryFactory
                .selectFrom(order)
                .where(occurrenceDateTimeBetween(condition.getStartDateTime(), condition.getEndDateTime()),
                        ownerKeyEq(condition.getOwnerKey()))
                .fetchCount();
    }

    private boolean isEmptyOneOf(LocalDateTime startDateTime, LocalDateTime endDateTime, Owner owner) {
        return isEmpty(startDateTime) || isEmpty(endDateTime) || isEmpty(owner);
    }

    private BooleanExpression occurrenceDateTimeBetween(LocalDateTime startDateTime, LocalDateTime endDateTime) {
        return (startDateTime != null && endDateTime != null)
                ? order.occurrenceDateTime.between(startDateTime, endDateTime)
                : null;
    }

    private BooleanExpression ownerKeyEq(String ownerKey) {
        return hasText(ownerKey) ? order.owner.ownerKey.value.eq(ownerKey) : null;
    }
}

@Ignore
@RunWith(SpringRunner.class)
@Transactional
@SpringBootTest
public class EntityServiceTest {
    // ... 생략
}

@Ignore
@RunWith(SpringRunner.class)
@Import(QuerydslConfig.class)
@DataJpaTest
public class EntityRepositoryTest {
    // ... 생략
}

public class OrderServiceTest extends EntityServiceTest { // @Transactional 제거한 EntityServiceTest

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private OrderDetailRepository orderDetailRepository;

    @Autowired
    private OwnerRepository ownerRepository;

    @Before
    public void setUp() {
        // 생략
    }

    @After
    public void tearDown() {
        orderDetailRepository.deleteAllInBatch();
        orderRepository.deleteAllInBatch();
        ownerRepository.deleteAllInBatch();
    }

    // ... 생략

@Slf4j
@RequiredArgsConstructor
@Configuration
public class PayoutCreationJobConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;
    private final EntityManagerFactory entityManagerFactory;
    private final PayoutCollector payoutCollector;
    private final PayoutCoreRepository payoutCoreRepository;

    // (1)
    private int chunkSize = 10;

    @Bean
    public Job payoutCreationJob() {
        return jobBuilderFactory.get("payoutCreationJob")
                .start(validateParameters(null, null))
                .next(registerOrderDetailAmountsStep(null, null))
                .next(registerCorrectionAmountAmountsStep(null, null))
                .next(saveAllPayoutsStep())
                .next(clearPayoutCollector())
                .build();
    }

    // validateParameters 로직 생략

    /**
     * OrderDetail을 기준으로 각 Owner의 (지급금용) 주문 합계 금액을 가져온다.
     * PayoutCollector Bean에 등록한다.
     */
    @Bean
    @JobScope
    public Step registerOrderDetailAmountsStep(@Value("#{jobParameters[startPayoutDate]}") String startPayoutDate,
                                               @Value("#{jobParameters[endPayoutDate]}") String endPayoutDate) {
        return stepBuilderFactory.get("registerOrderDetailAmountsStep")
                .<PayoutSubTotal, PayoutSubTotal>chunk(chunkSize)
                .reader(payoutByOrdersReader(startPayoutDate, endPayoutDate))
                .processor(payoutRegistrationOnCollectorProcessor())
                .writer(customNoOperationItemWriter())
                .build();
    }

    @Bean
    @StepScope
    public QuerydslPagingItemReader<PayoutSubTotal> payoutByOrdersReader(@Value("#{jobParameters[startPayoutDate]}") String startPayoutDate,
                                                                         @Value("#{jobParameters[endPayoutDate]}") String endPayoutDate) {
        LocalDate startDate = LocalDateFormatter.toLocalDate(startPayoutDate);
        LocalDate endDate = LocalDateFormatter.toLocalDate(endPayoutDate);

        log.info("startDate = {}", startDate);
        log.info("endDate = {}", endDate);

        List<PaymentMethod> paymentMethods = PaymentMethod.getPaymentMethodsIncludedInPayout();

        return new QuerydslPagingItemReader<>(entityManagerFactory, chunkSize, queryFactory -> queryFactory
                .select(Projections.fields(PayoutSubTotal.class,
                        order.occurrenceDate.as("payoutDate"),
                        owner.as("owner"),
                        orderDetail.amount.sum().as("totalAmount")
                ))
                .from(orderDetail)
                .join(orderDetail.order, order)
                .join(order.owner, owner)
                .where(order.occurrenceDate.between(startDate, endDate),
                        orderDetail.paymentMethod.in(paymentMethods),
                        order.canceled.isFalse())
                .groupBy(owner, order.occurrenceDate)
                .orderBy(owner.id.asc())
        );
    }

    // (2)
    @Bean
    @StepScope
    public ItemProcessor<PayoutSubTotal, PayoutSubTotal> payoutRegistrationOnCollectorProcessor() {
        return payoutSubTotal -> {
            log.info("payoutSubTotal : {}", payoutSubTotal);

            payoutCollector.register(payoutSubTotal);
            return payoutSubTotal;
        };
    }
    
    // (2)
    @Bean
    @StepScope
    public ItemWriter<PayoutSubTotal> customNoOperationItemWriter() {
        return items -> {
        };
    }

    /**
     * CorrectionAmount를 기준으로 각 Owner의 (지급금용) 주문 합계 금액을 가져온다.
     * PayoutCollector Bean에 등록한다.
     */
    // registerCorrectionAmountAmountsStep 생략

    /**
     * PayoutCollector에서 모든 지급금을 만들어와서 repository에 저장한다.
     */
    // saveAllPayoutsStep 생략

    // ... 생략

    // (3)
    @Bean
    @JobScope
    public Step clearPayoutCollector() {
        return stepBuilderFactory.get("clearPayoutCollector")
                .tasklet((contribution, chunkContext) -> {
                    payoutCollector.clear();

                    return RepeatStatus.FINISHED;
                })
                .build();
    }

    @Component // (3)
    public static class PayoutCollector {
        // 주문 상세 정보와 보정 금액 정보를 계산하여 지급금을 생성하는 
        // 임시 Batch 전용 Bean
    }
}

@Slf4j
@RequiredArgsConstructor
@Configuration
public class PayoutCreationJobConfiguration {

    private final JobBuilderFactory jobBuilderFactory;
    private final StepBuilderFactory stepBuilderFactory;
    private final EntityManagerFactory entityManagerFactory;
    private final PayoutCollector payoutCollector;
    private final PayoutCoreRepository payoutCoreRepository;

    @Value("${chunkSize:1000}")
    private int chunkSize;

    @Bean
    public Job payoutCreationJob() {
        return jobBuilderFactory.get("payoutCreationJob")
                .start(validateParameters(null, null))
                .next(registerOrderDetailAmountsStep(null, null))
                .next(registerCorrectionAmountAmountsStep(null, null))
                .next(saveAllPayoutsStep())
                .build();
    }

    // validateParameters 로직 생략

    /**
     * OrderDetail을 기준으로 각 Owner의 (지급금용) 주문 합계 금액을 가져온다.
     * PayoutCollector Bean에 등록한다.
     */
    @Bean
    @JobScope
    public Step registerOrderDetailAmountsStep(@Value("#{jobParameters[startPayoutDate]}") String startPayoutDate,
                                               @Value("#{jobParameters[endPayoutDate]}") String endPayoutDate) {
        return stepBuilderFactory.get("registerOrderDetailAmountsStep")
                .<PayoutSubTotal, PayoutSubTotal>chunk(chunkSize)
                .reader(payoutByOrdersReader(startPayoutDate, endPayoutDate))
                .writer(customNoOperationItemWriter())
                .build();
    }

    @Bean
    @StepScope
    public QuerydslPagingItemReader<PayoutSubTotal> payoutByOrdersReader(@Value("#{jobParameters[startPayoutDate]}") String startPayoutDate,
                                                                         @Value("#{jobParameters[endPayoutDate]}") String endPayoutDate) {
        LocalDate startDate = LocalDateFormatter.toLocalDate(startPayoutDate);
        LocalDate endDate = LocalDateFormatter.toLocalDate(endPayoutDate);

        log.info("startDate = {}", startDate);
        log.info("endDate = {}", endDate);

        List<PaymentMethod> paymentMethods = PaymentMethod.getPaymentMethodsIncludedInPayout();

        return new QuerydslPagingItemReader<>(entityManagerFactory, chunkSize, queryFactory -> queryFactory
                .select(Projections.fields(PayoutSubTotal.class,
                        order.occurrenceDate.as("payoutDate"),
                        owner.as("owner"),
                        orderDetail.amount.sum().as("totalAmount")
                ))
                .from(orderDetail)
                .join(orderDetail.order, order)
                .join(order.owner, owner)
                .where(order.occurrenceDate.between(startDate, endDate),
                        orderDetail.paymentMethod.in(paymentMethods),
                        order.canceled.isFalse())
                .groupBy(owner, order.occurrenceDate)
                .orderBy(owner.id.asc())
        );
    }

    @Bean
    @StepScope
    public ItemWriter<PayoutSubTotal> customNoOperationItemWriter() {
        return items -> {
            for (PayoutSubTotal item : items) {
                log.info("payoutSubTotal : {}", item);
                payoutCollector.register(item);
            }
        };
    }

    /**
     * CorrectionAmount를 기준으로 각 Owner의 (지급금용) 주문 합계 금액을 가져온다.
     * PayoutCollector Bean에 등록한다.
     */
    // registerCorrectionAmountAmountsStep 생략

    /**
     * PayoutCollector에서 모든 지급금을 만들어와서 repository에 저장한다.
     */
    // saveAllPayoutsStep 생략

    @Bean
    @JobScope
    public PayoutCollector payoutCollector() {
        return new PayoutCollector();
    }
}