Feature/crawl service refactor

apps/pre-processing-service/app/api/endpoints/blog.py

@@ -4,7 +4,9 @@
 from ...model.schemas import *
 from app.service.blog.tistory_blog_post_service import TistoryBlogPostService
 from app.service.blog.naver_blog_post_service import NaverBlogPostService
-from ...service.blog.blogger_blog_post_service import BloggerBlogPostService
+from ...service.blog.blogger_blog_post_adapter import (
+    BloggerBlogPostAdapter,
+)  # 수정된 import
 
 router = APIRouter()
 
@@ -62,7 +64,7 @@ async def publish(request: RequestBlogPublish):
         return ResponseBlogPublish(status="success", metadata=result)
 
     elif request.tag == "blogger":
-        blogger_service = BloggerBlogPostService()
+        blogger_service = BloggerBlogPostAdapter()  # 수정: Adapter 사용
         result = blogger_service.post_content(
             title=request.post_title,
             content=request.post_content,

apps/pre-processing-service/app/api/endpoints/keywords.py

@@ -6,6 +6,11 @@
 router = APIRouter()
 
 
+@router.get("/")
+async def root():
+    return {"message": "keyword API"}
+
+
 @router.post(
     "/search", response_model=ResponseNaverSearch, summary="네이버 키워드 검색"
 )
@@ -15,9 +20,6 @@ async def search(request: RequestNaverSearch):
 
     요청 예시:
     {
-        "job_id": 1,
-        "schedule_id": 1,
-        "schedule_his_id": 1,
         "tag": "naver",
         "category": "50000000",
         "start_date": "2025-09-01",

apps/pre-processing-service/app/api/endpoints/product.py

@@ -8,6 +8,7 @@
 from ...service.crawl_service import CrawlService
 from ...service.search_service import SearchService
 from ...service.match_service import MatchService
+from ...service.similarity_service import SimilarityService
 
 
 # from ...service.similarity_service import SimilarityService
@@ -54,33 +55,33 @@ async def match(request: RequestSadaguMatch):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-# @router.post(
-#     "/similarity", response_model=ResponseSadaguSimilarity, summary="상품 유사도 분석"
-# )
-# async def similarity(request: RequestSadaguSimilarity):
-#     """
-#     매칭된 상품들 중 키워드와의 유사도를 계산하여 최적의 상품을 선택합니다.
-#     """
-#     try:
-#         similarity_service = SimilarityService()
-#         result = similarity_service.select_product_by_similarity(request)
-#
-#         if not result:
-#             raise CustomException(
-#                 500, "유사도 분석에 실패했습니다.", "SIMILARITY_FAILED"
-#             )
-#
-#         return result
-#     except InvalidItemDataException as e:
-#         raise HTTPException(status_code=e.status_code, detail=e.detail)
-#     except Exception as e:
-#         raise HTTPException(status_code=500, detail=str(e))
+@router.post(
+    "/similarity", response_model=ResponseSadaguSimilarity, summary="상품 유사도 분석"
+)
+async def similarity(request: RequestSadaguSimilarity):
+    """
+    매칭된 상품들 중 키워드와의 유사도를 계산하여 최적의 상품을 선택합니다.
+    """
+    try:
+        similarity_service = SimilarityService()
+        result = similarity_service.select_product_by_similarity(request)
+
+        if not result:
+            raise CustomException(
+                500, "유사도 분석에 실패했습니다.", "SIMILARITY_FAILED"
+            )
+
+        return result
+    except InvalidItemDataException as e:
+        raise HTTPException(status_code=e.status_code, detail=e.detail)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
 
 @router.post(
     "/crawl", response_model=ResponseSadaguCrawl, summary="상품 상세 정보 크롤링"
 )
-async def crawl(request: Request, body: RequestSadaguCrawl):
+async def crawl(body: RequestSadaguCrawl):
     """
     상품 상세 페이지를 크롤링하여 상세 정보를 수집합니다.
     """

apps/pre-processing-service/app/api/endpoints/test.py

@@ -62,19 +62,14 @@ def with_meta(data: Mapping[str, Any], meta: Mapping[str, Any]) -> Dict[str, Any
 
 @router.get("/tester", response_model=None)
 async def processing_tester():
-    meta = {
-        "job_id": 1,
-        "schedule_id": 1,
-        "schedule_his_id": 1,  # ✅ 타이포 수정
-    }
     request_dict = {
         "tag": "naver",
         "category": "50000000",
         "start_date": "2025-09-01",
         "end_date": "2025-09-02",
     }
     # 네이버 키워드 검색
-    naver_request = RequestNaverSearch(**with_meta(meta, request_dict))
+    naver_request = RequestNaverSearch(**with_meta(request_dict))
     response_data = await keyword_search(naver_request)
     keyword = response_data.get("keyword")
     loguru.logger.info(keyword)
@@ -84,21 +79,21 @@ async def processing_tester():
     }
 
     # 싸다구 상품 검색
-    sadagu_request = RequestSadaguSearch(**with_meta(meta, keyword))
+    sadagu_request = RequestSadaguSearch(**with_meta(keyword))
     search_service = SearchService()
     keyword_result = await search_service.search_products(sadagu_request)
     loguru.logger.info(keyword_result)
 
     # 싸다구 상품 매치
     keyword["search_results"] = keyword_result.get("search_results")
-    keyword_match_request = RequestSadaguMatch(**with_meta(meta, keyword))
+    keyword_match_request = RequestSadaguMatch(**with_meta(keyword))
     match_service = MatchService()
     keyword_match_response = match_service.match_products(keyword_match_request)
     loguru.logger.info(keyword_match_response)
 
     # 싸다구 상품 유사도 분석
     keyword["matched_products"] = keyword_match_response.get("matched_products")
-    keyword_similarity_request = RequestSadaguSimilarity(**with_meta(meta, keyword))
+    keyword_similarity_request = RequestSadaguSimilarity(**with_meta(keyword))
     # similarity_service = SimilarityService()
     # keyword_similarity_response = similarity_service.select_product_by_similarity(
     #     keyword_similarity_request

apps/pre-processing-service/app/model/schemas.py

@@ -5,29 +5,11 @@
 
 # 기본 요청
 class RequestBase(BaseModel):
-    # job_id: int = Field(
-    #     ..., title="작업 ID", description="현재 실행 중인 작업의 고유 식별자"
-    # )
-    # schedule_id: int = Field(
-    #     ..., title="스케줄 ID", description="예약된 스케줄의 고유 식별자"
-    # )
-    # schedule_his_id: Optional[int] = Field(
-    #     None, title="스케줄 히스토리 ID", description="스케줄 실행 이력의 고유 식별자"
-    # )
     pass
 
 
 # 기본 응답
 class ResponseBase(BaseModel):
-    # job_id: int = Field(
-    #     ..., title="작업 ID", description="현재 실행 중인 작업의 고유 식별자"
-    # )
-    # schedule_id: int = Field(
-    #     ..., title="스케줄 ID", description="예약된 스케줄의 고유 식별자"
-    # )
-    # schedule_his_id: Optional[int] = Field(
-    #     None, title="스케줄 히스토리 ID", description="스케줄 실행 이력의 고유 식별자"
-    # )
     status: str = Field(..., title="상태", description="요청 처리 상태")
     pass
 

apps/pre-processing-service/app/service/blog/base_blog_post_service.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional
+from typing import Dict
 
 from app.utils.crawling_util import CrawlingUtil
 from app.errors.BlogPostingException import *
@@ -11,51 +11,39 @@ class BaseBlogPostService(ABC):
     블로그 포스팅 서비스 추상 클래스
     """
 
-    def __init__(self, config_file="blog_config.json"):
-        """공통 초기화 로직"""
-        # Selenium 기반 서비스를 위한 초기화
-        if self._requires_webdriver():
+    def __init__(self, use_webdriver=True):
+        """
+        공통 초기화 로직
+        :param use_webdriver: 웹드라이버 사용 여부 (API 서비스의 경우 False)
+        """
+        self.use_webdriver = use_webdriver
+
+        if self.use_webdriver:
             try:
-                self.crawling_service = CrawlingUtil()
+                # 블로그 포스팅용 설정으로 초기화
+                self.crawling_service = CrawlingUtil(
+                    headless=False,  # 네이버 탐지 우회를 위해 headless 비활성화
+                    for_blog_posting=True,
+                )
                 self.web_driver = self.crawling_service.get_driver()
                 self.wait_driver = self.crawling_service.get_wait()
             except Exception:
                 raise WebDriverConnectionException()
         else:
-            # API 기반 서비스의 경우 WebDriver가 필요 없음
             self.crawling_service = None
             self.web_driver = None
             self.wait_driver = None
 
-        # API 기반 서비스를 위한 초기화
-        self.config_file = config_file
-        self.config = {}
-        self.current_upload_account = None
-
-        # API 관련 속성들 (사용하지 않는 서비스에서는 None으로 유지)
-        self.blogger_service = None
-        self.blog_id = None
-        self.scopes = None
-
         self._load_config()
 
-    def _requires_webdriver(self) -> bool:
-        """
-        서브클래스에서 WebDriver가 필요한지 여부를 반환
-        기본값은 True (Selenium 기반), API 기반 서비스에서는 False로 오버라이드
-        """
-        return True
-
     @abstractmethod
     def _load_config(self) -> None:
         """플랫폼별 설정 로드"""
         pass
 
+    @abstractmethod
     def _login(self) -> None:
-        """
-        플랫폼별 로그인 구현 (API 기반 서비스의 경우 인증으로 대체)
-        기본 구현은 아무것도 하지 않음 (API 서비스용)
-        """
+        """플랫폼별 로그인 구현"""
         pass
 
     @abstractmethod
@@ -83,6 +71,14 @@ def _validate_content(
         :param content: 포스트 내용
         :param tags: 포스트 태그 리스트
         """
+        # if not title or not title.strip():
+        #     raise BlogContentValidationException("title", "제목이 비어있습니다")
+        #
+        # if not content or not content.strip():
+        #     raise BlogContentValidationException("content", "내용이 비어있습니다")
+        #
+        # if tags is None:
+        #     raise BlogContentValidationException("tags", "태그가 비어있습니다")
         pass
 
     def post_content(self, title: str, content: str, tags: List[str] = None) -> Dict:
@@ -96,7 +92,7 @@ def post_content(self, title: str, content: str, tags: List[str] = None) -> Dict
         # 1. 콘텐츠 유효성 검사
         self._validate_content(title, content, tags)
 
-        # 2. 로그인 (Selenium 기반) 또는 인증 (API 기반)
+        # 2. 로그인
         self._login()
 
         # 3. 포스트 작성 및 발행

apps/pre-processing-service/app/service/blog/blogger_blog_post_adapter.py

@@ -0,0 +1,84 @@
+from typing import Dict, List, Optional
+from app.service.blog.base_blog_post_service import BaseBlogPostService
+from app.service.blog.blogger_blog_post_service import BloggerApiService
+from app.errors.BlogPostingException import *
+
+
+class BloggerBlogPostAdapter(BaseBlogPostService):
+    """
+    BaseBlogPostService와 호환되도록 BloggerApiService를 감싼 어댑터
+    현재 BaseBlogPostService 인터페이스와 호환
+    """
+
+    def __init__(self, config_file="blog_config.json"):
+        # API 전용 서비스 (Adaptee) 먼저 초기화
+        self.api_service = BloggerApiService(config_file=config_file)
+
+        try:
+            # 부모 클래스의 웹드라이버 초기화를 시도하지만, 실패해도 무시
+            # 이렇게 하면 부모의 다른 초기화 로직은 실행됨
+            super().__init__()
+        except Exception:
+            # 웹드라이버 초기화 실패 시 API 서비스용으로 속성 설정
+            self.crawling_service = None
+            self.web_driver = None
+            self.wait_driver = None
+            # 설정 로드는 직접 호출
+            self._load_config()
+
+    def _load_config(self) -> None:
+        """
+        BloggerApiService 내부에서 이미 처리되므로 별도 구현 불필요
+        """
+        # API 서비스의 설정이 이미 로드되었으므로 추가 작업 없음
+        pass
+
+    def _login(self) -> None:
+        """
+        Selenium 로그인과 달리, OAuth 인증으로 대체
+        """
+        try:
+            self.api_service.authenticate_with_google_oauth()
+        except Exception as e:
+            raise BlogLoginException("Blogger", f"OAuth 인증 실패: {str(e)}")
+
+    def _write_content(self, title: str, content: str, tags: List[str] = None) -> None:
+        """
+        API를 통한 포스트 작성
+        """
+        try:
+            result = self.api_service.create_post_via_api(title, content, labels=tags)
+            # 결과 로깅
+            print(f"포스트 생성 완료: {result.get('published_url', 'URL 없음')}")
+        except Exception as e:
+            raise BlogPostPublishException("Blogger", f"포스트 작성 실패: {str(e)}")
+
+    def _get_platform_name(self) -> str:
+        """플랫폼 이름 반환"""
+        return "Blogger"
+
+    def _validate_content(
+        self, title: str, content: str, tags: Optional[List[str]] = None
+    ) -> None:
+        """
+        API 전용 유효성 검사 호출
+        """
+        try:
+            # Optional을 List로 변환 (None인 경우 빈 리스트)
+            tags_list = tags if tags is not None else []
+            self.api_service.validate_api_content(title, content, labels=tags_list)
+        except Exception as e:
+            # BloggerApiService의 예외를 BaseBlogPostService 호환 예외로 변환
+            if "title" in str(e).lower():
+                raise BlogContentValidationException("title", str(e))
+            elif "content" in str(e).lower():
+                raise BlogContentValidationException("content", str(e))
+            else:
+                raise BlogContentValidationException("general", str(e))
+
+    def __del__(self):
+        """
+        API 서비스이므로 웹드라이버 정리가 불필요
+        """
+        # 웹드라이버가 없으므로 정리할 것이 없음
+        pass