Files
dbx-main/app/modules/outreach/router.py
T
king 48cd7f0878 feat(안내문 발송): DM 수동 보내기 — 이름 지우기·본문 편집·저장한 본문 목록
- 이름 목록: × 한 명씩 빼기·[전체 삭제], 이름 넣기는 목록에 더함
- 본문: 바로 고침(plaintext-only), {이름} 자리 = 분홍 칩, 이름 누르면 고친 글 + 이름 복사
- 저장한 본문(본문 오른쪽): 설정 DM 문구 + 저장한 것, 고르기·[저장]·[새 본문으로 저장]·× 지우기
- outreach_db 마이그레이션 002 outreach_dm_bodies + POST/PUT/DELETE /outreach/api/dm-bodies
  (002 미적용이면 목록 안내만, API 503)
- 캐시 버전 20261030c, 단위·API·실제 PG·브라우저 테스트

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-30 16:51:10 +09:00

451 lines
22 KiB
Python

"""안내문 발송(outreach) 라우터 — 리스트(이메일·인스타 주소 + 이름)에 안내문 메일 일괄 발송·인스타 DM 반자동(2026-10-27).
GET /outreach/ 리스트 + 보내기 화면
GET /outreach/settings 설정 — 메일 제목·본문({이름})·보내는 이름·끝 문구·(광고)·본문 아래 사진
POST /outreach/settings 설정 저장 · POST /settings/images(올리기) · /settings/images/{id}/delete · /move
GET /outreach/images/{id} 사진(설정·미리보기)
GET /outreach/api/recipients 리스트(JSON — 발송 중 진행 보기)
POST /outreach/api/recipients/parse 붙여 넣은 글 해석 미리보기(메일/DM/오류)
POST /outreach/api/recipients 리스트에 추가 {text}
PUT /outreach/api/recipients/{id} 이름·메모 고치기, 다시 대기로 {status: "대기"}
POST /outreach/api/recipients/delete 지우기 {ids}
GET /outreach/api/recipients/{id}/preview 그 사람에게 갈 제목·HTML·DM 글
POST /outreach/api/send 고른 메일 줄 일괄 발송 {ids} — 본인 Gmail, 백그라운드
POST /outreach/api/recipients/{id}/dm-sent DM 보냄 표시(사람이 DM 창에서 보낸 뒤)
GET /outreach/gmail/connect · POST /gmail/disconnect 내 Gmail 연결(입출고·휴가와 같은 연결, 같은 구글 콜백)
권한: 모듈 권한키 `outreach`(보기·리스트·보내기·설정 모두). DB: OUTREACH_DB_URL(outreach_db) — 없으면 "설정 필요" 안내.
"""
from __future__ import annotations
from io import BytesIO
from typing import Any
from urllib.parse import urlencode
from fastapi import APIRouter, BackgroundTasks, Body, File, Form, HTTPException, Request, UploadFile
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, Response
from . import store
router = APIRouter(prefix="/outreach", tags=["outreach"])
IMAGE_MAX_W = 700
IMAGE_MAX_BYTES = 15 * 1024 * 1024
MAX_ADD = 2000
def _store(request: Request) -> Any:
return getattr(request.app.state, "outreach_store", None)
def _inout(request: Request) -> Any:
return getattr(request.app.state, "inout_store", None)
def _user(request: Request) -> dict[str, Any]:
from app.main import get_current_user_record # noqa: WPS433
from app.store import has_module # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
if not has_module(user, "outreach"):
raise HTTPException(status_code=403, detail="안내문 발송 모듈 권한이 없습니다.")
return user
def _db(request: Request) -> Any:
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail="안내문 발송 DB(OUTREACH_DB_URL)가 설정되지 않았습니다.")
return st
def _page(request: Request) -> Any:
"""화면 공통 — (st, user) 또는 응답(로그인·권한·설정 필요)."""
from app.main import build_erp_nav, get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin, login_redirect # noqa: WPS433
user = get_current_user_record(request)
if user is None:
return login_redirect(request)
if not has_module(user, "outreach"):
return render_template(request, "denied.html", {"reason": "안내문 발송 모듈 접근 권한이 없습니다.",
"is_admin": is_admin(user)}, status_code=403)
st = _store(request)
if st is None:
return render_template(request, "denied.html", {
"reason": "안내문 발송 모듈이 아직 설정되지 않았습니다. scripts/sql/outreach_db_init.sql 로 outreach_db 를 만들고 "
".env 에 OUTREACH_DB_URL 을 넣은 뒤 컨테이너를 다시 시작하세요.",
"user": user, "is_admin": is_admin(user), "nav_items": build_erp_nav(user, active="outreach")}, status_code=503)
return st, user
def _render(request: Request, name: str, user: dict[str, Any], ctx: dict[str, Any]) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
return render_template(request, name, {"user": user, "is_admin": is_admin(user),
"nav_items": build_erp_nav(user, active="outreach"), **ctx})
def _gmail_state(request: Request, user: dict[str, Any]) -> dict[str, Any]:
from app.modules.inout import gmail # noqa: WPS433
inout = _inout(request)
connected = False
if inout is not None:
try:
connected = inout.gmail_token(user["email"]) is not None
except Exception: # noqa: BLE001
connected = False
return {"available": inout is not None and gmail.configured(), "connected": connected, "email": user["email"]}
def _view(r: dict[str, Any], template: dict[str, Any]) -> dict[str, Any]:
"""리스트 한 줄 화면용 — 구분 라벨, DM 이면 그 사람 이름을 넣은 DM 글·DM 창 주소(누르는 순간 복사·열기라 미리 담아 둔다)."""
out = {k: r.get(k) for k in ("id", "kind", "handle", "address", "name", "memo", "status", "sent_at", "sent_by", "sent_via",
"last_error")}
out["kind_label"] = store.KIND_LABELS.get(r["kind"], "")
out["needs_name"] = store.needs_name(template, r["kind"]) and not (r.get("name") or "").strip()
if r["kind"] == "instagram":
out["dm_link"] = store.dm_link(r["handle"])
out["profile_link"] = store.profile_link(r["handle"])
out["dm_text"] = store.dm_text(template, r.get("name") or "")
return out
# ════════════════════════════════════════════════════════════
# 화면
# ════════════════════════════════════════════════════════════
@router.get("/health")
def health(request: Request) -> JSONResponse:
return JSONResponse({"status": "ok" if _store(request) is not None else "not_configured"})
@router.get("/", response_class=HTMLResponse)
def index(request: Request) -> Any:
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
template = st.get_template()
rows = [_view(r, template) for r in st.list_recipients()]
return _render(request, "outreach/index.html", user, {
"page_title": "안내문 발송", "page_subtitle": "메일 일괄 발송 · 인스타 DM",
"template": template, "body_text": store.html_to_text(template["body"]), "needs_name": store.needs_name(template),
"images": st.list_images(), "rows": rows, "logs": st.list_logs(limit=50), "active_tab": "list",
"gmail": _gmail_state(request, user), "msg": request.query_params.get("msg", ""),
})
@router.get("/dm", response_class=HTMLResponse)
def dm_page(request: Request) -> Any:
"""DM 수동 보내기 탭(2026-10-30) — 이름 목록 | 고칠 수 있는 본문(화면이 {이름} 을 바꿔 복사) | 저장한 본문 목록."""
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
return _render(request, "outreach/dm.html", user, {
"page_title": "안내문 발송", "page_subtitle": "DM 수동 보내기", "active_tab": "dm",
# {이름} 을 그대로 둔 DM 문구(리스트 줄 [DM 보내기]와 같은 글) + 저장한 본문 목록(002 미적용 = None)
"dm_template": store.dm_text(st.get_template(), store.NAME_TAG),
"dm_bodies": st.list_dm_bodies(), "dm_max": store.DM_MAX,
})
_DM_BODIES_MIGRATION_MSG = "본문 저장 표가 없습니다 — outreach_db 마이그레이션 002(scripts/sql/outreach_db_002_dm_bodies.sql)를 적용하세요."
def _dm_body_save(request: Request, payload: dict[str, Any], body_id: int | None) -> JSONResponse:
from psycopg.errors import UndefinedTable # noqa: WPS433
user = _user(request)
st = _db(request)
try:
saved = st.save_dm_body(payload.get("body"), by=user.get("email", ""), body_id=body_id)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
except KeyError:
raise HTTPException(status_code=404, detail="저장한 본문이 없습니다(다른 사람이 지웠을 수 있음).")
except UndefinedTable:
raise HTTPException(status_code=503, detail=_DM_BODIES_MIGRATION_MSG)
return JSONResponse({"id": saved, "items": st.list_dm_bodies() or []})
@router.post("/api/dm-bodies")
def api_dm_body_add(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""DM 수동 보내기 — 본문 새로 저장(제목 = 첫 줄)."""
return _dm_body_save(request, payload, None)
@router.put("/api/dm-bodies/{body_id:int}")
def api_dm_body_update(request: Request, body_id: int, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""DM 수동 보내기 — 고른 저장 본문 고치기."""
return _dm_body_save(request, payload, body_id)
@router.delete("/api/dm-bodies/{body_id:int}")
def api_dm_body_delete(request: Request, body_id: int) -> JSONResponse:
from psycopg.errors import UndefinedTable # noqa: WPS433
_user(request)
st = _db(request)
try:
st.delete_dm_body(body_id)
except UndefinedTable:
raise HTTPException(status_code=503, detail=_DM_BODIES_MIGRATION_MSG)
return JSONResponse({"items": st.list_dm_bodies() or []})
@router.get("/settings", response_class=HTMLResponse)
def settings_page(request: Request) -> Any:
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
return _render(request, "outreach/settings.html", user, {
"page_title": "안내문 발송 — 설정", "page_subtitle": "메일 제목 · 본문 · DM 문구 · 사진",
"template": st.get_template(), "default": store.normalize_template(None), "images": st.list_images(),
"max_images": 10, "dm_max": store.DM_MAX, "msg": request.query_params.get("msg", ""),
})
@router.post("/settings")
def settings_save(request: Request, subject: str = Form(""), body: str = Form(""), sender_name: str = Form(""),
footer: str = Form(""), ad_label: str = Form(""), dm_body: str = Form(""),
fmt: str = Form("text")) -> RedirectResponse:
"""body = 설정 화면 편집기 HTML(fmt=html, 서버가 다시 정리) — fmt 없이 오면 글로 본다."""
user = _user(request)
st = _db(request)
try:
st.save_template({"subject": subject, "body": body, "sender_name": sender_name, "footer": footer, "dm_body": dm_body,
"ad_label": ad_label in ("1", "on", "true"), "fmt": "html" if fmt == "html" else "text"},
by=user["email"])
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return RedirectResponse(url="/outreach/settings?" + urlencode({"msg": "설정을 저장했습니다."}), status_code=303)
def _shrink(data: bytes) -> tuple[bytes, int, int]:
"""사진 → 메일용 JPEG(가로 최대 700px, 회전 정보 반영, 투명 = 흰 바탕). 못 여는 파일(HEIC 등)은 ValueError."""
from PIL import Image, ImageOps # noqa: WPS433
try:
im = Image.open(BytesIO(data))
im = ImageOps.exif_transpose(im)
if im.mode not in ("RGB", "L"):
rgba = im.convert("RGBA")
bg = Image.new("RGB", rgba.size, (255, 255, 255))
bg.paste(rgba, mask=rgba.split()[-1])
im = bg
if im.width > IMAGE_MAX_W:
im = im.resize((IMAGE_MAX_W, max(1, round(im.height * IMAGE_MAX_W / im.width))), Image.LANCZOS)
buf = BytesIO()
im.convert("RGB").save(buf, "JPEG", quality=85, optimize=True)
except Exception: # noqa: BLE001
raise ValueError("사진을 열 수 없습니다(JPG·PNG·WEBP 를 올리세요 — HEIC 는 안 됩니다).") from None
return buf.getvalue(), im.width, im.height
@router.post("/settings/images")
def images_upload(request: Request, files: list[UploadFile] = File(...)) -> RedirectResponse:
user = _user(request)
st = _db(request)
added, errors = 0, []
for f in files:
data = f.file.read(IMAGE_MAX_BYTES + 1)
if not data:
continue
if len(data) > IMAGE_MAX_BYTES:
errors.append(f"{f.filename}: 15MB 보다 큽니다")
continue
try:
jpg, w, h = _shrink(data)
st.add_image(filename=f.filename or "photo.jpg", data=jpg, width=w, height=h, by=user["email"])
added += 1
except ValueError as exc:
errors.append(f"{f.filename}: {exc}")
msg = f"사진 {added}장을 넣었습니다." + (" · " + " · ".join(errors) if errors else "")
return RedirectResponse(url="/outreach/settings?" + urlencode({"msg": msg}) + "#images", status_code=303)
@router.post("/settings/images/{image_id:int}/delete")
def images_delete(request: Request, image_id: int) -> RedirectResponse:
_user(request)
_db(request).delete_image(image_id)
return RedirectResponse(url="/outreach/settings?" + urlencode({"msg": "사진을 뺐습니다."}) + "#images", status_code=303)
@router.post("/settings/images/{image_id:int}/move")
def images_move(request: Request, image_id: int, direction: int = Form(...)) -> RedirectResponse:
_user(request)
_db(request).move_image(image_id, direction)
return RedirectResponse(url="/outreach/settings#images", status_code=303)
@router.get("/images/{image_id:int}")
def image_view(request: Request, image_id: int) -> Response:
_user(request)
im = _db(request).get_image(image_id)
if im is None:
raise HTTPException(status_code=404, detail="사진을 찾을 수 없습니다.")
return Response(content=bytes(im["data"]), media_type="image/jpeg", headers={"Cache-Control": "private, max-age=3600"})
# ════════════════════════════════════════════════════════════
# 리스트 API
# ════════════════════════════════════════════════════════════
@router.get("/api/recipients")
def api_list(request: Request) -> JSONResponse:
_user(request)
st = _db(request)
template = st.get_template()
return JSONResponse({"rows": [_view(r, template) for r in st.list_recipients()]})
@router.post("/api/recipients/parse")
def api_parse(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""붙여 넣은 글 → 줄마다 {address, name, kind, kind_label, handle, error, dup, exists} (저장 안 함)."""
_user(request)
st = _db(request)
rows = store.parse_bulk(str(payload.get("text") or ""))[:MAX_ADD]
have = {(r["kind"], r["handle"]) for r in st.list_recipients()}
for r in rows:
r["kind_label"] = store.KIND_LABELS.get(r["kind"] or "", "오류")
r["exists"] = bool(r["kind"]) and (r["kind"], r["handle"]) in have
return JSONResponse({"rows": rows})
@router.post("/api/recipients")
def api_add(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
user = _user(request)
st = _db(request)
rows = [r for r in store.parse_bulk(str(payload.get("text") or "")) if not r["dup"]]
if len(rows) > MAX_ADD:
raise HTTPException(status_code=400, detail=f"한 번에 {MAX_ADD}줄까지 넣을 수 있습니다.")
res = st.add_recipients(rows, by=user["email"])
return JSONResponse({"ok": True, **res})
@router.put("/api/recipients/{rid:int}")
def api_update(request: Request, rid: int, payload: dict[str, Any] = Body(...)) -> JSONResponse:
_user(request)
st = _db(request)
try:
r = st.update_recipient(rid, name=payload.get("name"), memo=payload.get("memo"), status=payload.get("status"))
except KeyError:
raise HTTPException(status_code=404, detail="리스트에 없는 줄입니다.")
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return JSONResponse({"row": _view(r, st.get_template())})
@router.post("/api/recipients/delete")
def api_delete(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
_user(request)
try:
ids = [int(i) for i in payload.get("ids") or []]
except (TypeError, ValueError):
raise HTTPException(status_code=400, detail="ids 가 올바르지 않습니다.")
return JSONResponse({"ok": True, "deleted": _db(request).delete_recipients(ids)})
@router.get("/api/recipients/{rid:int}/preview")
def api_preview(request: Request, rid: int) -> JSONResponse:
"""그 사람에게 갈 제목·HTML(사진은 /outreach/images 주소로)·DM 글."""
_user(request)
st = _db(request)
r = st.get_recipient(rid)
if r is None:
raise HTTPException(status_code=404, detail="리스트에 없는 줄입니다.")
t = st.get_template()
html = store.html_body(t, r["name"], [f"img-{im['id']}" for im in st.list_images()])
for im in st.list_images():
html = html.replace(f"cid:img-{im['id']}", f"/outreach/images/{im['id']}")
return JSONResponse({"subject": store.subject_for(t, r["name"]), "html": html,
"text": store.dm_text(t, r["name"]) if r["kind"] == "instagram" else store.plain_text(t, r["name"]),
"kind": r["kind"], "to": r["handle"], "sender_name": t["sender_name"]})
@router.post("/api/send")
def api_send(request: Request, bg: BackgroundTasks, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""고른 줄 중 메일·대기/실패를 '발송중'으로 잡고(한 번만) 백그라운드로 본인 Gmail 발송. 진행은 GET /api/recipients 로."""
from . import send # noqa: WPS433
user = _user(request)
st = _db(request)
try:
ids = [int(i) for i in payload.get("ids") or []]
except (TypeError, ValueError):
raise HTTPException(status_code=400, detail="ids 가 올바르지 않습니다.")
if not ids:
raise HTTPException(status_code=400, detail="보낼 줄을 고르세요.")
gm = _gmail_state(request, user)
if not gm["connected"]:
return JSONResponse({"ok": False, "reconnect": True,
"message": "Gmail 이 연결되지 않았습니다 — [Gmail 연결]을 먼저 하세요(내 Gmail 로 보냅니다)."},
status_code=409)
rows = st.claim_for_send(ids)
if not rows:
return JSONResponse({"ok": False, "message": "보낼 메일 줄이 없습니다(이미 보냈거나 보내는 중, 또는 DM 줄)."}, status_code=409)
bg.add_task(send.send_batch, st, _inout(request), rows=rows, user=dict(user))
return JSONResponse({"ok": True, "queued": len(rows)}, status_code=202)
@router.post("/api/recipients/{rid:int}/dm-sent")
def api_dm_sent(request: Request, rid: int) -> JSONResponse:
user = _user(request)
st = _db(request)
t = st.get_template()
r0 = st.get_recipient(rid)
if r0 is None:
raise HTTPException(status_code=404, detail="리스트에 없는 줄입니다.")
try:
r = st.mark_dm_sent(rid, by=user["email"], subject=store.subject_for(t, r0["name"]))
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
return JSONResponse({"row": _view(r, t)})
# ════════════════════════════════════════════════════════════
# 내 Gmail 연결 — 입출고·휴가와 같은 연결(inout_gmail_tokens), 같은 구글 콜백(/inout/gmail/callback)
# ════════════════════════════════════════════════════════════
@router.get("/gmail/connect")
async def gmail_connect(request: Request) -> Any:
from app.main import ALLOWED_DOMAIN, public_url_for # noqa: WPS433
from app.modules.inout import gmail # noqa: WPS433
user = _user(request)
if _inout(request) is None:
return RedirectResponse(url="/outreach/?" + urlencode({"msg": "Gmail 연결 저장소(입출고 DB)가 설정되지 않아 연결할 수 없습니다."}),
status_code=303)
try:
client = gmail.oauth_client()
except gmail.GmailError as exc:
return RedirectResponse(url="/outreach/?" + urlencode({"msg": str(exc)}), status_code=303)
request.session["_gmail_origin"] = "outreach"
request.session["_gmail_next"] = "/outreach/"
return await client.authorize_redirect(
request, public_url_for(request, "inout_gmail_callback"),
access_type="offline", prompt="consent", include_granted_scopes="true",
login_hint=user.get("email", ""), hd=ALLOWED_DOMAIN)
@router.post("/gmail/disconnect")
def gmail_disconnect(request: Request) -> RedirectResponse:
from app.modules.inout import gmail # noqa: WPS433
user = _user(request)
inout = _inout(request)
if inout is not None:
row = inout.gmail_token(user["email"])
if row:
try:
gmail.revoke(gmail.decrypt_token(user["email"], row["refresh_token_enc"]))
except (gmail.GmailError, gmail.GmailNotConnected):
pass
inout.delete_gmail_token(user["email"])
return RedirectResponse(url="/outreach/?" + urlencode({"msg": "Gmail 연결을 끊었습니다(입출고·휴가 메일 연결도 함께)."}),
status_code=303)