README.md

@@ -69,8 +69,6 @@ PROJECT_DOMAIN=localhost:8000          # 프로젝트 도메인 (호스트:포
 PROJECT_VERSION=0.1.0                  # 프로젝트 버전
 DESCRIPTION=FastAPI 기반 CastAD 프로젝트  # 프로젝트 설명
 ADMIN_BASE_URL=/admin                  # 관리자 페이지 기본 URL
-SHARE_FRONTEND_URL=https://ado2.o2osolution.ai  # 공유 링크가 이동할 프론트엔드 공개 URL
-SHARE_DEFAULT_IMAGE_URL=https://ado2.o2osolution.ai/assets/images/hero-background.png  # 포스터가 없을 때의 절대 이미지 URL
 DEBUG=True                             # 디버그 모드 (True: 개발, False: 운영)
 
 # ================================

app/archive/api/routers/v1/archive.py

@@ -17,11 +17,7 @@ from app.user.models import User
 from app.utils.logger import get_logger
 from app.utils.pagination import PaginatedResponse
 from app.comment.models import Comment
-from app.database.like_cache import (
+from app.database.like_cache import get_like_counts, mset_like_counts
-    bulk_is_user_liked,
-    get_like_counts,
-    mset_like_counts,
-)
 from app.video.models import Video, VideoReaction
 from app.video.schemas.video_schema import VideoListItem
 
