007a16eb9c
- app/store.py login_redirect(): 로그인 전 화면 주소를 /login?next= 로 넘긴다(GET 만 — 폼 POST 주소로 돌아가면 405). 경비·쿠팡·휴가·말레이시아·배송·카페24·실적 11곳이 next 없이 /login 으로 보내던 것과 프로젝트·입출고·안내문 발송의 복사본 4벌을 이 함수로. - UserStore._read: JSONDecodeError 를 빈 목록으로 삼키지 않는다 — 다음 로그인이 전체 사용자·권한을 그 한 명으로 덮어쓰던 것을 막는다. - tests/test_login_redirect.py Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
392 lines
19 KiB
Python
392 lines
19 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),
|
|
"gmail": _gmail_state(request, user), "msg": request.query_params.get("msg", ""),
|
|
})
|
|
|
|
|
|
@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)
|