From 4cc59df94241d8435294f87dce6d65c415744fe9 Mon Sep 17 00:00:00 2001
From: thkim7 <xogusrla7@gmail.com>
Date: Wed, 17 Sep 2025 10:52:04 +0900
Subject: [PATCH 1/4] =?UTF-8?q?feat:=20=EB=B8=94=EB=A1=9C=EA=B7=B8=20Rag?=
 =?UTF-8?q?=EA=B8=B0=EB=B0=98=20=EC=BD=98=ED=85=90=EC=B8=A0=20=EC=83=9D?=
 =?UTF-8?q?=EC=84=B1?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../app/service/blog/blog_create_service.py   | 298 ++++++++++++++
 .../service/product_blog_posting_service.py   | 387 ------------------
 2 files changed, 298 insertions(+), 387 deletions(-)
 create mode 100644 apps/pre-processing-service/app/service/blog/blog_create_service.py
 delete mode 100644 apps/pre-processing-service/app/service/product_blog_posting_service.py

diff --git a/apps/pre-processing-service/app/service/blog/blog_create_service.py b/apps/pre-processing-service/app/service/blog/blog_create_service.py
new file mode 100644
index 00000000..b0e06907
--- /dev/null
+++ b/apps/pre-processing-service/app/service/blog/blog_create_service.py
@@ -0,0 +1,298 @@
+import json
+import logging
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+
+from openai import OpenAI
+from dotenv import load_dotenv
+
+from app.schemas import RequestBlogCreate
+from app.errors.BlogPostingException import *
+
+# 환경변수 로드
+load_dotenv(".env.dev")
+
+client = OpenAI()
+
+
+class BlogContentService:
+    """RAG를 사용한 블로그 콘텐츠 생성 전용 서비스"""
+
+    def __init__(self):
+        # OpenAI API 키 설정
+        self.openai_api_key = os.getenv("OPENAI_API_KEY")
+        if not self.openai_api_key:
+            raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
+
+        client.api_key = self.openai_api_key
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def generate_blog_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
+        """
+        요청 데이터를 기반으로 블로그 콘텐츠 생성
+
+        Args:
+            request: RequestBlogCreate 객체
+
+        Returns:
+            Dict: {"title": str, "content": str, "tags": List[str]} 형태의 결과
+        """
+        try:
+            # 1. 콘텐츠 정보 정리
+            content_context = self._prepare_content_context(request)
+
+            # 2. 프롬프트 생성
+            prompt = self._create_content_prompt(content_context, request)
+
+            # 3. GPT를 통한 콘텐츠 생성
+            generated_content = self._generate_with_openai(prompt)
+
+            # 4. 콘텐츠 파싱 및 구조화
+            return self._parse_generated_content(generated_content, request)
+
+        except Exception as e:
+            self.logger.error(f"콘텐츠 생성 실패: {e}")
+            return self._create_fallback_content(request)
+
+    def _prepare_content_context(self, request: RequestBlogCreate) -> str:
+        """요청 데이터를 콘텐츠 생성용 컨텍스트로 변환"""
+        context_parts = []
+
+        # 키워드 정보 추가
+        if request.keyword:
+            context_parts.append(f"주요 키워드: {request.keyword}")
+
+        # 상품 정보 추가
+        if request.product_info:
+            context_parts.append("\n상품 정보:")
+
+            # 상품 기본 정보
+            if request.product_info.get("title"):
+                context_parts.append(f"- 상품명: {request.product_info['title']}")
+
+            if request.product_info.get("price"):
+                context_parts.append(f"- 가격: {request.product_info['price']:,}원")
+
+            if request.product_info.get("rating"):
+                context_parts.append(f"- 평점: {request.product_info['rating']}/5.0")
+
+            # 상품 상세 정보
+            if request.product_info.get("description"):
+                context_parts.append(f"- 설명: {request.product_info['description']}")
+
+            # 상품 사양 (material_info 등)
+            if request.product_info.get("material_info"):
+                context_parts.append("- 주요 사양:")
+                specs = request.product_info["material_info"]
+                if isinstance(specs, dict):
+                    for key, value in specs.items():
+                        context_parts.append(f"  * {key}: {value}")
+
+            # 상품 옵션
+            if request.product_info.get("options"):
+                options = request.product_info["options"]
+                context_parts.append(f"- 구매 옵션 ({len(options)}개):")
+                for i, option in enumerate(options[:5], 1):  # 최대 5개만
+                    if isinstance(option, dict):
+                        option_name = option.get("name", f"옵션 {i}")
+                        context_parts.append(f"  {i}. {option_name}")
+                    else:
+                        context_parts.append(f"  {i}. {option}")
+
+            # 구매 링크
+            if request.product_info.get("url") or request.product_info.get("product_url"):
+                url = request.product_info.get("url") or request.product_info.get("product_url")
+                context_parts.append(f"- 구매 링크: {url}")
+
+        return "\n".join(context_parts) if context_parts else "키워드 기반 콘텐츠 생성"
+
+    def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> str:
+        """콘텐츠 생성용 프롬프트 생성"""
+
+        # 기본 키워드가 없으면 상품 제목에서 추출
+        main_keyword = request.keyword
+        if not main_keyword and request.product_info and request.product_info.get("title"):
+            main_keyword = request.product_info["title"]
+
+        prompt = f"""
+다음 정보를 바탕으로 매력적인 블로그 포스트를 작성해주세요.
+
+정보:
+{context}
+
+작성 가이드라인:
+- 스타일: 친근하면서도 신뢰할 수 있는, 정보 제공 중심
+- 길이: 1200자 내외의 적당한 길이
+- 톤: 독자의 관심을 끄는 자연스러운 어조
+
+작성 요구사항:
+1. SEO 친화적이고 클릭하고 싶은 매력적인 제목
+2. 독자의 관심을 끄는 도입부
+3. 핵심 특징과 장점을 구체적으로 설명
+4. 실제 사용 시나리오나 활용 팁
+5. 구매 결정에 도움이 되는 정보
+
+⚠️ 주의:
+- 절대로 마지막에 'HTML 구조는…' 같은 자기 평가 문장을 추가하지 마세요.
+- 출력 시 ```나 ```html 같은 코드 블록 구문을 포함하지 마세요.
+- 오직 HTML 태그만 사용하여 구조화된 콘텐츠를 작성해주세요.
+(예: <h2>, <h3>, <p>, <ul>, <li> 등)
+"""
+
+        return prompt
+
+    def _generate_with_openai(self, prompt: str) -> str:
+        """OpenAI API를 통한 콘텐츠 생성"""
+        try:
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {
+                        "role": "system",
+                        "content": "당신은 전문적인 블로그 콘텐츠 작성자입니다. 상품 리뷰와 정보성 콘텐츠를 매력적이고 SEO 친화적으로 작성합니다.",
+                    },
+                    {"role": "user", "content": prompt},
+                ],
+                temperature=0.7,
+                max_tokens=2000,
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            self.logger.error(f"OpenAI API 호출 실패: {e}")
+            raise
+
+    def _parse_generated_content(self, content: str, request: RequestBlogCreate) -> Dict[str, Any]:
+        """생성된 콘텐츠를 파싱하여 구조화"""
+
+        # 제목 추출 (첫 번째 h1이나 강조된 줄)
+        lines = content.strip().split("\n")
+        title = "블로그 포스트"  # 기본값
+
+        for line in lines[:10]:  # 처음 10줄에서 제목 찾기
+            clean_line = (
+                line.strip()
+                .replace("#", "")
+                .replace("<h1>", "")
+                .replace("</h1>", "")
+                .replace("<h2>", "")
+                .replace("</h2>", "")
+            )
+            if clean_line and len(clean_line) > 5 and len(clean_line) < 100:
+                title = clean_line
+                break
+
+        # 키워드가 있으면 제목에 없을 경우 기본 제목 생성
+        if request.keyword and request.keyword not in title:
+            if request.product_info and request.product_info.get("title"):
+                title = f"{request.product_info['title']} - {request.keyword} 완벽 가이드"
+            else:
+                title = f"{request.keyword} - 완벽 가이드"
+
+        # 태그 생성
+        tags = self._generate_tags(request)
+
+        return {
+            "title": title,
+            "content": content,
+            "tags": tags
+        }
+
+    def _generate_tags(self, request: RequestBlogCreate) -> List[str]:
+        """요청 정보 기반 태그 생성"""
+        tags = []
+
+        # 키워드 추가
+        if request.keyword:
+            tags.append(request.keyword)
+
+        # 상품 정보에서 태그 추출
+        if request.product_info:
+            # 상품명에서 키워드 추출
+            if request.product_info.get("title"):
+                title = request.product_info["title"].lower()
+
+                # 일반적인 제품 카테고리 태그
+                if any(word in title for word in ["iphone", "아이폰", "phone"]):
+                    tags.extend(["아이폰", "스마트폰"])
+                if any(word in title for word in ["필름", "보호", "강화"]):
+                    tags.extend(["보호필름", "강화필름"])
+                if any(word in title for word in ["케이스", "커버"]):
+                    tags.extend(["폰케이스", "액세서리"])
+                if any(word in title for word in ["노트북", "laptop"]):
+                    tags.extend(["노트북", "컴퓨터"])
+                if any(word in title for word in ["마우스", "키보드"]):
+                    tags.extend(["컴퓨터용품", "PC액세서리"])
+
+            # 재료/사양 정보에서 태그 생성
+            if request.product_info.get("material_info"):
+                material_info = request.product_info["material_info"]
+                if isinstance(material_info, dict):
+                    for key, value in material_info.items():
+                        if value and len(str(value).strip()) <= 20:
+                            clean_value = str(value).strip()
+                            if clean_value not in tags:
+                                tags.append(clean_value)
+
+        # 기본 태그 추가
+        if not tags:
+            tags = ["상품정보", "리뷰"]
+
+        # 중복 제거 및 개수 제한
+        unique_tags = []
+        for tag in tags:
+            if tag not in unique_tags and len(unique_tags) < 10:
+                unique_tags.append(tag)
+
+        return unique_tags
+
+    def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]:
+        """콘텐츠 생성 실패 시 대안 콘텐츠 생성"""
+
+        if request.product_info and request.product_info.get("title"):
+            title = f"{request.product_info['title']} - 상품 정보 및 구매 가이드"
+            product_name = request.product_info["title"]
+        elif request.keyword:
+            title = f"{request.keyword} - 완벽 가이드"
+            product_name = request.keyword
+        else:
+            title = "상품 정보 및 구매 가이드"
+            product_name = "상품"
+
+        content = f"""
+<h1>{title}</h1>
+
+<h2>상품 소개</h2>
+<p>{product_name}에 대한 상세한 정보를 소개합니다.</p>
+
+<h2>주요 특징</h2>
+<ul>
+<li>고품질의 제품으로 신뢰할 수 있는 브랜드입니다</li>
+<li>합리적인 가격으로 가성비가 뛰어납니다</li>
+<li>사용자 친화적인 디자인과 기능을 제공합니다</li>
+</ul>
+"""
+
+        if request.product_info:
+            if request.product_info.get("price"):
+                content += f"<h2>가격 정보</h2>\n<p>판매가: <strong>{request.product_info['price']:,}원</strong></p>\n"
+
+            if request.product_info.get("material_info"):
+                content += "<h2>상품 사양</h2>\n<ul>\n"
+                for key, value in request.product_info["material_info"].items():
+                    content += f"<li><strong>{key}:</strong> {value}</li>\n"
+                content += "</ul>\n"
+
+        content += """
+<h2>구매 안내</h2>
+<p>신중한 검토를 통해 만족스러운 구매 결정을 내리시기 바랍니다.</p>
+"""
+
+        return {
+            "title": title,
+            "content": content,
+            "tags": self._generate_tags(request)
+        }
\ No newline at end of file
diff --git a/apps/pre-processing-service/app/service/product_blog_posting_service.py b/apps/pre-processing-service/app/service/product_blog_posting_service.py
deleted file mode 100644
index 129c4666..00000000
--- a/apps/pre-processing-service/app/service/product_blog_posting_service.py
+++ /dev/null
@@ -1,387 +0,0 @@
-import json
-import logging
-import os
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-from dataclasses import dataclass
-from enum import Enum
-
-from openai import OpenAI
-from dotenv import load_dotenv
-
-from app.service.blog.blogger_blog_post_adapter import BloggerBlogPostAdapter
-from app.errors.BlogPostingException import *
-
-# 환경변수 로드
-load_dotenv(".env.dev")
-
-client = OpenAI()
-
-
-class PostingStatus(Enum):
-    PENDING = "pending"
-    PROCESSING = "processing"
-    SUCCESS = "success"
-    FAILED = "failed"
-    RETRY = "retry"
-
-
-@dataclass
-class ProductData:
-    """크롤링된 상품 데이터 모델"""
-
-    tag: str
-    product_url: str
-    title: str
-    price: int
-    rating: float
-    options: List[Dict[str, Any]]
-    material_info: Dict[str, str]
-    product_images: List[str]
-    crawled_at: str
-
-    @classmethod
-    def from_dict(cls, data: Dict) -> "ProductData":
-        """딕셔너리에서 ProductData 객체 생성"""
-        product_detail = data.get("product_detail", {})
-        return cls(
-            tag=data.get("tag", ""),
-            product_url=product_detail.get("url", ""),
-            title=product_detail.get("title", ""),
-            price=product_detail.get("price", 0),
-            rating=product_detail.get("rating", 0.0),
-            options=product_detail.get("options", []),
-            material_info=product_detail.get("material_info", {}),
-            product_images=product_detail.get("product_images", []),
-            crawled_at=data.get("crawled_at", ""),
-        )
-
-
-@dataclass
-class BlogPostContent:
-    """생성된 블로그 포스트 콘텐츠"""
-
-    title: str
-    content: str
-    tags: List[str]
-
-
-@dataclass
-class BlogContentRequest:
-    """블로그 콘텐츠 생성 요청"""
-
-    content_style: str = "informative"  # "informative", "promotional", "review"
-    target_keywords: List[str] = None
-    include_pricing: bool = True
-    include_specifications: bool = True
-    content_length: str = "medium"  # "short", "medium", "long"
-
-
-class ProductContentGenerator:
-    """GPT를 활용한 상품 블로그 콘텐츠 생성"""
-
-    def __init__(self):
-        # 환경변수에서 OpenAI API 키 로드
-        self.openai_api_key = os.getenv("OPENAI_API_KEY")
-        if not self.openai_api_key:
-            raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
-
-        client.api_key = self.openai_api_key
-
-    def generate_blog_content(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """상품 데이터를 기반으로 블로그 콘텐츠 생성"""
-
-        # 1. 상품 정보 정리
-        product_info = self._format_product_info(product_data, request)
-
-        # 2. 프롬프트 생성
-        prompt = self._create_blog_prompt(product_info, request)
-
-        # 3. GPT를 통한 콘텐츠 생성
-        try:
-
-            response = client.chat.completions.create(
-                model="gpt-4o-mini",
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "당신은 전문적인 블로그 콘텐츠 작성자입니다. 상품 리뷰와 정보성 콘텐츠를 매력적이고 SEO 친화적으로 작성합니다.",
-                    },
-                    {"role": "user", "content": prompt},
-                ],
-                temperature=0.7,
-                max_tokens=2000,
-            )
-
-            generated_content = response.choices[0].message.content
-
-            # 4. 콘텐츠 파싱 및 구조화
-            return self._parse_generated_content(
-                generated_content, product_data, request
-            )
-
-        except Exception as e:
-            logging.error(f"콘텐츠 생성 실패: {e}")
-            return self._create_fallback_content(product_data, request)
-
-    def _format_product_info(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> str:
-        """상품 정보를 텍스트로 포맷팅"""
-        info_parts = [
-            f"상품명: {product_data.title}",
-        ]
-
-        # 가격 정보 추가
-        if request.include_pricing and product_data.price:
-            info_parts.append(f"가격: {product_data.price:,}원")
-
-        # 평점 정보 추가
-        if product_data.rating:
-            info_parts.append(f"평점: {product_data.rating}/5.0")
-
-        # 사양 정보 추가
-        if request.include_specifications and product_data.material_info:
-            info_parts.append("\n상품 사양:")
-            for key, value in product_data.material_info.items():
-                info_parts.append(f"- {key}: {value}")
-
-        # 옵션 정보 추가
-        if product_data.options:
-            info_parts.append(f"\n구매 옵션 ({len(product_data.options)}개):")
-            for i, option in enumerate(product_data.options[:5], 1):  # 처음 5개만
-                info_parts.append(f"{i}. {option.get('name', 'N/A')}")
-
-        # 구매 링크
-        if product_data.product_url:
-            info_parts.append(f"\n구매 링크: {product_data.product_url}")
-
-        return "\n".join(info_parts)
-
-    def _create_blog_prompt(
-        self, product_info: str, request: BlogContentRequest
-    ) -> str:
-        """블로그 작성용 프롬프트 생성"""
-
-        # 스타일별 가이드라인
-        style_guidelines = {
-            "informative": "객관적이고 상세한 정보 제공 중심으로, 독자가 제품을 이해할 수 있도록 전문적으로 작성",
-            "promotional": "제품의 장점과 매력을 강조하며, 구매 의욕을 자극할 수 있도록 매력적으로 작성",
-            "review": "실제 사용 경험을 바탕으로 한 솔직한 평가와 추천 중심으로 작성",
-        }
-
-        # 길이별 가이드라인
-        length_guidelines = {
-            "short": "800자 내외의 간결한 내용",
-            "medium": "1200자 내외의 적당한 길이",
-            "long": "1500자 이상의 상세한 내용",
-        }
-
-        style_guide = style_guidelines.get(
-            request.content_style, style_guidelines["informative"]
-        )
-        length_guide = length_guidelines.get(
-            request.content_length, length_guidelines["medium"]
-        )
-
-        # 키워드 정보
-        keywords_text = ""
-        if request.target_keywords:
-            keywords_text = f"\n포함할 키워드: {', '.join(request.target_keywords)}"
-
-        prompt = f"""
-다음 상품 정보를 바탕으로 매력적인 블로그 포스트를 작성해주세요.
-
-상품 정보:
-{product_info}
-
-작성 가이드라인:
-- 스타일: {style_guide}
-- 길이: {length_guide}
-- 톤: 친근하면서도 신뢰할 수 있는, 정보 제공 중심{keywords_text}
-
-작성 요구사항:
-1. SEO 친화적이고 클릭하고 싶은 매력적인 제목
-2. 독자의 관심을 끄는 도입부
-3. 상품의 핵심 특징과 장점을 구체적으로 설명
-4. 실제 사용 시나리오나 활용 팁
-5. 구매 결정에 도움이 되는 정보
-
-⚠️ 주의:
-- 절대로 마지막에 '이 HTML 구조는…' 같은 자기 평가 문장을 추가하지 마세요.
-- 출력 시 ```나 ```html 같은 코드 블록 구문을 포함하지 마세요.
-- 오직 HTML 태그만 사용하여 구조화된 콘텐츠를 작성해주세요.
-(예: <h2>, <h3>, <p>, <ul>, <li> 등)
-"""
-
-        return prompt
-
-    def _parse_generated_content(
-        self, content: str, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """생성된 콘텐츠를 파싱하여 구조화"""
-
-        # 제목 추출 (첫 번째 h1이나 강조된 줄)
-        lines = content.strip().split("\n")
-        title = product_data.title  # 기본값
-
-        for line in lines[:10]:  # 처음 10줄에서 제목 찾기
-            clean_line = (
-                line.strip().replace("#", "").replace("<h1>", "").replace("</h1>", "")
-            )
-            if (
-                clean_line
-                and len(clean_line) > 5
-                and ("제목" in line or "<h1>" in line or line.startswith("#"))
-            ):
-                title = clean_line
-                break
-            elif clean_line and len(clean_line) > 10 and len(clean_line) < 100:
-                # 적당한 길이의 첫 번째 줄을 제목으로
-                title = clean_line
-                break
-
-        # 태그 생성
-        tags = self._generate_tags_from_product(product_data, request)
-
-        return BlogPostContent(title=title, content=content, tags=tags)
-
-    def _generate_tags_from_product(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> List[str]:
-        """상품 정보 기반 태그 생성"""
-        tags = []
-
-        # 사용자 지정 키워드가 있으면 우선 추가
-        if request.target_keywords:
-            tags.extend(request.target_keywords[:5])
-
-        # 기본 태그 추가
-        if product_data.tag:
-            tags.append(product_data.tag)
-
-        # 제품 타입 추론해서 태그 추가
-        title_lower = product_data.title.lower()
-        if any(word in title_lower for word in ["iphone", "아이폰", "phone"]):
-            tags.extend(["아이폰", "스마트폰"])
-        if any(word in title_lower for word in ["필름", "보호", "강화"]):
-            tags.extend(["보호필름", "강화필름"])
-        if any(word in title_lower for word in ["케이스", "커버"]):
-            tags.extend(["폰케이스", "액세서리"])
-
-        # 재료 정보에서 태그 생성
-        if product_data.material_info:
-            for key, value in product_data.material_info.items():
-                if value and len(value.strip()) <= 20:  # 너무 긴 값은 제외
-                    clean_value = value.strip()
-                    if clean_value not in tags:
-                        tags.append(clean_value)
-
-        # 중복 제거 및 개수 제한
-        unique_tags = []
-        for tag in tags:
-            if tag not in unique_tags and len(unique_tags) < 10:
-                unique_tags.append(tag)
-
-        return unique_tags
-
-    def _create_fallback_content(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> BlogPostContent:
-        """콘텐츠 생성 실패 시 대안 콘텐츠 생성"""
-        title = f"{product_data.title} - 상품 정보 및 구매 가이드"
-
-        content = f"""
-<h1>{product_data.title}</h1>
-
-<h2>상품 소개</h2>
-<p>{product_data.title}에 대한 상세한 정보를 소개합니다.</p>
-
-<h2>가격 정보</h2>
-<p>판매가: <strong>{product_data.price:,}원</strong></p>
-"""
-
-        if product_data.material_info:
-            content += "<h2>상품 사양</h2>\n<ul>\n"
-            for key, value in product_data.material_info.items():
-                content += f"<li><strong>{key}:</strong> {value}</li>\n"
-            content += "</ul>\n"
-
-        if product_data.options:
-            content += f"<h2>구매 옵션 ({len(product_data.options)}가지)</h2>\n<ul>\n"
-            for option in product_data.options[:5]:
-                content += f"<li>{option.get('name', 'N/A')}</li>\n"
-            content += "</ul>\n"
-
-        content += f"""
-<h2>구매 안내</h2>
-<p>상품 구매는 <a href="{product_data.product_url}" target="_blank">여기</a>에서 가능합니다.</p>
-"""
-
-        return BlogPostContent(
-            title=title,
-            content=content,
-            tags=[product_data.tag] if product_data.tag else ["상품정보"],
-        )
-
-
-class ProductBlogPostingService:
-    """상품 데이터를 Blogger에 포스팅하는 메인 서비스"""
-
-    def __init__(self):
-        self.content_generator = ProductContentGenerator()
-        self.blogger_service = BloggerBlogPostAdapter()
-
-    def post_product_to_blogger(
-        self, product_data: ProductData, request: BlogContentRequest
-    ) -> dict:
-        """상품 데이터를 Blogger에 포스팅"""
-        try:
-            # 1. GPT를 통한 콘텐츠 생성
-            blog_content = self.content_generator.generate_blog_content(
-                product_data, request
-            )
-
-            # 2. Blogger에 포스팅
-            self.blogger_service.post_content(
-                title=blog_content.title,
-                content=blog_content.content,
-                tags=blog_content.tags,
-            )
-
-            # 3. 성공 결과 반환
-            return {
-                "status": "success",
-                "platform": "blogger",
-                "title": blog_content.title,
-                "tags": blog_content.tags,
-                "posted_at": datetime.now().isoformat(),
-                "product_tag": product_data.tag,
-            }
-
-        except Exception as e:
-            logging.error(f"Blogger 포스팅 실패: {e}")
-            # ProductData 객체 기준으로 처리
-            return {
-                "status": "failed",
-                "error": str(e),
-                "platform": "blogger",
-                "attempted_at": datetime.now().isoformat(),
-                "product_tag": getattr(product_data, "tag", "unknown"),
-            }
-
-    # def batch_post_products(self, products_data: List[Dict], request: BlogContentRequest) -> List[Dict[str, Any]]:
-    #     """여러 상품을 일괄 포스팅"""
-    #     results = []
-    #
-    #     for product_data in products_data:
-    #         result = self.post_product_to_blogger(product_data, request)
-    #         results.append(result)
-    #
-    #         # API 호출 제한을 고려한 딜레이
-    #         import time
-    #         time.sleep(3)  # 3초 대기
-    #
-    #     return results

From 39ce9518069be2dfd2a4fdfc01677c3d6a8d82f6 Mon Sep 17 00:00:00 2001
From: thkim7 <xogusrla7@gmail.com>
Date: Wed, 17 Sep 2025 11:12:54 +0900
Subject: [PATCH 2/4] =?UTF-8?q?feat:=20=EB=B8=94=EB=A1=9C=EA=B7=B8=20Rag?=
 =?UTF-8?q?=EA=B8=B0=EB=B0=98=20=EC=BD=98=ED=85=90=EC=B8=A0=20=EC=83=9D?=
 =?UTF-8?q?=EC=84=B1=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?=
 =?UTF-8?q?=EC=9E=91=EC=84=B1=20=EC=99=84=EB=A3=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../app/service/blog/blog_create_service.py   | 50 +++++++++--
 .../app/test/test_blog_create_service.py      | 84 ++++++++++++++++++
 .../test/test_product_blog_posting_service.py | 87 -------------------
 3 files changed, 128 insertions(+), 93 deletions(-)
 create mode 100644 apps/pre-processing-service/app/test/test_blog_create_service.py
 delete mode 100644 apps/pre-processing-service/app/test/test_product_blog_posting_service.py

diff --git a/apps/pre-processing-service/app/service/blog/blog_create_service.py b/apps/pre-processing-service/app/service/blog/blog_create_service.py
index b0e06907..b2d61c21 100644
--- a/apps/pre-processing-service/app/service/blog/blog_create_service.py
+++ b/apps/pre-processing-service/app/service/blog/blog_create_service.py
@@ -7,14 +7,12 @@
 from openai import OpenAI
 from dotenv import load_dotenv
 
-from app.schemas import RequestBlogCreate
+from app.model.schemas import RequestBlogCreate
 from app.errors.BlogPostingException import *
 
 # 환경변수 로드
 load_dotenv(".env.dev")
 
-client = OpenAI()
-
 
 class BlogContentService:
     """RAG를 사용한 블로그 콘텐츠 생성 전용 서비스"""
@@ -25,7 +23,8 @@ def __init__(self):
         if not self.openai_api_key:
             raise ValueError("OPENAI_API_KEY가 .env.dev 파일에 설정되지 않았습니다.")
 
-        client.api_key = self.openai_api_key
+        # 인스턴스 레벨에서 클라이언트 생성
+        self.client = OpenAI(api_key=self.openai_api_key)
         logging.basicConfig(level=logging.INFO)
         self.logger = logging.getLogger(__name__)
 
@@ -146,7 +145,7 @@ def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> st
     def _generate_with_openai(self, prompt: str) -> str:
         """OpenAI API를 통한 콘텐츠 생성"""
         try:
-            response = client.chat.completions.create(
+            response = self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 messages=[
                     {
@@ -295,4 +294,43 @@ def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]
             "title": title,
             "content": content,
             "tags": self._generate_tags(request)
-        }
\ No newline at end of file
+        }
+
+# if __name__ == '__main__':
+#     # 테스트용 요청 데이터
+#     test_request = RequestBlogCreate(
+#         keyword="아이폰 케이스",
+#         product_info={
+#             "title": "아이폰 15 프로 투명 케이스",
+#             "price": 29900,
+#             "rating": 4.8,
+#             "description": "9H 강화 보호 기능을 제공하는 투명 케이스",
+#             "material_info": {
+#                 "소재": "TPU + PC",
+#                 "두께": "1.2mm",
+#                 "색상": "투명",
+#                 "호환성": "아이폰 15 Pro"
+#             },
+#             "options": [
+#                 {"name": "투명"},
+#                 {"name": "반투명"},
+#                 {"name": "블랙"}
+#             ],
+#             "url": "https://example.com/iphone-case"
+#         }
+#     )
+#
+#     # 서비스 실행
+#     service = BlogContentService()
+#     print("=== 블로그 콘텐츠 생성 테스트 ===")
+#     print(f"키워드: {test_request.keyword}")
+#     print(f"상품: {test_request.product_info['title']}")
+#     print("\n--- 생성 시작 ---")
+#
+#     result = service.generate_blog_content(test_request)
+#
+#     print(f"\n=== 생성 결과 ===")
+#     print(f"제목: {result['title']}")
+#     print(f"\n태그: {', '.join(result['tags'])}")
+#     print(f"\n내용:\n{result['content']}")
+#     print(f"\n글자수: {len(result['content'])}자")
\ No newline at end of file
diff --git a/apps/pre-processing-service/app/test/test_blog_create_service.py b/apps/pre-processing-service/app/test/test_blog_create_service.py
new file mode 100644
index 00000000..0c6d447c
--- /dev/null
+++ b/apps/pre-processing-service/app/test/test_blog_create_service.py
@@ -0,0 +1,84 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from app.service.blog.blog_create_service import BlogContentService
+from app.model.schemas import RequestBlogCreate
+
+
+class TestBlogContentGeneration(unittest.TestCase):
+    """블로그 콘텐츠 생성 핵심 로직 테스트"""
+
+    @patch.dict('os.environ', {'OPENAI_API_KEY': 'test-key'})
+    @patch('app.service.blog.blog_create_service.OpenAI')
+    def setUp(self, mock_openai_class):
+        """테스트 설정 - OpenAI Mock 적용"""
+        # Mock OpenAI 클라이언트 설정
+        self.mock_client = MagicMock()
+        mock_openai_class.return_value = self.mock_client
+
+        # 서비스 인스턴스 생성
+        self.service = BlogContentService()
+
+    def test_generate_blog_content_success(self):
+        """정상적인 콘텐츠 생성 테스트"""
+        # Mock 응답 설정
+        mock_choice = MagicMock()
+        mock_choice.message.content = """<h1>아이폰 15 케이스 완벽 가이드</h1>
+<h2>제품 소개</h2>
+<p>이 케이스는 뛰어난 보호 성능을 제공합니다.</p>"""
+
+        mock_response = MagicMock()
+        mock_response.choices = [mock_choice]
+
+        self.mock_client.chat.completions.create.return_value = mock_response
+
+        # 테스트 요청
+        request = RequestBlogCreate(
+            keyword="아이폰 케이스",
+            product_info={
+                "title": "아이폰 15 투명 케이스",
+                "price": 25000
+            }
+        )
+
+        # 실행
+        result = self.service.generate_blog_content(request)
+
+        # 검증
+        self.assertIn("title", result)
+        self.assertIn("content", result)
+        self.assertIn("tags", result)
+        # 실제 파싱 로직에 따른 제목 검증 (키워드가 제목에 포함되지 않아 기본 제목 생성됨)
+        self.assertEqual(result["title"], "아이폰 15 투명 케이스 - 아이폰 케이스 완벽 가이드")
+        self.assertIn("<h1>", result["content"])
+        self.assertIn("아이폰 케이스", result["tags"])
+
+    def test_generate_blog_content_api_failure(self):
+        """API 실패 시 폴백 콘텐츠 생성 테스트"""
+        # API 실패 시뮬레이션
+        self.mock_client.chat.completions.create.side_effect = Exception("API Error")
+
+        request = RequestBlogCreate(keyword="테스트 키워드")
+
+        # 실행
+        result = self.service.generate_blog_content(request)
+
+        # 폴백 콘텐츠 검증
+        self.assertIn("title", result)
+        self.assertIn("content", result)
+        self.assertIn("tags", result)
+        self.assertEqual(result["title"], "테스트 키워드 - 완벽 가이드")
+
+    def test_generate_blog_content_minimal_input(self):
+        """최소한의 입력으로 콘텐츠 생성 테스트"""
+        # API 실패 시뮬레이션
+        self.mock_client.chat.completions.create.side_effect = Exception("API Error")
+
+        request = RequestBlogCreate()
+
+        result = self.service.generate_blog_content(request)
+
+        # 기본 콘텐츠 생성 확인
+        self.assertEqual(result["title"], "상품 정보 및 구매 가이드")
+        self.assertIn("<h1>", result["content"])
+        self.assertEqual(result["tags"], ["상품정보", "리뷰"])
\ No newline at end of file
diff --git a/apps/pre-processing-service/app/test/test_product_blog_posting_service.py b/apps/pre-processing-service/app/test/test_product_blog_posting_service.py
deleted file mode 100644
index c5b1efde..00000000
--- a/apps/pre-processing-service/app/test/test_product_blog_posting_service.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import pytest
-from app.service.product_blog_posting_service import (
-    ProductBlogPostingService,
-    BlogContentRequest,
-    ProductData,
-)
-
-# 샘플 데이터
-sample_product_data = {
-    "tag": "test001",
-    "product_url": "https://ssadagu.kr/shop/view.php?platform=1688&num_iid=902500949447",
-    "status": "success",
-    "product_detail": {
-        "url": "https://ssadagu.kr/shop/view.php?platform=1688&num_iid=902500949447",
-        "title": "코닝 적용 가능한 애플 13 강화 필름 iphone16/15promax 휴대 전화 필름 애플 11 안티-peep 및 먼지없는 빈",
-        "price": 430,
-        "rating": 5.0,
-        "options": [
-            {"name": "먼지 없는 창고 2차 필름 [코닝글라스 방폭丨초투명]", "stock": 0},
-            {
-                "name": "먼지 없는 창고 2차 필름 [코닝글라스 방폭丨훔쳐보기 방지]",
-                "stock": 0,
-            },
-        ],
-        "material_info": {
-            "상표": "다른",
-            "재료": "강화 유리",
-            "필름 종류": "전막",
-            "크기": "애플 16프로맥스( 6.9inch )",
-            "적용 모델": "iPhone13 Pro Max",
-        },
-        "product_images": [],
-    },
-    "crawled_at": "2025-09-16 11:49:24",
-}
-
-
-@pytest.fixture
-def blog_service():
-    return ProductBlogPostingService()
-
-
-def test_generate_blog_content(blog_service):
-    """GPT를 통한 블로그 콘텐츠 생성 테스트"""
-    request = BlogContentRequest(
-        content_style="informative",
-        target_keywords=["아이폰", "강화필름", "보호필름", "스마트폰액세서리"],
-        include_pricing=True,
-        content_length="medium",
-    )
-
-    product_obj = ProductData.from_dict(sample_product_data)
-
-    # 순수 콘텐츠 생성만 테스트
-    blog_content = blog_service.content_generator.generate_blog_content(
-        product_obj, request
-    )
-
-    assert blog_content.title
-    assert "<h2>" in blog_content.content
-    assert len(blog_content.tags) > 0
-
-
-def test_post_product_to_blogger(blog_service, monkeypatch):
-    """Blogger 포스팅 테스트 (실제 API 호출을 막고 mock)"""
-
-    class MockBloggerAdapter:
-        def post_content(self, title, content, tags):
-            return {"mock": True}
-
-    monkeypatch.setattr(blog_service, "blogger_service", MockBloggerAdapter())
-
-    request = BlogContentRequest(
-        content_style="informative",
-        target_keywords=["아이폰", "강화필름", "보호필름", "스마트폰액세서리"],
-        include_pricing=True,
-        content_length="medium",
-    )
-
-    product_obj = ProductData.from_dict(sample_product_data)
-
-    result = blog_service.post_product_to_blogger(product_obj, request)
-
-    assert result["status"] == "success"
-    assert result["platform"] == "blogger"
-    assert "title" in result
-    assert "tags" in result

From b7bf20bb3c2e42256c92ed4a78f6bfe74dd9f224 Mon Sep 17 00:00:00 2001
From: thkim7 <xogusrla7@gmail.com>
Date: Wed, 17 Sep 2025 11:28:22 +0900
Subject: [PATCH 3/4] chore: poetry run black .

---
 .../app/service/blog/blog_create_service.py   | 33 ++++++++++++-------
 .../app/test/test_blog_create_service.py      | 15 ++++-----
 2 files changed, 28 insertions(+), 20 deletions(-)

diff --git a/apps/pre-processing-service/app/service/blog/blog_create_service.py b/apps/pre-processing-service/app/service/blog/blog_create_service.py
index b2d61c21..29ce12b7 100644
--- a/apps/pre-processing-service/app/service/blog/blog_create_service.py
+++ b/apps/pre-processing-service/app/service/blog/blog_create_service.py
@@ -101,8 +101,12 @@ def _prepare_content_context(self, request: RequestBlogCreate) -> str:
                         context_parts.append(f"  {i}. {option}")
 
             # 구매 링크
-            if request.product_info.get("url") or request.product_info.get("product_url"):
-                url = request.product_info.get("url") or request.product_info.get("product_url")
+            if request.product_info.get("url") or request.product_info.get(
+                "product_url"
+            ):
+                url = request.product_info.get("url") or request.product_info.get(
+                    "product_url"
+                )
                 context_parts.append(f"- 구매 링크: {url}")
 
         return "\n".join(context_parts) if context_parts else "키워드 기반 콘텐츠 생성"
@@ -112,7 +116,11 @@ def _create_content_prompt(self, context: str, request: RequestBlogCreate) -> st
 
         # 기본 키워드가 없으면 상품 제목에서 추출
         main_keyword = request.keyword
-        if not main_keyword and request.product_info and request.product_info.get("title"):
+        if (
+            not main_keyword
+            and request.product_info
+            and request.product_info.get("title")
+        ):
             main_keyword = request.product_info["title"]
 
         prompt = f"""
@@ -164,7 +172,9 @@ def _generate_with_openai(self, prompt: str) -> str:
             self.logger.error(f"OpenAI API 호출 실패: {e}")
             raise
 
-    def _parse_generated_content(self, content: str, request: RequestBlogCreate) -> Dict[str, Any]:
+    def _parse_generated_content(
+        self, content: str, request: RequestBlogCreate
+    ) -> Dict[str, Any]:
         """생성된 콘텐츠를 파싱하여 구조화"""
 
         # 제목 추출 (첫 번째 h1이나 강조된 줄)
@@ -187,18 +197,16 @@ def _parse_generated_content(self, content: str, request: RequestBlogCreate) ->
         # 키워드가 있으면 제목에 없을 경우 기본 제목 생성
         if request.keyword and request.keyword not in title:
             if request.product_info and request.product_info.get("title"):
-                title = f"{request.product_info['title']} - {request.keyword} 완벽 가이드"
+                title = (
+                    f"{request.product_info['title']} - {request.keyword} 완벽 가이드"
+                )
             else:
                 title = f"{request.keyword} - 완벽 가이드"
 
         # 태그 생성
         tags = self._generate_tags(request)
 
-        return {
-            "title": title,
-            "content": content,
-            "tags": tags
-        }
+        return {"title": title, "content": content, "tags": tags}
 
     def _generate_tags(self, request: RequestBlogCreate) -> List[str]:
         """요청 정보 기반 태그 생성"""
@@ -293,9 +301,10 @@ def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]
         return {
             "title": title,
             "content": content,
-            "tags": self._generate_tags(request)
+            "tags": self._generate_tags(request),
         }
 
+
 # if __name__ == '__main__':
 #     # 테스트용 요청 데이터
 #     test_request = RequestBlogCreate(
@@ -333,4 +342,4 @@ def _create_fallback_content(self, request: RequestBlogCreate) -> Dict[str, Any]
 #     print(f"제목: {result['title']}")
 #     print(f"\n태그: {', '.join(result['tags'])}")
 #     print(f"\n내용:\n{result['content']}")
-#     print(f"\n글자수: {len(result['content'])}자")
\ No newline at end of file
+#     print(f"\n글자수: {len(result['content'])}자")
diff --git a/apps/pre-processing-service/app/test/test_blog_create_service.py b/apps/pre-processing-service/app/test/test_blog_create_service.py
index 0c6d447c..d32e4e9e 100644
--- a/apps/pre-processing-service/app/test/test_blog_create_service.py
+++ b/apps/pre-processing-service/app/test/test_blog_create_service.py
@@ -8,8 +8,8 @@
 class TestBlogContentGeneration(unittest.TestCase):
     """블로그 콘텐츠 생성 핵심 로직 테스트"""
 
-    @patch.dict('os.environ', {'OPENAI_API_KEY': 'test-key'})
-    @patch('app.service.blog.blog_create_service.OpenAI')
+    @patch.dict("os.environ", {"OPENAI_API_KEY": "test-key"})
+    @patch("app.service.blog.blog_create_service.OpenAI")
     def setUp(self, mock_openai_class):
         """테스트 설정 - OpenAI Mock 적용"""
         # Mock OpenAI 클라이언트 설정
@@ -35,10 +35,7 @@ def test_generate_blog_content_success(self):
         # 테스트 요청
         request = RequestBlogCreate(
             keyword="아이폰 케이스",
-            product_info={
-                "title": "아이폰 15 투명 케이스",
-                "price": 25000
-            }
+            product_info={"title": "아이폰 15 투명 케이스", "price": 25000},
         )
 
         # 실행
@@ -49,7 +46,9 @@ def test_generate_blog_content_success(self):
         self.assertIn("content", result)
         self.assertIn("tags", result)
         # 실제 파싱 로직에 따른 제목 검증 (키워드가 제목에 포함되지 않아 기본 제목 생성됨)
-        self.assertEqual(result["title"], "아이폰 15 투명 케이스 - 아이폰 케이스 완벽 가이드")
+        self.assertEqual(
+            result["title"], "아이폰 15 투명 케이스 - 아이폰 케이스 완벽 가이드"
+        )
         self.assertIn("<h1>", result["content"])
         self.assertIn("아이폰 케이스", result["tags"])
 
@@ -81,4 +80,4 @@ def test_generate_blog_content_minimal_input(self):
         # 기본 콘텐츠 생성 확인
         self.assertEqual(result["title"], "상품 정보 및 구매 가이드")
         self.assertIn("<h1>", result["content"])
-        self.assertEqual(result["tags"], ["상품정보", "리뷰"])
\ No newline at end of file
+        self.assertEqual(result["tags"], ["상품정보", "리뷰"])

From 987692d3dbbca8fcbcc35635d536a75eb3ee495f Mon Sep 17 00:00:00 2001
From: thkim7 <xogusrla7@gmail.com>
Date: Wed, 17 Sep 2025 11:42:25 +0900
Subject: [PATCH 4/4] chore: poetry run black .

---
 apps/pre-processing-service/app/utils/llm_extractor.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/apps/pre-processing-service/app/utils/llm_extractor.py b/apps/pre-processing-service/app/utils/llm_extractor.py
index 4263a270..3fb200a5 100644
--- a/apps/pre-processing-service/app/utils/llm_extractor.py
+++ b/apps/pre-processing-service/app/utils/llm_extractor.py
@@ -4,6 +4,7 @@
 
 load_dotenv()
 
+
 class LLMExtractor:
 
     def __init__(self, model="gpt-4o"):