e467e76d02
- Replace static articles array with dynamic source_keyword queries
- Use MongoDB _id as unique identifier for outlets
- Add multilingual translations (9 languages: ko, en, zh_cn, zh_tw, ja, fr, de, es, it)
- Add OutletService for database operations
- Add outlet migration script with Korean source_keyword matching
- Remove JSON file-based outlet loading
- Add /outlets/{outlet_id}/articles endpoint for dynamic article retrieval
This resolves the design issues with:
1. Static articles array requiring constant updates
2. Lack of multilingual support for outlet names/descriptions
3. Broken image URLs
4. Korean entity matching for article queries
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude <noreply@anthropic.com>
135 lines
5.1 KiB
Python
135 lines
5.1 KiB
Python
from fastapi import APIRouter, HTTPException, Query
|
|
from typing import Optional
|
|
from app.services.article_service import ArticleService
|
|
from app.services.comment_service import CommentService
|
|
from app.services.outlet_service import OutletService
|
|
from app.models.article import ArticleList, Article, ArticleSummary
|
|
from app.models.comment import Comment, CommentCreate, CommentList
|
|
from app.models.outlet import Outlet
|
|
from typing import List
|
|
|
|
router = APIRouter()
|
|
|
|
@router.get("/{language}/articles", response_model=ArticleList)
|
|
async def get_articles(
|
|
language: str,
|
|
page: int = Query(1, ge=1, description="Page number"),
|
|
page_size: int = Query(20, ge=1, le=100, description="Items per page"),
|
|
category: Optional[str] = Query(None, description="Filter by category")
|
|
):
|
|
"""기사 목록 조회"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
return await ArticleService.get_articles(language, page, page_size, category)
|
|
|
|
@router.get("/{language}/articles/latest", response_model=List[ArticleSummary])
|
|
async def get_latest_articles(
|
|
language: str,
|
|
limit: int = Query(10, ge=1, le=50, description="Number of articles")
|
|
):
|
|
"""최신 기사 조회"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
return await ArticleService.get_latest_articles(language, limit)
|
|
|
|
@router.get("/{language}/articles/search", response_model=ArticleList)
|
|
async def search_articles(
|
|
language: str,
|
|
q: str = Query(..., min_length=1, description="Search keyword"),
|
|
page: int = Query(1, ge=1, description="Page number"),
|
|
page_size: int = Query(20, ge=1, le=100, description="Items per page")
|
|
):
|
|
"""기사 검색"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
return await ArticleService.search_articles(language, q, page, page_size)
|
|
|
|
@router.get("/{language}/articles/{article_id}", response_model=Article)
|
|
async def get_article_by_id(
|
|
language: str,
|
|
article_id: str
|
|
):
|
|
"""ID로 기사 조회"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
article = await ArticleService.get_article_by_id(language, article_id)
|
|
if not article:
|
|
raise HTTPException(status_code=404, detail="Article not found")
|
|
|
|
return article
|
|
|
|
@router.get("/{language}/categories", response_model=List[str])
|
|
async def get_categories(language: str):
|
|
"""카테고리 목록 조회"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
return await ArticleService.get_categories(language)
|
|
|
|
@router.get("/outlets")
|
|
async def get_outlets(category: Optional[str] = Query(None, description="Filter by category: people, topics, companies")):
|
|
"""Get outlets list - people, topics, companies"""
|
|
if category:
|
|
# Get outlets for specific category
|
|
outlets = await OutletService.get_all_outlets(category=category)
|
|
return {category: outlets}
|
|
|
|
# Get all outlets grouped by category
|
|
result = {}
|
|
for cat in ['people', 'topics', 'companies']:
|
|
outlets = await OutletService.get_all_outlets(category=cat)
|
|
result[cat] = outlets
|
|
|
|
return result
|
|
|
|
@router.get("/outlets/{outlet_id}")
|
|
async def get_outlet_by_id(outlet_id: str):
|
|
"""Get specific outlet by ID (_id)"""
|
|
outlet = await OutletService.get_outlet_by_id(outlet_id)
|
|
return outlet
|
|
|
|
@router.get("/{language}/outlets/{outlet_id}/articles")
|
|
async def get_outlet_articles(
|
|
language: str,
|
|
outlet_id: str,
|
|
page: int = Query(1, ge=1, description="Page number"),
|
|
page_size: int = Query(20, ge=1, le=100, description="Items per page")
|
|
):
|
|
"""Get articles for a specific outlet using source_keyword"""
|
|
if not ArticleService.validate_language(language):
|
|
raise HTTPException(status_code=400, detail=f"Unsupported language: {language}")
|
|
|
|
# Get outlet to retrieve source_keyword
|
|
outlet = await OutletService.get_outlet_by_id(outlet_id)
|
|
|
|
# Query articles by source_keyword dynamically
|
|
articles_result = await ArticleService.get_articles_by_source_keyword(
|
|
language,
|
|
outlet['source_keyword'],
|
|
page,
|
|
page_size
|
|
)
|
|
|
|
return articles_result
|
|
|
|
# Comment endpoints
|
|
@router.get("/comments", response_model=CommentList)
|
|
async def get_comments(article_id: str = Query(..., alias="articleId")):
|
|
"""Get comments for an article"""
|
|
return await CommentService.get_comments_by_article(article_id)
|
|
|
|
@router.post("/comments", response_model=Comment)
|
|
async def create_comment(comment: CommentCreate):
|
|
"""Create a new comment"""
|
|
return await CommentService.create_comment(comment)
|
|
|
|
@router.get("/articles/{article_id}/comment-count")
|
|
async def get_comment_count(article_id: str):
|
|
"""Get comment count for an article"""
|
|
count = await CommentService.get_comment_count(article_id)
|
|
return {"count": count}
|