ShoppingCrawler/processor/src/main/java/com/myoa/engineering/crawl/ppomppu/processor/service/PpomppuArticleService.java

package com.myoa.engineering.crawl.ppomppu.processor.service;

import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.myoa.engineering.crawl.ppomppu.processor.domain.PpomppuArticle;
import com.myoa.engineering.crawl.ppomppu.processor.domain.PpomppuBoardFeedStatus;
import com.myoa.engineering.crawl.ppomppu.processor.infrastructure.repository.PpomppuArticleRepository;
import com.myoa.engineering.crawl.ppomppu.processor.infrastructure.repository.PpomppuBoardFeedStatusRepository;
import com.myoa.engineering.crawl.ppomppu.support.dto.code.PpomppuBoardName;

import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class PpomppuArticleService {

    private final PpomppuArticleRepository ppomppuArticleRepository;

    private final PpomppuBoardFeedStatusRepository ppomppuBoardFeedStatusRepository;

    public PpomppuArticleService(PpomppuArticleRepository ppomppuArticleRepository,
                                 PpomppuBoardFeedStatusRepository ppomppuBoardFeedStatusRepository) {
        this.ppomppuArticleRepository = ppomppuArticleRepository;
        this.ppomppuBoardFeedStatusRepository = ppomppuBoardFeedStatusRepository;
    }

    @Transactional(readOnly = true)
    public List<PpomppuArticle> filterOnlyNewArticles(PpomppuBoardName boardName, List<PpomppuArticle> articles) {
        Optional<PpomppuBoardFeedStatus> boardFeedStatus = ppomppuBoardFeedStatusRepository.findByBoardName(boardName);
        Long latestArticleId = boardFeedStatus.map(PpomppuBoardFeedStatus::getLatestParsedArticleId)
                                              .orElse(0L);

        log.info("latestArticleId : {}", latestArticleId);
        return articles.stream()
                       .filter(e -> e.getArticleId().compareTo(latestArticleId) > 0)
                       .collect(Collectors.toList());
    }

    @Transactional
    public List<PpomppuArticle> save(PpomppuBoardName boardName, List<PpomppuArticle> articles) {
        Long latestArticleId = articles.stream()
                                       .map(PpomppuArticle::getArticleId)
                                       .max(Long::compareTo)
                                       .orElse(0L);

        // save PpomppuBoardFeedStatus
        Optional<PpomppuBoardFeedStatus> boardFeedStatus = ppomppuBoardFeedStatusRepository.findByBoardName(boardName);
        log.info("[save] boardName: {}, isPresent?: {}, latestArticleId: {}",
                 boardName, boardFeedStatus.isPresent(), latestArticleId);
        log.info("[save] articles count: {}, article ids: {}",
                 articles.size(), articles.stream().map(PpomppuArticle::getArticleId).toArray());
        boardFeedStatus.ifPresentOrElse(e -> {
                                            if (latestArticleId.longValue() > 0L) {
                                                e.updateArticleId(latestArticleId);
                                                ppomppuBoardFeedStatusRepository.save(e);
                                            }
                                        },
                                        () -> ppomppuBoardFeedStatusRepository.save(PpomppuBoardFeedStatus.of(boardName,
                                                                                                              latestArticleId)));

        // save real articles.
        return ppomppuArticleRepository.saveAll(articles);
    }
}