o2o-site-AEO/solution/backend/services/site_service.py

import json
import uuid

from fastapi import Depends

from common.database.db_session_manager import DB_SESSION_MNG
from common.database.model.models import places, site_publish_logs, site_versions, sites
from common.enums import (
    BuildStatus,
    DBWRType,
    ErrorType,
    JobStatus,
    JobType,
    PublishAction,
    PublishResult,
    SiteStatus,
)
from common.logger import LOG
from common.template_catalog import is_allowed
from common.models.gmodel import PageParams, UserInfo
from common.utils.gtime import GTime
from crud.job_crud import JobQueue
from crud.place_crud import PlaceCRUD
from crud.site_crud import ISiteCRUD, SiteCRUD
from router.v1.site.protocol import (
    MySiteData,
    PublishLogData,
    RenderStatusData,
    Req_SiteSlug,
    Req_SiteStatus,
    Req_SiteTemplate,
    Req_SiteTheme,
    Req_Rollback,
    Req_StartBuild,
    Res_MySites,
    Res_PublishLogs,
    Res_Site,
    Res_SeoAudit,
    Res_SiteSlug,
    Res_SiteVersions,
    Res_SlugCheck,
    Res_StartBuild,
    SiteData,
    SiteVersionData,
)
from services import render_report, site_payload, site_slug
from services.job_service import enqueue_job

# 주소 저장을 거부할 때 쓰는 결과 코드.
_ERROR_BY_SLUG_REASON = {
    site_slug.REASON_LENGTH: ErrorType.INVALID_REQUEST_DATA,
    site_slug.REASON_FORMAT: ErrorType.INVALID_REQUEST_DATA,
    site_slug.REASON_RESERVED: ErrorType.INVALID_REQUEST_DATA,
    site_slug.REASON_TAKEN: ErrorType.DB_ALREADY_SAME_KEY,
    site_slug.REASON_LOCKED: ErrorType.SITE_SLUG_LOCKED,
}

# 테마 JSON 직렬화 크기 상한(64KB).
_THEME_MAX_BYTES = 64 * 1024

# theme 안에 들어와도 저장하지 않는 키.
_THEME_OWNED_ELSEWHERE = ("templateId", "template_id")

# '거부' 표식.
_THEME_REJECTED = object()

# 상태 전이만으로 처리하는 액션 — ★ 물리 삭제 경로는 만들지 않는다.
_STATUS_BY_ACTION = {
    PublishAction.SUSPEND: SiteStatus.SUSPENDED,
    PublishAction.RESUME: SiteStatus.PUBLISHED,
    PublishAction.UNPUBLISH: SiteStatus.UNPUBLISHED,
}