@@ -153,24 +149,6 @@ async def get_videos(
                 if vid not in db_found_ids:
                     like_count_map[vid] = 0
 
-        # is_liked_by_me: Redis user-set 기준, 캐시 미스 시 현재 사용자 상태만 DB 조회
-        raw_liked = await bulk_is_user_liked(video_ids, current_user.user_uuid)
-        needs_db_lookup = [
-            vid for vid, liked in raw_liked.items()
-            if liked is None and like_count_map.get(vid, 0) > 0
-        ]
-        if needs_db_lookup:
-            liked_video_ids = set((await session.execute(
-                select(VideoReaction.video_id).where(
-                    VideoReaction.video_id.in_(needs_db_lookup),
-                    VideoReaction.user_uuid == current_user.user_uuid,
-                )
-            )).scalars().all())
-            for vid in needs_db_lookup:
-                raw_liked[vid] = vid in liked_video_ids
-
-        liked_map = {vid: bool(liked) for vid, liked in raw_liked.items()}
-
         # VideoListItem으로 변환
         items = [
             VideoListItem(
@@ -179,11 +157,9 @@ async def get_videos(
                 region=project.region,
                 task_id=video.task_id,
                 result_movie_url=video.result_movie_url,
-                poster_url=video.poster_url,
                 created_at=video.created_at,
                 like_count=like_count_map.get(video.id) or 0,
                 comment_count=comment_count or 0,
-                is_liked_by_me=liked_map.get(video.id, False),
             )
             for video, project, comment_count in rows
         ]

app/comment/api/routers/v1/comment.py

@@ -46,7 +46,7 @@ router = APIRouter(prefix="/comment", tags=["Comment"])
 - **parent_id**: 대댓글일 때만 부모 댓글 id (생략 시 최상위 댓글)
 
 ## 참고
-- 작성자 닉네임/프로필 이미지는 카카오 로그인 정보를 그대로 사용합니다 (클라이언트에서 지정 불가).
+- 작성자 정보는 응답에 포함되지 않습니다 (익명 정책).
 - 대댓글에 또 대댓글을 다는 것은 불가합니다 (최대 2-depth).
     """,
     response_model=CommentCreateResponse,
@@ -71,7 +71,7 @@ async def post_comment(
         session=session,
         video_id=video_id,
         user_uuid=current_user.user_uuid,
-        nickname=current_user.nickname,
+        nickname=body.nickname,
         content=body.content,
         parent_id=body.parent_id,
     )
@@ -79,7 +79,6 @@ async def post_comment(
     return CommentCreateResponse(
         id=comment.id,
         nickname=comment.nickname or "익명",
-        profile_image_url=current_user.profile_image_url,
         parent_id=comment.parent_id,
         content=comment.content,
         created_at=comment.created_at,
@@ -102,7 +101,7 @@ async def post_comment(
 
 ## 참고
 - 최상위 댓글만 페이지네이션됩니다. 각 댓글의 대댓글은 전부 포함됩니다.
-- 작성자 닉네임/프로필 이미지는 카카오 로그인 정보 기준이며, is_mine으로 본인 댓글 여부도 확인 가능합니다.
+- 작성자 정보는 노출되지 않으며, is_mine으로 본인 댓글 여부만 확인 가능합니다.
 - 삭제된 댓글은 content=null로 노출됩니다 (대댓글이 있는 경우).
     """,
     response_model=PaginatedResponse[CommentItem],

app/comment/models.py

@@ -17,8 +17,7 @@ class Comment(Base):
 
     2-depth 구조 (최상위 댓글 + 대댓글 1단계).
     parent_id가 NULL이면 최상위 댓글, 값이 있으면 대댓글.
-    작성자 닉네임은 카카오 로그인 정보를 작성 시점에 그대로 저장한 스냅샷이며,
+    작성자(user_uuid)는 DB에 저장하지만 API 응답에는 미노출 (익명 정책).
-    프로필 이미지는 별도 컬럼 없이 응답 시 User 테이블을 조인해 최신값을 조회한다.
     """
 
     __tablename__ = "comment"
@@ -55,7 +54,7 @@ class Comment(Base):
         comment="NULL=최상위 댓글, 값=대댓글의 부모 id",
     )
     nickname: Mapped[Optional[str]] = mapped_column(
-        String(50), nullable=True, comment="댓글 작성자 카카오 닉네임 스냅샷 (null이면 익명)"
+        String(50), nullable=True, comment="댓글 작성자 닉네임 (null이면 익명)"
     )
     content: Mapped[str] = mapped_column(
         String(100), nullable=False, comment="댓글 본문 (한글 기준 100자 이내)"

app/comment/schemas/comment_schema.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field
 
 
 class CommentCreateRequest(BaseModel):
+    nickname: Optional[str] = Field(None, min_length=1, max_length=50, description="작성자 닉네임 (미입력 시 익명)")
     content: str = Field(..., min_length=1, max_length=100, description="댓글 본문 (한글 기준 100자 이내)")
     parent_id: Optional[int] = Field(None, description="대댓글일 때만 부모 댓글 id")
 
@@ -13,8 +14,7 @@ class ReplyItem(BaseModel):
     """대댓글 응답"""
 
     id: int = Field(..., description="댓글 고유 ID")
-    nickname: str = Field(..., description="작성자 닉네임 (카카오 닉네임, 미보유 시 '익명')")
+    nickname: str = Field(..., description="작성자 닉네임 (미입력 시 '익명')")
-    profile_image_url: Optional[str] = Field(None, description="작성자 프로필 이미지 URL (카카오 프로필, 로그인 시점 기준 최신값)")
     content: Optional[str] = Field(None, description="본문 (소프트 삭제된 경우 null)")
     is_deleted: bool = Field(..., description="삭제 여부")
     is_mine: bool = Field(..., description="현재 로그인 사용자의 댓글 여부")
@@ -25,8 +25,7 @@ class CommentItem(BaseModel):
     """최상위 댓글 응답 — replies 포함"""
 
     id: int = Field(..., description="댓글 고유 ID")
-    nickname: str = Field(..., description="작성자 닉네임 (카카오 닉네임, 미보유 시 '익명')")
+    nickname: str = Field(..., description="작성자 닉네임 (미입력 시 '익명')")
-    profile_image_url: Optional[str] = Field(None, description="작성자 프로필 이미지 URL (카카오 프로필, 로그인 시점 기준 최신값)")
     content: Optional[str] = Field(None, description="본문 (소프트 삭제된 경우 null)")
     is_deleted: bool = Field(..., description="삭제 여부")
     is_mine: bool = Field(..., description="현재 로그인 사용자의 댓글 여부")
@@ -36,8 +35,7 @@ class CommentItem(BaseModel):
 
 class CommentCreateResponse(BaseModel):
     id: int = Field(..., description="생성된 댓글 고유 ID")
-    nickname: str = Field(..., description="작성자 닉네임 (카카오 닉네임, 미보유 시 '익명')")
+    nickname: str = Field(..., description="작성자 닉네임 (미입력 시 '익명')")
-    profile_image_url: Optional[str] = Field(None, description="작성자 프로필 이미지 URL (카카오 프로필)")
     parent_id: Optional[int] = Field(None, description="부모 댓글 id (대댓글인 경우)")
     content: str = Field(..., description="댓글 본문")
     created_at: datetime = Field(..., description="작성 일시")

app/comment/services/comment.py

@@ -7,7 +7,6 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.comment.models import Comment
 from app.comment.schemas.comment_schema import CommentItem, ReplyItem
-from app.user.models import User
 from app.utils.pagination import PaginatedResponse
 from app.video.models import Video
 
@@ -38,7 +37,6 @@ def _build_comment_items(
     parents: list,
     replies_map: dict,
     current_user_uuid: Optional[str],
-    profile_image_map: dict,
 ) -> List[CommentItem]:
     items = []
     for c in parents:
@@ -47,7 +45,6 @@ def _build_comment_items(
             ReplyItem(
                 id=r.id,
                 nickname=r.nickname or "익명",
-                profile_image_url=profile_image_map.get(r.user_uuid),
                 content=None if r.is_deleted else r.content,
                 is_deleted=r.is_deleted,
                 is_mine=(current_user_uuid == r.user_uuid) if current_user_uuid else False,
@@ -59,7 +56,6 @@ def _build_comment_items(
             CommentItem(
                 id=c.id,
                 nickname=c.nickname or "익명",
-                profile_image_url=profile_image_map.get(c.user_uuid),
                 content=None if c.is_deleted else c.content,
                 is_deleted=c.is_deleted,
                 is_mine=(current_user_uuid == c.user_uuid) if current_user_uuid else False,
@@ -74,7 +70,7 @@ async def create_comment(
     session: AsyncSession,
     video_id: int,
     user_uuid: str,
-    nickname: Optional[str],
+    nickname: str,
     content: str,
     parent_id: Optional[int],
 ) -> Comment:
@@ -147,7 +143,6 @@ async def list_comments(
     parents = (await session.execute(parents_q)).scalars().all()
 
     replies_map: dict = defaultdict(list)
-    replies: list = []
     if parents:
         parent_ids = [c.id for c in parents]
         replies_q = (
@@ -162,16 +157,7 @@ async def list_comments(
         for r in replies:
             replies_map[r.parent_id].append(r)
 
-    # 작성자 프로필 이미지는 스냅샷을 저장하지 않고, 응답 시 User 테이블을 조인해 최신값을 조회한다.
+    items = _build_comment_items(list(parents), replies_map, current_user_uuid)
-    user_uuids = {c.user_uuid for c in parents} | {r.user_uuid for r in replies}
-    profile_image_map: dict = {}
-    if user_uuids:
-        profile_q = select(User.user_uuid, User.profile_image_url).where(
-            User.user_uuid.in_(user_uuids)
-        )
-        profile_image_map = {uuid: url for uuid, url in (await session.execute(profile_q)).all()}
-
-    items = _build_comment_items(list(parents), replies_map, current_user_uuid, profile_image_map)
 
     return PaginatedResponse.create(
         items=items,

app/utils/video_poster.py

@@ -1,173 +0,0 @@
-"""영상 파일에서 SNS 공유용 포스터 이미지를 생성하고 저장합니다."""
-
-import asyncio
-from pathlib import Path
-
-from app.utils.logger import get_logger
-from app.utils.upload_blob_as_request import AzureBlobUploader
-
-logger = get_logger("video_poster")
-
-FFMPEG_TIMEOUT_SECONDS = 30.0
-FFMPEG_CLEANUP_TIMEOUT_SECONDS = 5.0
-_STDERR_LOG_LIMIT = 500
-
-
-async def _kill_and_wait(process: asyncio.subprocess.Process) -> None:
-    """실행 중인 ffmpeg 프로세스를 종료하고 자원을 회수합니다."""
-    try:
-        process.kill()
-    except ProcessLookupError:
-        pass
-    except Exception as exc:
-        logger.warning(
-            "[video_poster] ffmpeg 프로세스 종료에 실패했습니다: %s",
-            exc,
-        )
-
-    try:
-        await asyncio.wait_for(
-            process.wait(),
-            timeout=FFMPEG_CLEANUP_TIMEOUT_SECONDS,
-        )
-    except TimeoutError:
-        logger.warning(
-            "[video_poster] 종료한 ffmpeg 프로세스 회수 시간이 초과되었습니다 "
-            "(timeout=%ss)",
-            FFMPEG_CLEANUP_TIMEOUT_SECONDS,
-        )
-    except Exception as exc:
-        logger.warning(
-            "[video_poster] ffmpeg 프로세스 회수에 실패했습니다: %s",
-            exc,
-        )
-
-
-def _format_stderr(stderr: bytes) -> str:
-    """ffmpeg 표준 오류를 로그에 안전한 길이의 문자열로 변환합니다."""
-    return stderr.decode("utf-8", errors="replace").strip()[-_STDERR_LOG_LIMIT:]
-
-
-async def extract_first_frame(video_path: str | Path) -> bytes | None:
-    """로컬 영상의 첫 프레임을 JPEG 바이트로 추출하고 실패 시 ``None``을 반환합니다."""
-    process: asyncio.subprocess.Process | None = None
-
-    try:
-        process = await asyncio.create_subprocess_exec(
-            "ffmpeg",
-            "-nostdin",
-            "-hide_banner",
-            "-loglevel",
-            "error",
-            "-i",
-            str(video_path),
-            "-frames:v",
-            "1",
-            "-f",
-            "image2pipe",
-            "-c:v",
-            "mjpeg",
-            "pipe:1",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-
-        try:
-            stdout, stderr = await asyncio.wait_for(
-                process.communicate(),
-                timeout=FFMPEG_TIMEOUT_SECONDS,
-            )
-        except TimeoutError:
-            await _kill_and_wait(process)
-            logger.warning(
-                "[video_poster] ffmpeg 첫 프레임 추출 시간이 초과되었습니다 "
-                "(path=%s, timeout=%ss)",
-                video_path,
-                FFMPEG_TIMEOUT_SECONDS,
-            )
-            return None
-
-        if process.returncode != 0:
-            logger.warning(
-                "[video_poster] ffmpeg 첫 프레임 추출에 실패했습니다 "
-                "(path=%s, returncode=%s, stderr=%s)",
-                video_path,
-                process.returncode,
-                _format_stderr(stderr),
-            )
-            return None
-
-        if not stdout:
-            logger.warning(
-                "[video_poster] ffmpeg가 빈 이미지를 반환했습니다 (path=%s)",
-                video_path,
-            )
-            return None
-
-        return stdout
-
-    except asyncio.CancelledError:
-        if process is not None:
-            await _kill_and_wait(process)
-        raise
-    except Exception as exc:
-        if process is not None:
-            await _kill_and_wait(process)
-        logger.warning(
-            "[video_poster] 첫 프레임 추출 중 오류가 발생했습니다 "
-            "(path=%s, error=%s: %s)",
-            video_path,
-            type(exc).__name__,
-            exc,
-        )
-        return None
-
-
-async def generate_and_store_poster(
-    *,
-    video_path: str | Path,
-    user_uuid: str,
-    task_id: str,
-    file_stem: str,
-) -> str | None:
-    """첫 프레임을 Blob에 저장하고 공개 URL을 반환하며, 실패 시 ``None``을 반환합니다."""
-    try:
-        image_bytes = await extract_first_frame(video_path)
-        if image_bytes is None:
-            return None
-
-        uploader = AzureBlobUploader(user_uuid=user_uuid, task_id=task_id)
-        uploaded = await uploader.upload_image_bytes(
-            image_bytes,
-            f"{file_stem}.jpg",
-        )
-        if not uploaded:
-            logger.warning(
-                "[video_poster] 포스터 Blob 업로드에 실패했습니다 "
-                "(path=%s, task_id=%s)",
-                video_path,
-                task_id,
-            )
-            return None
-
-        if not uploader.public_url:
-            logger.warning(
-                "[video_poster] 포스터 업로드 후 공개 URL이 비어 있습니다 "
-                "(path=%s, task_id=%s)",
-                video_path,
-                task_id,
-            )
-            return None
-
-        return uploader.public_url
-
-    except Exception as exc:
-        logger.warning(
-            "[video_poster] 포스터 생성 또는 저장 중 오류가 발생했습니다 "
-            "(path=%s, task_id=%s, error=%s: %s)",
-            video_path,
-            task_id,
-            type(exc).__name__,
-            exc,
-        )
-        return None

app/video/api/routers/v1/video.py

@@ -17,8 +17,7 @@ import json
 from collections import defaultdict
 from typing import Literal
 
-from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query, Request
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query
-from fastapi.responses import HTMLResponse
 from sqlalchemy import func, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
@@ -58,11 +57,10 @@ from app.video.schemas.video_schema import (
     VideoRenderData,
     VideoThumbnailItem,
 )
-from app.video.services.share_page import build_video_share_html, get_video_share_data
 from app.video.worker.video_task import download_and_upload_video_to_blob
 
 
-from config import creatomate_settings, prj_settings
+from config import creatomate_settings
 
 logger = get_logger("video")
 
@@ -989,7 +987,6 @@ async def get_all_videos(
                 video_id=v.id,
                 store_name=p.store_name,
                 result_movie_url=v.result_movie_url,
-                poster_url=v.poster_url,
                 created_at=v.created_at,
                 like_count=like_count_map.get(v.id) or 0,
                 is_liked_by_me=liked_map.get(v.id, False),
@@ -1093,43 +1090,6 @@ async def toggle_like(
         raise HTTPException(status_code=500, detail=f"좋아요 처리에 실패했습니다: {str(e)}")
 
 
-@router.get(
-    "/share/{video_id}",
-    response_class=HTMLResponse,
-    summary="영상 공유용 Open Graph 페이지",
-    description="영상별 제목, 설명, 포스터 메타데이터가 포함된 공개 HTML을 반환합니다.",
-    responses={
-        200: {"description": "공유 메타데이터 HTML 반환"},
-        404: {"description": "공유 가능한 완료 영상을 찾을 수 없음"},
-    },
-)
-async def get_video_share_page(
-    video_id: int,
-    request: Request,
-    session: AsyncSession = Depends(get_session),
-) -> HTMLResponse:
-    """공개 공유 페이지를 반환하고 일반 브라우저는 영상 상세로 이동시킵니다."""
-    share_data = await get_video_share_data(session, video_id)
-    if share_data is None:
-        raise HTTPException(status_code=404, detail="공유 가능한 영상을 찾을 수 없습니다.")
-
-    share_url = str(request.url).split("?", maxsplit=1)[0]
-    html = build_video_share_html(
-        share_data,
-        share_url=share_url,
-        frontend_base_url=prj_settings.SHARE_FRONTEND_URL,
-        configured_default_image_url=prj_settings.SHARE_DEFAULT_IMAGE_URL,
-    )
-    return HTMLResponse(
-        content=html,
-        headers={
-            "Cache-Control": "public, max-age=300",
-            "Referrer-Policy": "no-referrer",
-            "X-Content-Type-Options": "nosniff",
-        },
-    )
-
-
 @router.get(
     "/{video_id}",
     summary="단일 영상 상세 조회",
@@ -1206,7 +1166,6 @@ async def get_video_detail(
         return VideoDetailResponse(
             video_id=video.id,
             result_movie_url=video.result_movie_url,
-            poster_url=video.poster_url,
             store_name=project.store_name,
             region=project.region or _extract_region_from_address(project.detail_region_info),
             created_at=video.created_at,

app/video/models.py

@@ -29,7 +29,6 @@ class Video(Base):
         task_id: 영상 생성 작업의 고유 식별자 (UUID7 형식)
         status: 처리 상태 (pending, processing, completed, failed 등)
         result_movie_url: 생성된 영상 URL (S3, CDN 경로)
-        poster_url: 영상 첫 프레임 포스터 이미지 URL (SNS 공유 og:image용)
         created_at: 생성 일시 (자동 설정)
 
     Relationships:
@@ -107,12 +106,6 @@ class Video(Base):
         comment="생성된 영상 URL",
     )
 
-    poster_url: Mapped[Optional[str]] = mapped_column(
-        String(2048),
-        nullable=True,
-        comment="영상 첫 프레임 포스터 이미지 URL (SNS 공유용)",
-    )
-
     is_deleted: Mapped[bool] = mapped_column(
         Boolean,
         nullable=False,

app/video/schemas/video_schema.py

@@ -148,7 +148,6 @@ class VideoListItem(BaseModel):
             "region": "군산",
             "task_id": "019123ab-cdef-7890-abcd-ef1234567890",
             "result_movie_url": "http://localhost:8000/media/2025-01-15/video.mp4",
-            "poster_url": "http://localhost:8000/media/2025-01-15/video.jpg",
             "created_at": "2025-01-15T12:00:00"
         }
     """
@@ -158,14 +157,9 @@ class VideoListItem(BaseModel):
     region: Optional[str] = Field(None, description="지역명")
     task_id: str = Field(..., description="작업 고유 식별자")
     result_movie_url: Optional[str] = Field(None, description="영상 결과 URL")
-    poster_url: Optional[str] = Field(None, description="영상 첫 프레임 포스터 이미지 URL")
     created_at: Optional[datetime] = Field(None, description="생성 일시")
     like_count: int = Field(0, description="좋아요 수")
     comment_count: int = Field(0, description="댓글 수 (대댓글 포함)")
-    is_liked_by_me: bool = Field(
-        False,
-        description="현재 로그인 사용자가 좋아요를 눌렀는지",
-    )
 
 
 class VideoThumbnailItem(BaseModel):
@@ -177,8 +171,7 @@ class VideoThumbnailItem(BaseModel):
 
     video_id: int = Field(..., description="영상 고유 ID (상세 페이지 라우팅 키)")
     store_name: str = Field(..., description="업체명")
-    result_movie_url: str = Field(..., description="영상 URL")
+    result_movie_url: str = Field(..., description="영상 URL — 프론트에서 <video> 태그 첫 프레임을 썸네일로 사용")
-    poster_url: Optional[str] = Field(None, description="영상 첫 프레임 포스터 이미지 URL (썸네일 표시용)")
     created_at: datetime = Field(..., description="생성 일시")
     like_count: int = Field(..., description="좋아요 수")
     is_liked_by_me: bool = Field(..., description="현재 로그인 사용자가 좋아요를 눌렀는지 (비로그인은 항상 false)")
@@ -194,7 +187,6 @@ class VideoDetailResponse(BaseModel):
 
     video_id: int = Field(..., description="영상 고유 ID")
     result_movie_url: str = Field(..., description="영상 URL")
-    poster_url: Optional[str] = Field(None, description="영상 첫 프레임 포스터 이미지 URL")
     store_name: Optional[str] = Field(None, description="업체명")
     region: Optional[str] = Field(None, description="지역명")
     created_at: datetime = Field(..., description="생성 일시")

app/video/services/share_page.py

@@ -1,161 +0,0 @@
-"""영상 공유 링크용 Open Graph HTML 생성 서비스."""
-
-from dataclasses import dataclass
-from html import escape
-from urllib.parse import urlsplit, urlunsplit
-
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.home.models import Project
-from app.video.models import Video
-
-FALLBACK_FRONTEND_URL = "https://ado2.o2osolution.ai"
-DEFAULT_SHARE_IMAGE_PATH = "/assets/images/hero-background.png"
-
-
-@dataclass(frozen=True, slots=True)
-class VideoShareData:
-    """공유 페이지에 필요한 영상 및 프로젝트 정보."""
-
-    video_id: int
-    poster_url: str | None
-    store_name: str
-    region: str
-
-
-async def get_video_share_data(
-    session: AsyncSession,
-    video_id: int,
-) -> VideoShareData | None:
-    """공유 가능한 완료 영상을 프로젝트 정보와 함께 조회합니다."""
-    result = await session.execute(
-        select(
-            Video.id,
-            Video.poster_url,
-            Project.store_name,
-            Project.region,
-        )
-        .join(Project, Video.project_id == Project.id)
-        .where(
-            Video.id == video_id,
-            Video.status == "completed",
-            Video.is_deleted.is_(False),
-            Project.is_deleted.is_(False),
-        )
-    )
-    row = result.one_or_none()
-    if row is None:
-        return None
-
-    return VideoShareData(
-        video_id=row.id,
-        poster_url=row.poster_url,
-        store_name=row.store_name,
-        region=row.region,
-    )
-
-
-def build_video_share_html(
-    data: VideoShareData,
-    *,
-    share_url: str,
-    frontend_base_url: str,
-    configured_default_image_url: str = "",
-) -> str:
-    """영상별 OG 메타데이터와 상세 화면 이동 기능을 포함한 HTML을 생성합니다."""
-    frontend_base = _normalise_frontend_base_url(frontend_base_url)
-    detail_url = f"{frontend_base}/video/{data.video_id}"
-    fallback_image_url = _resolve_default_image_url(
-        configured_default_image_url,
-        frontend_base,
-    )
-    image_url = _absolute_http_url(data.poster_url) or fallback_image_url
-
-    store_name = _normalise_text(data.store_name, "ADO2 영상")
-    region = _normalise_text(data.region, "")
-    title = f"{store_name} | ADO2"
-    description = (
-        f"{region} · ADO2 AI 마케팅 영상"
-        if region
-        else "ADO2 AI 마케팅 영상"
-    )
-
-    escaped_title = escape(title, quote=True)
-    escaped_description = escape(description, quote=True)
-    escaped_image_url = escape(image_url, quote=True)
-    escaped_share_url = escape(_absolute_http_url(share_url) or detail_url, quote=True)
-    escaped_detail_url = escape(detail_url, quote=True)
-
-    return f"""<!doctype html>
-<html lang="ko">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>{escaped_title}</title>
-  <meta name="description" content="{escaped_description}">
-  <link rel="canonical" href="{escaped_share_url}">
-
-  <meta property="og:title" content="{escaped_title}">
-  <meta property="og:description" content="{escaped_description}">
-  <meta property="og:image" content="{escaped_image_url}">
-  <meta property="og:image:alt" content="{escaped_title}">
-  <meta property="og:url" content="{escaped_share_url}">
-  <meta property="og:type" content="video.other">
-
-  <meta name="twitter:card" content="summary_large_image">
-  <meta name="twitter:title" content="{escaped_title}">
-  <meta name="twitter:description" content="{escaped_description}">
-  <meta name="twitter:image" content="{escaped_image_url}">
-
-</head>
-<body>
-  <main>
-    <h1>{escaped_title}</h1>
-    <p>{escaped_description}</p>
-    <a id="continue-link" href="{escaped_detail_url}">영상 보기</a>
-  </main>
-  <script>
-    window.location.replace(document.getElementById("continue-link").href);
-  </script>
-</body>
-</html>
-"""
-
-
-def _normalise_text(value: str | None, fallback: str) -> str:
-    """메타데이터용 텍스트에서 불필요한 공백을 제거합니다."""
-    normalised = " ".join((value or "").split())
-    return normalised or fallback
-
-
-def _normalise_frontend_base_url(value: str) -> str:
-    """프론트엔드 기준 URL을 안전한 절대 HTTP(S) URL로 정규화합니다."""
-    absolute_url = _absolute_http_url(value) or FALLBACK_FRONTEND_URL
-    parts = urlsplit(absolute_url)
-    path = parts.path.rstrip("/")
-    return urlunsplit((parts.scheme, parts.netloc, path, "", ""))
-
-
-def _resolve_default_image_url(configured_url: str, frontend_base: str) -> str:
-    """설정된 기본 이미지 또는 프론트엔드의 공개 기본 이미지를 반환합니다."""
-    configured_absolute_url = _absolute_http_url(configured_url)
-    if configured_absolute_url:
-        return configured_absolute_url
-    return f"{frontend_base}{DEFAULT_SHARE_IMAGE_PATH}"
-
-
-def _absolute_http_url(value: str | None) -> str | None:
-    """값이 절대 HTTP(S) URL인 경우에만 정리된 문자열을 반환합니다."""
-    candidate = (value or "").strip()
-    if not candidate:
-        return None
-
-    try:
-        parts = urlsplit(candidate)
-    except ValueError:
-        return None
-
-    if parts.scheme.lower() not in {"http", "https"} or not parts.hostname:
-        return None
-    return candidate

app/video/worker/video_task.py

@@ -4,6 +4,7 @@ Video Background Tasks
 영상 생성 관련 백그라운드 태스크를 정의합니다.
 """
 
+import traceback
 from pathlib import Path
 
 import aiofiles
@@ -16,7 +17,6 @@ from app.user.services.credit import consume_credit
 from app.video.models import Video
 from app.utils.upload_blob_as_request import AzureBlobUploader
 from app.utils.logger import get_logger
-from app.utils.video_poster import generate_and_store_poster
 
 # 로거 설정
 logger = get_logger("video")
@@ -30,7 +30,6 @@ async def _update_video_status(
     status: str,
     video_url: str | None = None,
     creatomate_render_id: str | None = None,
-    poster_url: str | None = None,
 ) -> bool:
     """Video 테이블의 상태를 업데이트합니다.
 
@@ -39,7 +38,6 @@ async def _update_video_status(
         status: 변경할 상태 ("processing", "completed", "failed")
         video_url: 영상 URL
         creatomate_render_id: Creatomate render ID (선택)
-        poster_url: 영상 첫 프레임 포스터 URL (선택)
 
     Returns:
         bool: 업데이트 성공 여부
@@ -67,8 +65,6 @@ async def _update_video_status(
                 video.status = status
                 if video_url is not None:
                     video.result_movie_url = video_url
-                if poster_url is not None:
-                    video.poster_url = poster_url
                 await session.commit()
                 logger.info(f"[Video] Status updated - task_id: {task_id}, status: {status}")
                 return True
@@ -84,28 +80,6 @@ async def _update_video_status(
         return False
 
 
-async def _try_generate_poster(
-    temp_file_path: Path,
-    user_uuid: str,
-    task_id: str,
-    render_id: str,
-) -> str | None:
-    """포스터 생성 실패가 영상 생성 완료 처리에 영향을 주지 않도록 격리합니다."""
-    try:
-        return await generate_and_store_poster(
-            video_path=temp_file_path,
-            user_uuid=user_uuid,
-            task_id=task_id,
-            file_stem=render_id,
-        )
-    except Exception as e:
-        logger.warning(
-            f"[VideoPoster] Failed to generate poster - task_id: {task_id}, render_id: {render_id}, error: {e}",
-            exc_info=True,
-        )
-        return None
-
-
 async def _download_video(url: str, task_id: str) -> bytes:
     """URL에서 영상을 다운로드합니다.
 
@@ -179,18 +153,8 @@ async def download_and_upload_video_to_blob(
         blob_url = uploader.public_url
         logger.info(f"[download_and_upload_video_to_blob] Uploaded to Blob - task_id: {task_id}, url: {blob_url}")
 
-        poster_url = await _try_generate_poster(
-            temp_file_path, user_uuid, task_id, creatomate_render_id
-        )
-
         # Video 테이블 업데이트 (creatomate_render_id로 특정 Video 식별)
-        await _update_video_status(
+        await _update_video_status(task_id, "completed", blob_url, creatomate_render_id)
-            task_id,
-            "completed",
-            blob_url,
-            creatomate_render_id,
-            poster_url=poster_url,
-        )
 
         # 영상 생성 완료 시 크레딧 1 차감 (credits > 0 조건으로 음수 방지)
         async with BackgroundSessionLocal() as session:
@@ -295,17 +259,12 @@ async def download_and_upload_video_by_creatomate_render_id(
         blob_url = uploader.public_url
         logger.info(f"[download_and_upload_video_by_creatomate_render_id] Uploaded to Blob - creatomate_render_id: {creatomate_render_id}, url: {blob_url}")
 
-        poster_url = await _try_generate_poster(
-            temp_file_path, user_uuid, task_id, creatomate_render_id
-        )
-
         # Video 테이블 업데이트
         await _update_video_status(
             task_id=task_id,
             status="completed",
             video_url=blob_url,
             creatomate_render_id=creatomate_render_id,
-            poster_url=poster_url,
         )
         logger.info(f"[download_and_upload_video_by_creatomate_render_id] SUCCESS - creatomate_render_id: {creatomate_render_id}")
 

config.py

@@ -33,14 +33,6 @@ class ProjectSettings(BaseSettings):
     ADMIN_BASE_URL: str = Field(default="/admin")
     ADMIN_SESSION_SECRET: str = Field(default="dev-secret-change-me-in-production")
     ADMIN_SESSION_MAX_AGE: int = Field(default=60 * 60 * 8)
-    SHARE_FRONTEND_URL: str = Field(
-        default="https://ado2.o2osolution.ai",
-        description="영상 공유 링크가 이동할 프론트엔드 공개 기준 URL",
-    )
-    SHARE_DEFAULT_IMAGE_URL: str = Field(
-        default="https://ado2.o2osolution.ai/assets/images/hero-background.png",
-        description="포스터가 없는 영상 공유 시 사용할 절대 이미지 URL",
-    )
     DEBUG: bool = Field(default=True)
     TIMEZONE: str = Field(
         default="Asia/Seoul",

docs/database-schema/migration_2026_08_13_add_video_poster_url.sql

@@ -1,10 +0,0 @@
--- ============================================================
--- Migration: video 테이블에 poster_url 컬럼 추가
--- Date: 2026-08-13
--- Description: 영상 첫 프레임 포스터 이미지 URL. SNS 공유 og:image 용도.
---              관련 코드: app/utils/video_poster.py, app/video/worker/video_task.py
--- ============================================================
-
-ALTER TABLE `video`
-    ADD COLUMN `poster_url` VARCHAR(2048) NULL
-    COMMENT '영상 첫 프레임 포스터 이미지 URL (SNS 공유 og:image용)' AFTER `result_movie_url`;