class SiteService:
    """사이트 조회 · 빌드 트리거 · 발행 상태 전이."""

    def __init__(
        self,
        crud: ISiteCRUD = Depends(SiteCRUD),
        place_crud: PlaceCRUD = Depends(PlaceCRUD),
        queue: JobQueue = Depends(JobQueue),
    ):
        self.crud = crud
        self.place_crud = place_crud
        self.queue = queue

    async def _load_place(self, user_info: UserInfo, place_id: str):
        err_type, place = await DB_SESSION_MNG.execute_lambda(
            places.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.place_crud.get_place(s, uuid.UUID(user_info.user_id), uuid.UUID(place_id)),
        )
        if err_type != ErrorType.SUCCESS:
            return ErrorType.PLACE_NOT_FOUND, None
        return ErrorType.SUCCESS, place

    async def _get_site(self, place_id: str):
        """사업장의 사이트 행."""
        pid = uuid.UUID(place_id)
        err_type, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_place(s, pid)
        )
        return site if err_type == ErrorType.SUCCESS else None

    async def get_seo_audit(self, user_info: UserInfo, place_id: str) -> Res_SeoAudit:
        """현재 저장값 기준 SEO/AEO 준비도."""
        from sqlalchemy import select
        from services.seo_audit import evaluate
        from services.snapshot import build_snapshot

        res = Res_SeoAudit()
        err_type, place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        site = await self._get_site(place_id)
        version = None
        if site is not None and site.current_version_id:
            v_err, version = await DB_SESSION_MNG.execute_lambda(
                site_versions.DBType(), DBWRType.DB_READ.value,
                lambda s: self.crud.get_version(s, site.site_id, site.current_version_id),
            )
            if v_err != ErrorType.SUCCESS:
                version = None

        # AI 노출 점검 이력은 읽지 않는다.
        report = evaluate(
            await build_snapshot(place), verified=place.verified_at is not None,
            site=site, version=version, ai_checks=[],
        )
        return Res_SeoAudit(**report)

    async def preview_payload(self, user_info: UserInfo, place_id: str) -> dict | None:
        """에디터 미리보기가 쓰는 **발행본과 똑같은 payload**."""
        from services.build_service import ensure_site, load_channel_links
        from services.site_payload import prepare_site_payload
        from services.snapshot import build_snapshot

        err_type, place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS or place is None:
            return None

        site = await ensure_site(place_id)
        links = await load_channel_links(place_id)
        snapshot = await build_snapshot(place)
        # version 은 None 이다.
        return await prepare_site_payload(place, snapshot, site, None, links)

    # --- 사이트 주소(네임스페이스) --------------------------------------- 규칙(정규식·예약어)은 services/site_slug 한 곳에만 있다.

    async def _domain_owner(self, slug: str):
        """이 주소를 이미 쓰는 사업장 id."""
        err_type, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_domain(s, slug)
        )
        if err_type != ErrorType.SUCCESS or site is None:
            return None
        return str(site.place_id)

    async def _suggest(self, slug: str):
        """`-2`, `-3` … 중 실제로 비어 있는 것 하나."""
        candidates = site_slug.suggestions(slug)
        if not candidates:
            return None
        err_type, taken = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.taken_domains(s, candidates)
        )
        if err_type != ErrorType.SUCCESS:
            return None
        return next((c for c in candidates if c not in taken), None)

    async def _judge_slug(self, place_id: str, slug: str):
        """(불가 사유, 대안)을 돌려준다."""
        reason = site_slug.validate_slug(slug)
        if reason in (site_slug.REASON_LENGTH, site_slug.REASON_FORMAT):
            # 형식이 깨진 값에 -2 를 붙여 봐야 여전히 못 쓴다.
            return reason, None

        value = (slug or "").strip()
        # 주인 확인이 예약어보다 먼저다.
        owner = await self._domain_owner(value)
        if owner is not None and owner == str(uuid.UUID(place_id)):
            return None, None
        if reason is None:
            # 이미 자기 주소면 쓸 수 있다 — 저장해 둔 화면을 다시 열었을 때 '중복'이라고 하면 안 된다.
            if owner is None:
                return None, None
            reason = site_slug.REASON_TAKEN
        return reason, await self._suggest(value)

    async def check_slug(self, user_info: UserInfo, place_id: str, slug: str) -> Res_SlugCheck:
        """주소를 쓸 수 있는지 미리 본다."""
        res = Res_SlugCheck()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        site = await self._get_site(place_id)
        if site is not None and (site.published_at is not None or site.status == SiteStatus.PUBLISHED.value):
            if (site.domain or "") != (slug or "").strip():
                res.available = False
                res.reason = site_slug.REASON_LOCKED
                return res
            res.available = True
            return res

        reason, suggestion = await self._judge_slug(place_id, slug)
        res.available = reason is None
        res.reason = reason
        res.suggestion = suggestion
        return res

    async def set_slug(self, user_info: UserInfo, place_id: str, req: Req_SiteSlug) -> Res_SiteSlug:
        """주소를 확정해 sites.domain 에 저장한다."""
        # 사이트 생성은 빌드와 같은 경로를 쓴다(사업장당 1개 보장) — 지역 import 로 빌드 스택을 웹에 얹지 않는다.
        from services.build_service import BuildAborted, ensure_site

        res = Res_SiteSlug()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        value = (req.slug or "").strip()
        site = await self._get_site(place_id)

        # 이미 발행된 사이트의 주소는 바꾸지 않는다.
        if site is not None and (site.published_at is not None or site.status == SiteStatus.PUBLISHED.value):
            if (site.domain or "") != value:
                res.result.SetResult(ErrorType.SITE_SLUG_LOCKED)
                res.reason = site_slug.REASON_LOCKED
                return res
            # 같은 값을 다시 보낸 건 변경이 아니다 — 재전송을 에러로 만들지 않는다.
            res.site = SiteData.model_validate(site)
            return res

        # 클라이언트 검증을 믿지 않는다.
        reason, suggestion = await self._judge_slug(place_id, value)
        if reason is not None:
            res.result.SetResult(_ERROR_BY_SLUG_REASON.get(reason, ErrorType.INVALID_REQUEST_DATA))
            res.reason = reason
            res.suggestion = suggestion
            return res

        if site is None:
            # 빌드 전에도 주소를 먼저 잡아둘 수 있어야 한다 — 주소를 고르는 건 발행보다 앞선 결정이다.
            try:
                site = await ensure_site(place_id)
            except BuildAborted as ex:
                LOG.e_no_callstack(ex)
                res.result.SetResult(ErrorType.DB_RUN_FAILED)
                return res

        u_err, _rowcount = await DB_SESSION_MNG.execute_lambda_claim(
            sites.DBType(), lambda s: self.crud.update_site(s, site.site_id, {"domain": value})
        )
        if u_err != ErrorType.SUCCESS:
            res.result.SetResult(u_err)
            if u_err == ErrorType.DB_ALREADY_SAME_KEY:
                res.reason = site_slug.REASON_TAKEN
                res.suggestion = await self._suggest(value)
            return res

        saved = await self._get_site(place_id)
        res.site = SiteData.model_validate(saved if saved is not None else site)
        return res

    # 템플릿(디자인)

    async def _mark_content_updated(self, place_id: str, ts):
        err = await DB_SESSION_MNG.execute_lambda_run([places.DBType()], [lambda s: self._touch(s, place_id, ts)])
        if err != ErrorType.SUCCESS:
            LOG.e_no_callstack(f"[site] content_updated_at 갱신 실패 place={place_id}")

    async def _touch(self, s, place_id: str, ts):
        from sqlalchemy import update

        query = update(places).where(places.place_id == uuid.UUID(place_id)).values(content_updated_at=ts, updated_at=ts)
        return await DB_SESSION_MNG.add(s, query)

    async def set_template(self, user_info: UserInfo, place_id: str, req: Req_SiteTemplate) -> Res_Site:
        """사장님이 고른 템플릿을 sites.template_id에 저장한다."""
        # 사이트 생성은 빌드와 같은 경로를 쓴다(사업장당 1개 보장) — 지역 import 로 빌드 스택을 웹에 얹지 않는다.
        from services.build_service import BuildAborted, ensure_site

        res = Res_Site()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        value = (req.template_id or "").strip()
        if value and not is_allowed(int(_place.category), value):
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res

        site = await self._get_site(place_id)
        if site is None:
            # 빌드 전에도 템플릿을 먼저 잡아둘 수 있어야 한다 — 고르는 건 발행보다 앞선 결정이다.
            try:
                site = await ensure_site(place_id)
            except BuildAborted as ex:
                LOG.e_no_callstack(ex)
                res.result.SetResult(ErrorType.DB_RUN_FAILED)
                return res

        before = site.template_id or None
        # 빈 문자열은 '고르지 않음'이다 — NULL 로 되돌려 업종 기본 템플릿으로 떨어뜨린다.
        after = value or None
        u_err, _rowcount = await DB_SESSION_MNG.execute_lambda_claim(
            sites.DBType(), lambda s: self.crud.update_site(s, site.site_id, {"template_id": after})
        )
        if u_err != ErrorType.SUCCESS:
            res.result.SetResult(u_err)
            return res

        if before != after and (site.published_at is not None or site.current_version_id is not None):
            await self._mark_content_updated(place_id, GTime.UTC())

        return await self.get_site(user_info, place_id)

    # 테마(색·서체·섹션)

    async def set_theme(self, user_info: UserInfo, place_id: str, req: Req_SiteTheme) -> Res_Site:
        """에디터가 정한 디자인을 sites.theme에 저장한다."""
        # 사이트 생성은 빌드와 같은 경로를 쓴다(사업장당 1개 보장) — 지역 import 로 빌드 스택을 웹에 얹지 않는다.
        from services.build_service import BuildAborted, ensure_site

        res = Res_Site()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        after = self._clean_theme(req.theme)
        if after is _THEME_REJECTED:
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res

        site = await self._get_site(place_id)
        if site is None:
            # 빌드 전에도 디자인을 먼저 잡아둘 수 있어야 한다 — 고르는 건 발행보다 앞선 결정이다.
            try:
                site = await ensure_site(place_id)
            except BuildAborted as ex:
                LOG.e_no_callstack(ex)
                res.result.SetResult(ErrorType.DB_RUN_FAILED)
                return res

        before = site.theme or None
        u_err, _rowcount = await DB_SESSION_MNG.execute_lambda_claim(
            sites.DBType(), lambda s: self.crud.update_site(s, site.site_id, {"theme": after})
        )
        if u_err != ErrorType.SUCCESS:
            res.result.SetResult(u_err)
            return res

        if before != after and (site.published_at is not None or site.current_version_id is not None):
            await self._mark_content_updated(place_id, GTime.UTC())

        return await self.get_site(user_info, place_id)

    @staticmethod
    def _clean_theme(theme):
        """저장할 theme 값을 만든다."""
        if not isinstance(theme, dict) or not theme:
            return None

        cleaned = {k: v for k, v in theme.items() if k not in _THEME_OWNED_ELSEWHERE}
        if not cleaned:
            return None

        try:
            size = len(json.dumps(cleaned, ensure_ascii=False).encode("utf-8"))
        except (TypeError, ValueError):
            return _THEME_REJECTED
        if size > _THEME_MAX_BYTES:
            return _THEME_REJECTED
        return cleaned

    async def list_my_sites(self, user_info: UserInfo, pg: PageParams) -> Res_MySites:
        """로그인한 사장님이 가진 사이트 전부."""
        res = Res_MySites(page=pg.page, size=pg.size)
        uid = uuid.UUID(user_info.user_id)
        err_type, rows, total = await DB_SESSION_MNG.execute_lambda(
            places.DBType(),
            DBWRType.DB_READ.value,
            lambda s: self.crud.list_owner_sites(s, uid, pg.skip, pg.size),
        )
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res
        res.sites = [
            self._my_site_row(place, site, built_at, primary_photo_url)
            for place, site, built_at, primary_photo_url in rows
        ]
        res.total = total
        return res

    @staticmethod
    def _my_site_row(place, site, built_at, primary_photo_url) -> MySiteData:
        # 재빌드 판별은 단건(get_site)과 같은 규칙이어야 한다 — 다르면 목록과 에디터가 다른 답을 한다.
        changed = place.content_updated_at
        # sites.thumbnail_url 은 발행할 때 Azure 에 대표 사진을 재호스팅해야 채워진다 (services/site_thumbnail.store) — 저장소가 안 꺼져 있으면(로컬 개발 등) 늘 비어 있다.
        ever_published = site is not None and getattr(site, "published_at", None) is not None
        thumbnail_url = getattr(site, "thumbnail_url", None) or (primary_photo_url if ever_published else None)
        return MySiteData(
            place_id=place.place_id,
            name=place.name,
            category=place.category,
            place_status=place.status,
            road_address=place.road_address or place.address,
            created_at=place.created_at,
            site_id=getattr(site, "site_id", None),
            status=getattr(site, "status", None),
            domain=getattr(site, "domain", None),
            template_id=getattr(site, "template_id", None),
            published_at=getattr(site, "published_at", None),
            thumbnail_url=thumbnail_url,
            needs_rebuild=bool(site is not None and changed and (built_at is None or changed > built_at)),
        )

    async def get_site(self, user_info: UserInfo, place_id: str) -> Res_Site:
        res = Res_Site()
        err_type, place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        pid = uuid.UUID(place_id)
        s_err, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_place(s, pid)
        )
        if s_err != ErrorType.SUCCESS or site is None:
            res.result.SetResult(ErrorType.SITE_NOT_FOUND)
            return res
        res.site = SiteData.model_validate(site)

        if site.current_version_id:
            v_err, version = await DB_SESSION_MNG.execute_lambda(
                site_versions.DBType(),
                DBWRType.DB_READ.value,
                lambda s: self.crud.get_version(s, site.site_id, site.current_version_id),
            )
            if v_err == ErrorType.SUCCESS and version is not None:
                res.current_version = SiteVersionData.model_validate(version)
                # 개별 재빌드 판별: 노출값이 바뀐 시각이 마지막 빌드보다 나중이면 다시 빌드해야 한다.
                built = version.built_at
                changed = place.content_updated_at
                res.needs_rebuild = bool(changed and (built is None or changed > built))
                res.render = self._render_status(place, site, version)
        else:
            res.needs_rebuild = bool(place.content_updated_at)
            res.render = self._render_status(place, site, None)
        return res

    @staticmethod
    def _render_status(place, site, version) -> RenderStatusData:
        """정적 페이지가 실제로 구워졌는지 + 두 렌더러가 어긋나지 않았는지."""
        # payload 를 쓸 때와 같은 규칙으로 슬러그를 구한다(site_payload 가 소유).
        slug = site_payload.publish_slug(place, site)
        if not slug:
            return RenderStatusData()

        status = render_report.render_status(slug, getattr(version, "version", None))
        return RenderStatusData(
            state=status["state"],
            rendered_at=status["rendered_at"],
            rendered_version=status["rendered_version"],
            error=status["error"],
        )

    async def start_build(self, user_info: UserInfo, place_id: str, req: Req_StartBuild) -> Res_StartBuild:
        """빌드를 큐에 넣는다."""
        res = Res_StartBuild()
        err_type, place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res
        # 검증 안 된 사업장은 빌드하지 않는다 — 주소·좌표가 없으면 JSON-LD 가 성립하지 않는다.
        if place.verified_at is None:
            res.result.SetResult(ErrorType.PLACE_NOT_VERIFIED)
            return res

        # publish=False 는 **이미 나가 있는 사이트를 다시 굽는** 경로다.
        site = await self._get_site(place_id)
        if not req.publish:
            if site is None or site.published_at is None:
                res.result.SetResult(ErrorType.SITE_VERSION_NOT_FOUND)
                return res

        # 주소를 안 골랐어도 막지 않는다.

        job_id, created = await enqueue_job(
            self.queue, JobType.BUILD,
            {
                "place_id": place_id, "owner_user_id": user_info.user_id,
                "publish": req.publish, "requested_by": user_info.user_id,
            },
            dedupe_key=f"build:{place_id}",
        )
        if job_id is None:
            res.result.SetResult(ErrorType.COLLECT_ALREADY_RUNNING)
            return res

        # 노래는 여기서 따로 걸지 않는다.
        res.job_id = uuid.UUID(job_id)
        res.status = JobStatus.PENDING
        res.created = created
        return res

    async def start_rollback(self, user_info: UserInfo, place_id: str, req: Req_Rollback) -> Res_StartBuild:
        """dedupe_key 를 빌드와 **같은 것**(`build:{place_id}`)을 쓴다 — 롤백 도중에 새 발행이 끼어들거나 그 반대가 되면 어느 쪽이 이겼는지 알 수 없는 상태가 된다."""
        res = Res_StartBuild()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        job_id, created = await enqueue_job(
            self.queue, JobType.ROLLBACK,
            {
                "place_id": place_id, "owner_user_id": user_info.user_id,
                "target_version": req.target_version, "requested_by": user_info.user_id,
            },
            dedupe_key=f"build:{place_id}",
        )
        if job_id is None:
            res.result.SetResult(ErrorType.COLLECT_ALREADY_RUNNING)
            return res

        res.job_id = uuid.UUID(job_id)
        res.status = JobStatus.PENDING
        res.created = created
        return res

    async def list_versions(self, user_info: UserInfo, place_id: str) -> Res_SiteVersions:
        from sqlalchemy import select

        res = Res_SiteVersions()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res
        pid = uuid.UUID(place_id)
        s_err, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_place(s, pid)
        )
        if s_err != ErrorType.SUCCESS or site is None:
            res.result.SetResult(ErrorType.SITE_NOT_FOUND)
            return res

        query = (
            select(site_versions)
            .where(site_versions.site_id == site.site_id, site_versions.deleted == False)  # noqa: E712
            .order_by(site_versions.version.desc())
            .limit(50)
        )
        v_err, rows = await DB_SESSION_MNG.execute_lambda(
            site_versions.DBType(),
            DBWRType.DB_READ.value,
            lambda s: DB_SESSION_MNG.execute(s, query),
        )
        if v_err == ErrorType.SUCCESS:
            res.versions = [SiteVersionData.model_validate(r) for r in rows]
        return res

    async def list_logs(self, user_info: UserInfo, place_id: str) -> Res_PublishLogs:
        res = Res_PublishLogs()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res
        pid = uuid.UUID(place_id)
        s_err, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_place(s, pid)
        )
        if s_err != ErrorType.SUCCESS or site is None:
            res.result.SetResult(ErrorType.SITE_NOT_FOUND)
            return res
        l_err, rows = await DB_SESSION_MNG.execute_lambda(
            site_publish_logs.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.list_logs(s, site.site_id, 50)
        )
        if l_err == ErrorType.SUCCESS:
            res.logs = [PublishLogData.model_validate(r) for r in rows]
        return res

    async def change_status(self, user_info: UserInfo, place_id: str, req: Req_SiteStatus) -> Res_Site:
        """발행 상태를 전이한다(중지·재개·내림)."""
        res = Res_Site()
        err_type, _place = await self._load_place(user_info, place_id)
        if err_type != ErrorType.SUCCESS:
            res.result.SetResult(err_type)
            return res

        target = _STATUS_BY_ACTION.get(req.action)
        if target is None:
            res.result.SetResult(ErrorType.INVALID_REQUEST_DATA)
            return res

        pid = uuid.UUID(place_id)
        s_err, site = await DB_SESSION_MNG.execute_lambda(
            sites.DBType(), DBWRType.DB_READ.value, lambda s: self.crud.get_site_by_place(s, pid)
        )
        if s_err != ErrorType.SUCCESS or site is None:
            res.result.SetResult(ErrorType.SITE_NOT_FOUND)
            return res
        # 한 번도 발행한 적 없는 사이트는 재개할 것이 없다.
        if req.action == PublishAction.RESUME and site.current_version_id is None:
            res.result.SetResult(ErrorType.SITE_VERSION_NOT_FOUND)
            return res

        now = GTime.UTC()
        await DB_SESSION_MNG.execute_lambda_claim(
            sites.DBType(), lambda s: self.crud.update_site(s, site.site_id, {"status": target.value})
        )
        log = site_publish_logs(
            site_id=site.site_id,
            site_version_id=site.current_version_id,
            action=req.action.value,
            result=PublishResult.SUCCESS.value,
            actor_user_id=uuid.UUID(user_info.user_id),
        )
        await DB_SESSION_MNG.execute_lambda_run([site_publish_logs.DBType()], [lambda s: self.crud.add_log(s, log)])
        return await self.get_site(user_info, place_id)