feat(outreach): 안내문 발송 모듈 — 메일 일괄 발송(본인 Gmail)·인스타 DM 반자동·{이름}

- 새 모듈 app/modules/outreach(권한키 outreach, outreach_db — scripts/sql/outreach_db_init.sql, OUTREACH_DB_URL)
- 리스트 붙여넣기(주소, 이름) → 주소를 보고 메일/DM 판별(store.detect: 이메일·@계정·instagram.com·ig.me·계정명) → 미리보기 → 추가
- 메일 = 고른 줄을 한 UPDATE 로 발송중(두 번 눌러도 한 번) → 백그라운드로 본인 Gmail 한 사람에 한 통(입출고·휴가와 같은 Gmail 연결),
  설정 사진 본문 아래(cid), 보냄/실패·기록. 인스타 = 이름 넣은 문구 복사 + ig.me DM 창 → [보냄] 기록(공식 API 는 첫 DM 불가)
- 설정: 제목·본문 기본 = 미라네주방 공동구매 제안 문구, {이름}·**굵게**, 보내는 이름·끝 문구·(광고) 표시, 사진 10장
- 입출고 Gmail 콜백을 모듈 공용으로(_GMAIL_ORIGINS — vacation·outreach)
- 테스트: 판별·본문·발송(가짜 Gmail)·실제 앱·실제 PG(동시 claim 4번 = 1번)·브라우저

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-26 17:28:21 +09:00
parent e197d3deb3
commit 8c805fdd9c
23 changed files with 2279 additions and 13 deletions
+5
View File
@@ -156,6 +156,11 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# 초기화: scripts/sql/inout_db_init.sql (docs/INOUT_MODULE.md). 제품(단품)은 아래 ITEMCODE_DB_URL 재사용.
# INOUT_DB_URL=postgresql://inout_app:replace-me@postgres-db:5432/inout_db
# ─── 안내문 발송 모듈 (outreach_db) — app/modules/outreach ───
# 리스트(이메일·인스타 주소 + 이름)에 안내문 메일 일괄 발송(보내는 사람 본인 Gmail — 입출고 Gmail 연결 재사용)·인스타 DM 반자동.
# 초기화: scripts/sql/outreach_db_init.sql (docs/DEPLOYMENT.md "안내문 발송 DB 생성"). 미설정 시 "설정 필요" 안내만.
# OUTREACH_DB_URL=postgresql://outreach_app:replace-me@postgres-db:5432/outreach_db
# ─── 상품 검색 (itemcode_db 읽기 전용) ───
# cupang 설정 화면에서 제품명을 itemcode_db 에서 검색해 등록한다(읽기만).
# 미설정 시 검색 비활성 → 수동 등록만 가능.
+2 -1
View File
@@ -46,6 +46,7 @@
| `[경비]` `[개인경비]` | `expense/` | `expense_db` | `expense` | (모듈 CLAUDE.md) | — |
| `[공지]` `[긴급공지]` | `notice/` | `project_db`(024) | 수퍼관리자 | `docs/NOTICE_MODULE.md` | `erp-notice*` |
| `[자산]` | `asset/` | `asset_db` | `asset` | `docs/ASSET_MODULE.md` | `asset.*` |
| `[안내문 발송]` | `outreach/` | `outreach_db` | `outreach` | (모듈 CLAUDE.md) | `outreach.*` |
| `[공통]` `[ERP]` | `app/main.py`, `app/templates/`(셸·로그인·관리자), 인증·권한 | — | — | `docs/PROJECT_OVERVIEW.md`, `docs/DESIGN.md` | `erp*.js/css`, `styles.css` |
| `[배포]` `[서버]` | `docker-compose*.yml`, `Dockerfile`, `scripts/` | — | — | `docs/DEPLOYMENT.md` | — |
| `[DB]` | `scripts/sql/` | — | — | `docs/DATABASES.md` | — |
@@ -59,7 +60,7 @@
- `performance_store` 매출: 실적 → 프로젝트 주간 회의록 머리 카드(읽기 전용).
- `ProjectStore.pool`(`project_db`): 프로젝트 + 긴급 공지.
- `APP_ENCRYPTION_KEY`: 실적(쇼핑몰·광고 인증) + 입출고(Gmail 토큰).
- 입출고 Gmail 연결(`inout_gmail_tokens`·`/inout/gmail/callback`): 입출고 발주 메일 + 휴가 메일(`vacation/notify.py`, 처리한 사람 본인 Gmail).
- 입출고 Gmail 연결(`inout_gmail_tokens`·`/inout/gmail/callback`, `_GMAIL_ORIGINS`): 입출고 발주 메일 + 휴가 메일(`vacation/notify.py`) + 안내문 발송(`outreach/send.py`) — 모두 보내는 사람 본인 Gmail.
- `app/integrations/google_sheets.py`(쿠팡) · `google_slides.py`(프로젝트 회의록 보드).
- `app/mail.py`: 프로젝트 알림 메일.
- ERP 모든 화면 스크립트: `erp-notice.js`(공지) · `erp-overdue.js`(프로젝트 마감 알림).
+19
View File
@@ -30,6 +30,8 @@ from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store
from .modules.malaysia import router as malaysia_router
from .modules.notice import build_notice_store
from .modules.notice import router as notice_router
from .modules.outreach import build_outreach_store
from .modules.outreach import router as outreach_router
from .modules.performance import build_performance_store
from .modules.performance import router as performance_router
from .modules.project import build_project_store
@@ -62,6 +64,7 @@ MODULE_LABELS: dict[str, str] = {
"performance": "실적",
"asset": "자산관리",
"inout": "입출고 관리",
"outreach": "안내문 발송",
"expense_approver": "개인경비",
"vacation_approver": "휴가",
}
@@ -157,6 +160,7 @@ _MODULE_TEMPLATE_DIRS = [
BASE_DIR / "modules" / "asset" / "templates",
BASE_DIR / "modules" / "notice" / "templates",
BASE_DIR / "modules" / "inout" / "templates",
BASE_DIR / "modules" / "outreach" / "templates",
]
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.loader = ChoiceLoader(
@@ -226,6 +230,9 @@ app.state.notice_store = build_notice_store(app.state.project_store)
# 제품은 itemcode_db 단품(single_items) 읽기 전용 — ITEMCODE_DB_URL 재사용.
app.state.inout_store = build_inout_store(dsn=env("INOUT_DB_URL") or None)
app.state.inout_items = build_inout_items()
# 안내문 발송(메일 일괄·인스타 DM 반자동): OUTREACH_DB_URL 없으면 store=None(화면이 "설정 필요" 안내).
# 메일은 보내는 사람 본인 Gmail — 입출고 Gmail 연결(inout_store.inout_gmail_tokens)을 같이 쓴다.
app.state.outreach_store = build_outreach_store(dsn=env("OUTREACH_DB_URL") or None)
# 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄.
app.include_router(expense_router)
@@ -239,6 +246,7 @@ app.include_router(performance_router)
app.include_router(asset_router)
app.include_router(notice_router)
app.include_router(inout_router)
app.include_router(outreach_router)
def public_url_for(request: Request, route_name: str) -> str:
@@ -441,6 +449,16 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
"status": "ready",
"category": "운영",
},
{
"key": "outreach",
"title": "안내문 발송",
"subtitle": "Outreach",
"description": "이메일·인스타그램 리스트에 이름을 넣은 안내문을 메일로 일괄 발송하고 인스타 DM 을 보냅니다.",
"url": "/outreach/",
"health_url": "/outreach/health",
"status": "ready",
"category": "운영",
},
]
items.append({
"key": "asset", "title": "자산관리", "subtitle": "Asset Management",
@@ -457,6 +475,7 @@ def _icon_svg(name: str) -> str:
"""좌측 사이드바용 인라인 아이콘. 외부 의존 없는 작은 SVG."""
paths = {
"inout": '<path d="M3 7l9-4 9 4v10l-9 4-9-4z"/><path d="M3 7l9 4 9-4"/><path d="M12 11v10"/>',
"outreach": '<path d="M22 2 11 13"/><path d="M22 2 15 22l-4-9-9-4z"/>',
"asset": '<rect x="3" y="3" width="18" height="13" rx="2"/><path d="M8 21h8M12 16v5"/><path d="M7 7h10M7 11h6"/>',
"home": '<path d="M3 11 12 3l9 8"/><path d="M5 10v10h14V10"/>',
"expense": '<rect x="3" y="6" width="18" height="13" rx="2"/><path d="M3 10h18"/><path d="M7 15h4"/>',
+21 -11
View File
@@ -577,7 +577,7 @@ async def gmail_connect(request: Request, next: str = "/inout/") -> Any: # noqa
except gmail.GmailError as exc:
return _redirect(_safe_next(next), str(exc))
request.session["_inout_gmail_next"] = _safe_next(next)
request.session.pop("_gmail_origin", None) # 휴가 옵션에서 시작한 연결 표시가 남아 있으면 지움
request.session.pop("_gmail_origin", None) # 휴가·안내문 발송에서 시작한 연결 표시가 남아 있으면 지움
return await client.authorize_redirect(
request, public_url_for(request, "inout_gmail_callback"),
access_type="offline", prompt="consent", include_granted_scopes="true",
@@ -586,7 +586,7 @@ async def gmail_connect(request: Request, next: str = "/inout/") -> Any: # noqa
@router.get("/gmail/callback", name="inout_gmail_callback")
async def gmail_callback(request: Request) -> Any:
if request.session.get("_gmail_origin") == "vacation":
if request.session.get("_gmail_origin") in _GMAIL_ORIGINS:
return await _gmail_callback_vacation(request)
got = _ctx(request)
if not isinstance(got, tuple):
@@ -611,9 +611,17 @@ async def gmail_callback(request: Request) -> Any:
return _redirect(nxt, "Gmail 을 연결했습니다 — 이제 [메일 발송]으로 보낼 수 있습니다.")
# 다른 모듈에서 시작한 [Gmail 연결] — 세션 _gmail_origin = 모듈 키 → (돌아갈 기본 주소, 권한 없을 때 문구, 연결 뒤 문구)
_GMAIL_ORIGINS: dict[str, tuple[str, str, str]] = {
"vacation": ("/vacation/options", "휴가 관리 모듈 권한이 없습니다.", "Gmail 을 연결했습니다 — 이제 휴가 메일이 내 Gmail 로 나갑니다."),
"outreach": ("/outreach/", "안내문 발송 모듈 권한이 없습니다.", "Gmail 을 연결했습니다 — 이제 안내문 메일을 내 Gmail 로 보낼 수 있습니다."),
}
async def _gmail_callback_vacation(request: Request) -> Any:
"""휴가 옵션 [Gmail 연결](2026-10-27) — 같은 구글 리디렉션 주소를 함께 쓰므로 여기로 돌아온다(구글 클라우드 설정 추가 없음).
입출고 담당 권한 대신 휴가 모듈 권한을 보고, 토큰은 입출고와 같은 inout_gmail_tokens 에(한 사람 = 연결 하나, 두 모듈이 같이 씀)."""
"""휴가 옵션·안내문 발송의 [Gmail 연결](2026-10-27) — 같은 구글 리디렉션 주소를 함께 쓰므로 여기로 돌아온다(구글 클라우드 설정 추가 없음).
입출고 담당 권한 대신 그 모듈 권한(_GMAIL_ORIGINS)을 보고, 토큰은 입출고와 같은 inout_gmail_tokens 에(한 사람 = 연결 하나, 모듈이 같이 씀).
돌아갈 주소 = 세션 _gmail_next(그 모듈 경로 아래만, 예전 휴가 _vacation_gmail_next 도 읽음)."""
from urllib.parse import quote # noqa: WPS433
from authlib.integrations.starlette_client import OAuthError # noqa: WPS433
@@ -623,15 +631,17 @@ async def _gmail_callback_vacation(request: Request) -> Any:
from . import gmail # noqa: WPS433
request.session.pop("_gmail_origin", None)
nxt = str(request.session.pop("_vacation_gmail_next", "") or "")
if not nxt.startswith("/vacation/") or "//" in nxt or "\\" in nxt:
nxt = "/vacation/options"
origin = str(request.session.pop("_gmail_origin", "") or "")
home, denied, done = _GMAIL_ORIGINS[origin]
nxt = str(request.session.pop("_gmail_next", "") or request.session.pop("_vacation_gmail_next", "") or "")
request.session.pop("_vacation_gmail_next", None)
if not nxt.startswith(f"/{origin}/") or "//" in nxt or "\\" in nxt:
nxt = home
user = get_current_user_record(request)
if user is None:
return RedirectResponse(url="/login?next=" + quote(nxt, safe=""), status_code=303)
if not has_module(user, "vacation"):
raise HTTPException(status_code=403, detail="휴가 관리 모듈 권한이 없습니다.")
if not has_module(user, origin):
raise HTTPException(status_code=403, detail=denied)
st = _store(request)
if st is None:
return _redirect(nxt, "Gmail 연결 저장소(입출고 DB)가 설정되지 않아 연결할 수 없습니다.")
@@ -645,7 +655,7 @@ async def _gmail_callback_vacation(request: Request) -> Any:
return _redirect(nxt, msg)
except (gmail.GmailError, ValueError) as exc:
return _redirect(nxt, str(exc))
return _redirect(nxt, "Gmail 을 연결했습니다 — 이제 휴가 메일이 내 Gmail 로 나갑니다.")
return _redirect(nxt, done)
@router.post("/gmail/disconnect")
+22
View File
@@ -0,0 +1,22 @@
# [안내문 발송] 안내문 발송 모듈 — `app/modules/outreach/`, `outreach_db`
> 이 모듈만 고칠 때 읽는 요약. 별도 상세 문서 없음 — 코드가 기준.
> 정적 파일: `app/static/outreach.js`, `app/static/outreach.css`. 템플릿: `templates/outreach/`. 테스트: `tests/test_outreach.py`,
> `tests/js/outreach.browser.test.js`(`render_outreach.py`).
> 다른 모듈과 연결: 메일 = 입출고 Gmail 연결(`inout_store.inout_gmail_tokens`, `app/modules/inout/gmail.py`, 콜백 `/inout/gmail/callback` 이
> 세션 `_gmail_origin=outreach` 를 보고 `_GMAIL_ORIGINS` 로 처리) — 입출고·휴가와 같은 연결.
- 리스트(주소 + 이름)에 안내문을 보낸다(2026-10-27). 권한키 `outreach`(보기·리스트·보내기·설정 모두), DB `OUTREACH_DB_URL`(없으면 "설정 필요" 안내).
- **주소를 보고 메일/DM 판별**(`store.detect`): `name@domain.tld` = 메일, `@계정`·`instagram.com/계정`·`ig.me/m/계정`·계정명만(영문·숫자·.·_) = 인스타 DM.
게시물 주소(`/p/`·`/reel/`)·한글만은 오류. 같은 주소는 한 번(`UNIQUE(kind, handle)`, 이메일·계정명 소문자).
- 리스트 추가 = 붙여넣기(한 줄에 한 사람 `주소, 이름` — 쉼표·탭·띄어쓰기, 순서는 어느 쪽이든, `store.parse_line`) → [미리보기](메일/DM/오류·중복·이미 있음) → [리스트에 추가].
- **본문 `{이름}`** = 그 줄 이름(제목에도). 이름이 빈 줄은 보내지 않고 실패('이름 없음'), 화면에 "이름 필요" 표시. `**굵게**` = 메일 굵은 글씨(DM 은 별표만 뺌), 주소 = 메일 링크.
- **메일** = [고른 메일 보내기] → `db.claim_for_send`(고른 줄 중 메일·대기/실패만 '발송중'으로 한 UPDATE — 두 번 눌러도·두 사람이 눌러도 한 번) →
`send.send_batch`(백그라운드, **보내는 사람 본인 Gmail**, 한 사람에 한 통·1초 간격, 설정 사진 = 본문 아래 cid) → 보냄/실패 + `outreach_logs`.
Gmail 연결 없으면 409(화면이 [Gmail 연결] 안내), 끊기면 남은 줄 실패. 서버 재시작 때 남은 '발송중' = 실패(`release_stuck`).
- **인스타 DM = 반자동** — 인스타 공식 API 는 처음 연락하는 사람에게 DM 을 보낼 수 없다(상대가 먼저 보낸 24시간 안만, 자동 DM 은 약관 위반·계정 정지 위험).
[DM 보내기] = 그 사람 이름이 든 문구 복사 + `https://ig.me/m/계정` 새 탭(누르는 순간 — 문구는 리스트 데이터에 미리 담음) → 붙여 넣어 보낸 뒤 [보냄](`dm-sent`, 기록).
- **설정** `/outreach/settings`(모듈 권한자 누구나): 메일 제목·본문(기본 = 미라네주방 공동구매 제안 문구, `store.DEFAULT_TEMPLATE`)·보내는 이름·끝 문구(수신 거부 안내 등)·
제목 앞 "(광고)" — 영리 목적 광고성 메일은 정보통신망법 제50조(제목 "(광고)"·수신 거부 방법) 대상일 수 있어 칸을 둠(법무 확인 권장).
본문 아래 사진 최대 10장(서버가 가로 700px JPEG 로 줄여 `outreach_images` 에, 순서 ◀▶). [기본 문구로 되돌리기] = 칸만(저장해야 적용).
- 리스트 줄: 이름 바로 고치기(칸 떠나면 저장), [미리보기](메일 = 제목·HTML, DM = 글), 고른 줄 다시 대기·지우기(발송중은 못 지움), 걸러 보기(전체·메일·DM·대기·보냄·실패).
+28
View File
@@ -0,0 +1,28 @@
"""안내문 발송(outreach) 모듈 — 리스트(이메일·인스타그램 주소 + 이름)에 안내문을 보낸다(2026-10-27).
- 라우터: `router.py` (prefix=/outreach) · 저장소: `db.py` (outreach_db) · 순수 함수: `store.py`(주소 판별·{이름}·본문)
- 메일 일괄 발송: `send.py` — 보내는 사람 본인 Gmail(입출고·휴가와 같은 Gmail 연결)
- 인스타 DM: 반자동(문구 복사 + DM 창 열기 + [보냄] 기록) — 인스타 공식 API 는 처음 연락하는 사람에게 DM 을 보낼 수 없다.
- 템플릿: `templates/outreach/`, 화면 스크립트·스타일 `static/outreach.{js,css}`
OUTREACH_DB_URL 미설정이면 build_outreach_store 가 None → 화면이 "설정 필요" 안내(앱은 죽지 않음). 권한키 `outreach`.
"""
from typing import Any
from .router import router
__all__ = ["router", "build_outreach_store"]
def build_outreach_store(*, dsn: str | None) -> Any:
if not dsn:
return None
from .db import OutreachDBStore # 지연 import
st = OutreachDBStore(dsn)
try:
st.release_stuck() # 서버가 보내던 중 다시 시작됨 → 발송중 줄을 실패로(다시 보낼 수 있게)
except Exception: # noqa: BLE001 — DB 가 잠시 없어도 앱은 뜬다
pass
return st
+220
View File
@@ -0,0 +1,220 @@
"""outreach_db PostgreSQL 저장소 — 안내문 발송(2026-10-27).
- 연결: 환경변수 `OUTREACH_DB_URL` (예: postgresql://outreach_app:<pwd>@postgres-db:5432/outreach_db)
- 스키마는 앱이 만들지 않는다 — `scripts/sql/outreach_db_init.sql` 을 superuser 가 먼저 적용(앱 계정은 CRUD 만).
- 연결 풀은 lazy open — 부팅 때 DB 가 잠시 끊겨도 컨테이너가 죽지 않게(다른 모듈과 같은 방식).
"""
from __future__ import annotations
from datetime import datetime
from typing import Any
from psycopg.rows import dict_row
from psycopg.types.json import Jsonb
from psycopg_pool import ConnectionPool
from app.timezone import KST
from . import store
MAX_IMAGES = 10
def _iso(v: Any) -> str:
return v.astimezone(KST).isoformat(timespec="seconds") if isinstance(v, datetime) else ""
class OutreachDBStore:
def __init__(self, dsn: str, *, min_size: int = 1, max_size: int = 4):
self._pool = ConnectionPool(conninfo=dsn, min_size=min_size, max_size=max_size,
kwargs={"row_factory": dict_row, "autocommit": True}, open=False)
self._pool.open(wait=False)
def close(self) -> None:
self._pool.close()
# ── 설정(제목·본문·보내는 이름·끝 문구·(광고)) ─────────────────
def get_template(self) -> dict[str, Any]:
with self._pool.connection() as conn:
row = conn.execute("SELECT value, updated_by, updated_at FROM outreach_settings WHERE key = 'template'").fetchone()
t = store.normalize_template(row["value"] if row and isinstance(row["value"], dict) else None)
t["updated_by"] = row["updated_by"] if row else ""
t["updated_at"] = _iso(row["updated_at"]) if row else ""
t["is_default"] = row is None
return t
def save_template(self, value: dict[str, Any], *, by: str) -> dict[str, Any]:
t = store.normalize_template(value)
if not t["subject"]:
raise ValueError("메일 제목을 쓰세요.")
if not t["body"].strip():
raise ValueError("본문을 쓰세요.")
with self._pool.connection() as conn:
conn.execute(
"INSERT INTO outreach_settings (key, value, updated_by, updated_at) VALUES ('template', %s, %s, now()) "
"ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_by = EXCLUDED.updated_by, updated_at = now()",
(Jsonb({k: t[k] for k in store.DEFAULT_TEMPLATE}), (by or "").lower()),
)
return self.get_template()
# ── 메일 본문 아래 사진 ────────────────────────────────
def list_images(self, *, with_data: bool = False) -> list[dict[str, Any]]:
cols = "id, filename, width, height, sort_order" + (", data" if with_data else "")
with self._pool.connection() as conn:
rows = conn.execute(f"SELECT {cols} FROM outreach_images ORDER BY sort_order, id").fetchall()
return [dict(r) for r in rows]
def get_image(self, image_id: int) -> dict[str, Any] | None:
with self._pool.connection() as conn:
return conn.execute("SELECT * FROM outreach_images WHERE id = %s", (image_id,)).fetchone()
def add_image(self, *, filename: str, data: bytes, width: int, height: int, by: str) -> int:
with self._pool.connection() as conn:
with conn.transaction():
n = conn.execute("SELECT COUNT(*) AS n, COALESCE(MAX(sort_order), -1) + 1 AS nxt FROM outreach_images").fetchone()
if n["n"] >= MAX_IMAGES:
raise ValueError(f"사진은 {MAX_IMAGES}장까지 넣을 수 있습니다.")
return int(conn.execute(
"INSERT INTO outreach_images (filename, data, width, height, sort_order, created_by) "
"VALUES (%s, %s, %s, %s, %s, %s) RETURNING id",
(filename[:200], data, width, height, int(n["nxt"]), (by or "").lower()),
).fetchone()["id"])
def delete_image(self, image_id: int) -> None:
with self._pool.connection() as conn:
conn.execute("DELETE FROM outreach_images WHERE id = %s", (image_id,))
def move_image(self, image_id: int, direction: int) -> None:
"""사진 순서 한 칸 앞/뒤(-1/1)."""
ids = [r["id"] for r in self.list_images()]
if image_id not in ids:
return
i = ids.index(image_id)
j = i + (-1 if direction < 0 else 1)
if not 0 <= j < len(ids):
return
ids[i], ids[j] = ids[j], ids[i]
with self._pool.connection() as conn:
conn.execute("UPDATE outreach_images m SET sort_order = v.ord FROM unnest(%s::int[]) WITH ORDINALITY AS v(id, ord) "
"WHERE m.id = v.id", (ids,))
# ── 리스트 ───────────────────────────────────────────
@staticmethod
def _row(r: dict[str, Any]) -> dict[str, Any]:
d = dict(r)
d["id"] = int(d["id"])
for k in ("sent_at", "created_at", "updated_at"):
d[k] = _iso(d.get(k))
return d
def list_recipients(self) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM outreach_recipients ORDER BY id").fetchall()
return [self._row(r) for r in rows]
def get_recipient(self, rid: int) -> dict[str, Any] | None:
with self._pool.connection() as conn:
r = conn.execute("SELECT * FROM outreach_recipients WHERE id = %s", (rid,)).fetchone()
return self._row(r) if r else None
def add_recipients(self, rows: list[dict[str, Any]], *, by: str) -> dict[str, int]:
"""[{address, name}] 추가 — 주소를 보고 메일/DM 을 정한다. 이미 있는 주소는 이름만 비어 있으면 채우고 건너뜀.
반환 {added, existed, invalid}. 틀린 주소는 저장하지 않고 센다(화면이 미리 보여 줌)."""
out = {"added": 0, "existed": 0, "invalid": 0}
who = (by or "").lower()
with self._pool.connection() as conn:
with conn.transaction():
for r in rows:
d = store.detect(r.get("address"))
if not d["kind"]:
out["invalid"] += 1
continue
name = str(r.get("name") or "").strip()[:100]
got = conn.execute(
"INSERT INTO outreach_recipients (kind, handle, address, name, created_by) VALUES (%s, %s, %s, %s, %s) "
"ON CONFLICT (kind, handle) DO UPDATE SET name = CASE WHEN outreach_recipients.name = '' "
"THEN EXCLUDED.name ELSE outreach_recipients.name END RETURNING (xmax = 0) AS inserted",
(d["kind"], d["handle"], str(r.get("address") or "").strip()[:320], name, who),
).fetchone()
out["added" if got["inserted"] else "existed"] += 1
return out
def update_recipient(self, rid: int, *, name: Any = None, memo: Any = None, status: Any = None) -> dict[str, Any]:
sets, params = [], []
if name is not None:
sets.append("name = %s")
params.append(str(name).strip()[:100])
if memo is not None:
sets.append("memo = %s")
params.append(str(memo).strip()[:500])
if status is not None:
if status != "대기":
raise ValueError("상태는 '대기'(다시 보내기)로만 바꿀 수 있습니다.")
sets += ["status = '대기'", "last_error = ''"]
if not sets:
raise ValueError("바꿀 내용이 없습니다.")
with self._pool.connection() as conn:
r = conn.execute(f"UPDATE outreach_recipients SET {', '.join(sets)} WHERE id = %s RETURNING *", (*params, rid)).fetchone()
if not r:
raise KeyError(rid)
return self._row(r)
def delete_recipients(self, ids: list[int]) -> int:
with self._pool.connection() as conn:
cur = conn.execute("DELETE FROM outreach_recipients WHERE id = ANY(%s) AND status <> '발송중'", ([int(i) for i in ids],))
return cur.rowcount
# ── 보내기 ───────────────────────────────────────────
def claim_for_send(self, ids: list[int]) -> list[dict[str, Any]]:
"""메일 일괄 발송 — 고른 줄 중 메일·대기/실패만 '발송중'으로 바꾸며 가져온다(한 UPDATE — 두 번 눌러도·두 사람이 눌러도 한 번만)."""
with self._pool.connection() as conn:
rows = conn.execute(
"UPDATE outreach_recipients SET status = '발송중', last_error = '' "
"WHERE id = ANY(%s) AND kind = 'email' AND status IN ('대기', '실패') RETURNING *",
([int(i) for i in ids],),
).fetchall()
return sorted((self._row(r) for r in rows), key=lambda r: r["id"])
def finish_send(self, rid: int, *, ok: bool, via: str, by: str, subject: str, error: str = "") -> None:
with self._pool.connection() as conn:
with conn.transaction():
r = conn.execute(
"UPDATE outreach_recipients SET status = %s, sent_at = CASE WHEN %s THEN now() ELSE sent_at END, "
"sent_by = CASE WHEN %s THEN %s ELSE sent_by END, sent_via = CASE WHEN %s THEN %s ELSE sent_via END, "
"last_error = %s WHERE id = %s RETURNING kind, address, name",
("보냄" if ok else "실패", ok, ok, (by or "").lower(), ok, via, (error or "")[:500], rid),
).fetchone()
if r:
conn.execute(
"INSERT INTO outreach_logs (recipient_id, kind, address, name, subject, via, sent_by, ok, error) "
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)",
(rid, r["kind"], r["address"], r["name"], (subject or "")[:300], via, (by or "").lower(), ok, (error or "")[:500]),
)
def mark_dm_sent(self, rid: int, *, by: str, subject: str) -> dict[str, Any]:
"""DM [보냄] — 인스타 줄만(사람이 DM 창에서 보낸 뒤 누름)."""
r = self.get_recipient(rid)
if r is None:
raise KeyError(rid)
if r["kind"] != "instagram":
raise ValueError("메일 줄은 [일괄 발송]으로 보냅니다.")
self.finish_send(rid, ok=True, via="dm", by=by, subject=subject)
return self.get_recipient(rid) # type: ignore[return-value]
def release_stuck(self) -> int:
"""서버가 보내던 중 멈춘 줄(발송중)을 실패로 — 서버 시작 때(앱은 프로세스 하나, 보내기는 메모리 작업)."""
with self._pool.connection() as conn:
cur = conn.execute("UPDATE outreach_recipients SET status = '실패', last_error = '보내던 중 서버가 다시 시작됨 — 다시 보내세요' "
"WHERE status = '발송중'")
return cur.rowcount
def list_logs(self, *, limit: int = 200) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM outreach_logs ORDER BY sent_at DESC, id DESC LIMIT %s", (limit,)).fetchall()
out = []
for r in rows:
d = dict(r)
d["sent_at"] = _iso(d["sent_at"])
out.append(d)
return out
+389
View File
@@ -0,0 +1,389 @@
"""안내문 발송(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 urllib.parse import quote # noqa: WPS433
from app.main import build_erp_nav, get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin # noqa: WPS433
user = get_current_user_record(request)
if user is None:
here = str(request.url.path) + ("?" + request.url.query if request.url.query else "")
return RedirectResponse(url="/login?next=" + quote(here, safe=""), status_code=303)
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) 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.plain_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, "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": "메일 제목 · 본문 · 사진",
"template": st.get_template(), "default": store.DEFAULT_TEMPLATE, "images": st.list_images(),
"max_images": 10, "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("")) -> RedirectResponse:
user = _user(request)
st = _db(request)
try:
st.save_template({"subject": subject, "body": body, "sender_name": sender_name, "footer": footer,
"ad_label": ad_label in ("1", "on", "true")}, 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.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)
+94
View File
@@ -0,0 +1,94 @@
"""안내문 메일 일괄 발송(2026-10-27) — 보내는 사람 본인 Gmail(입출고·휴가와 같은 Gmail 연결, gmail.send 만)로 한 사람에 한 통.
라우터가 고른 줄을 '발송중'으로 잡은 뒤(db.claim_for_send — 두 번 눌러도 한 번) 응답하고, 이 함수가 백그라운드에서 차례로 보낸다.
줄마다 {이름} 을 바꾼 제목·본문 + 설정 사진(본문 아래, cid)을 만들어 보내고 보냄/실패와 기록(outreach_logs)을 남긴다.
본문에 {이름} 이 있는데 이름이 빈 줄은 보내지 않고 실패('이름 없음'). Gmail 연결이 끊기면 남은 줄은 실패(다시 연결 안내).
"""
from __future__ import annotations
import logging
import time
from typing import Any
from . import store
logger = logging.getLogger("app.outreach.send")
SEND_GAP_SECONDS = 1.0 # 한 통마다 쉬는 시간 — Gmail 이 짧은 시간에 몰린 발송을 막지 않게
def _cid(image_id: int) -> str:
return f"outreach-{image_id}@dbx"
def build_mail(template: dict[str, Any], images: list[dict[str, Any]], *, name: str, sender_name: str, sender_email: str,
to: str) -> bytes:
from app.modules.inout import gmail # noqa: WPS433
cids = [_cid(int(im["id"])) for im in images]
return gmail.build_message(
sender_name=template.get("sender_name") or sender_name, sender_email=sender_email, to=[to], cc=[],
subject=store.subject_for(template, name), text=store.plain_text(template, name),
html=store.html_body(template, name, cids),
inline_images=[{"cid": c, "data": bytes(im["data"])} for c, im in zip(cids, images)],
)
def send_batch(db: Any, inout_store: Any, *, rows: list[dict[str, Any]], user: dict[str, Any],
gap: float = SEND_GAP_SECONDS) -> dict[str, int]:
"""잡아 둔 줄(rows)을 차례로 보낸다 — {"sent", "failed"}. 예외를 밖으로 던지지 않는다(줄마다 결과를 남김)."""
from app.modules.inout import gmail # noqa: WPS433
email = str(user.get("email") or "").lower()
result = {"sent": 0, "failed": 0}
try:
template = db.get_template()
images = db.list_images(with_data=True)
subject_of = lambda r: store.subject_for(template, r["name"]) # noqa: E731
row = inout_store.gmail_token(email) if inout_store is not None else None
refresh = gmail.decrypt_token(email, row["refresh_token_enc"]) if row else None
except Exception as exc: # noqa: BLE001 — 준비 실패 = 잡아 둔 줄 모두 실패(발송중으로 남지 않게)
for r in rows:
db.finish_send(r["id"], ok=False, via="gmail", by=email, subject="", error=f"보낼 준비 실패: {exc}")
result["failed"] = len(rows)
return result
stop_reason = "" if refresh else "Gmail 이 연결되지 않았습니다 — 안내문 발송 → [Gmail 연결] 뒤 다시 보내세요."
need_name = store.needs_name(template)
for i, r in enumerate(rows):
if stop_reason:
db.finish_send(r["id"], ok=False, via="gmail", by=email, subject=subject_of(r), error=stop_reason)
result["failed"] += 1
continue
if need_name and not (r.get("name") or "").strip():
db.finish_send(r["id"], ok=False, via="gmail", by=email, subject=subject_of(r),
error="이름 없음 — 본문에 {이름} 이 있어 이름을 넣은 뒤 다시 보내세요.")
result["failed"] += 1
continue
try:
raw = build_mail(template, images, name=r["name"], sender_name=str(user.get("name") or ""),
sender_email=email, to=r["handle"])
gmail.send(refresh, raw)
except gmail.GmailNotConnected as exc:
try:
inout_store.delete_gmail_token(email)
except Exception: # noqa: BLE001
pass
stop_reason = f"Gmail 연결이 끊겼습니다 — 다시 연결한 뒤 보내세요. ({exc})"
db.finish_send(r["id"], ok=False, via="gmail", by=email, subject=subject_of(r), error=stop_reason)
result["failed"] += 1
continue
except Exception as exc: # noqa: BLE001 — 그 사람만 실패(받는 주소 오류 등), 다음 사람은 계속
db.finish_send(r["id"], ok=False, via="gmail", by=email, subject=subject_of(r), error=str(exc)[:300])
result["failed"] += 1
continue
db.finish_send(r["id"], ok=True, via="gmail", by=email, subject=subject_of(r))
result["sent"] += 1
if gap and i < len(rows) - 1:
time.sleep(gap)
try:
if inout_store is not None and result["sent"]:
inout_store.mark_gmail(email)
except Exception: # noqa: BLE001
pass
logger.info("안내문 메일 %s: 보냄 %s · 실패 %s", email, result["sent"], result["failed"])
return result
+199
View File
@@ -0,0 +1,199 @@
"""안내문 발송 — 순수 함수(DB 없음): 주소 판별(이메일 / 인스타그램), 리스트 붙여넣기 해석, {이름} 바꾸기, 메일 HTML·DM 글.
- 주소를 보고 정한다: `name@domain.tld` = 메일, `@계정`·`instagram.com/계정`·`ig.me/m/계정`·계정명만(영문·숫자·.·_) = 인스타 DM.
- 본문 `{이름}` = 그 줄 이름. `**굵게**` 는 메일에서 굵은 글씨, DM 에서는 별표만 뺀다(인스타는 서식이 없음). 주소(https://…)는 메일에서 링크.
"""
from __future__ import annotations
import re
from html import escape
from typing import Any
NAME_TAG = "{이름}"
KINDS = ("email", "instagram")
KIND_LABELS = {"email": "메일", "instagram": "DM"}
STATUSES = ("대기", "발송중", "보냄", "실패")
_EMAIL_RE = re.compile(r"^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)+$")
_IG_USER_RE = re.compile(r"^[A-Za-z0-9._]{1,30}$")
_IG_URL_RE = re.compile(r"^(?:https?://)?(?:www\.|m\.)?(?:instagram\.com|instagr\.am)/([^/?#\s]+)", re.IGNORECASE)
_IG_ME_RE = re.compile(r"^(?:https?://)?ig\.me/m/([^/?#\s]+)", re.IGNORECASE)
# instagram.com 아래 계정이 아닌 주소(게시물·릴스 등)
_IG_RESERVED = {"p", "reel", "reels", "tv", "explore", "stories", "direct", "accounts", "about", "legal", "developer"}
DEFAULT_TEMPLATE: dict[str, Any] = {
"subject": "누적매출 300억. 800만개 판매 신화 미라클통 '미라네주방'입니다.",
"sender_name": "미라네주방",
"ad_label": False,
"footer": "",
"body": """안녕하세요, {이름}님.
주방의 본질을 지키며 6년간 묵묵히 300억 매출의 신화를 써온 **'미라네주방'**입니다.
저희는 지난 6년간 제품력 하나로 국내/해외 800만 개 판매를 돌파하고 호주, 동남아 등 글로벌 시장에서 인정받았습니다.
브랜드의 가치를 지키기 위해 공동구매를 극도로 자제해왔으나,
최근 'ㅎ 인플루언서'와의 PPL 및 전용 상품 협업을 통해 단일 프로젝트 매출 약3억, 누적 약 8억원이라는 놀라운 기록을 확인하였고,
ㄷ'인플루언서'님과는 약 2억원의 매출을 달성하는 등 인플루언서 파트너십의 새로운 가능성을 보았습니다.
이에, 압도적인 신뢰도와 감각을 보유하신 {이름}님과의 공동구매 파트너십을 정중히 제안드립니다.
왜 '미라네주방'이어야 하는가?
시장 점유율로 증명된 '미라클통'의 힘: 누적 800만 개 판매. 이미 시장에서 검증된 제품은 팔로워들에게 구구절절 설명할 필요가 없습니다.
희소성의 가치: 아무나 할 수 있는 공구가 아닙니다. 공구를 지양해온 브랜드이기에 {이름}님의 피드에서 진행되는 공구는 팔로워들에게 더욱 특별한 기회로 인식될 것입니다.
1단계: 검증된 베스트셀러로 화력 확인 (Existing Product)
이미 800만 개가 팔려나가며 시장성이 검증된 ‘미라클통’ 등 기존 베스트셀러 라인으로 공동구매를 진행합니다.
팔로워들에게는 '구하고 싶어도 공구로 만나기 힘들었던 제품'이라는 명분을, 인플루언서님께는 확실한 수익과 유입을 보장합니다.
2단계: 화력 입증 시 {이름}님 전용 상품 개발 (Exclusive Product)
첫 공구에서 유의미한 매출 성과가 확인될 경우, 저희는 즉시 {이름}님만을 위한 전용 상품(PB/콜라보) 개발에 착수합니다.
전용 컬러, 단독 구성, 혹은 니즈를 반영한 신규 기능을 담아, 어디에서도 볼 수 없는 '귀하만의 제품'을 시장에 선보이게 됩니다.
이는 인플루언서로서의 브랜드 가치를 한 단계 높이는 결정적인 계기가 될 것입니다.
"'ㅎ인플루언서님'과의 콜라보 사례를 하단과 같이 사진 공유드립니다."
미라네주방은 단순히 한 번의 공구로 끝나는 관계를 원하지 않습니다.
{이름}님의 감각과 저희의 기술력이 만나 주방용품 시장의 판도를 바꿀 '전용 브랜드'를 함께 만들어가길 희망합니다.
긍정적인 검토 부탁드리며, 미라네주방의 성공 신화에 함께 올라타실 파트너가 되어주시길 기다리겠습니다.
감사합니다.
미라네주방 팀 드림
https://miras.co.kr/""",
}
SUBJECT_MAX, BODY_MAX, FOOTER_MAX = 200, 20000, 2000
def _ig_user(value: str) -> str | None:
v = value.strip().strip("/")
if v.startswith("@"):
v = v[1:]
if not _IG_USER_RE.match(v) or v.startswith(".") or v.endswith(".") or ".." in v:
return None
if v.lower() in _IG_RESERVED:
return None
return v.lower()
def detect(address: Any) -> dict[str, Any]:
"""주소 → {"kind": "email"|"instagram"|None, "handle", "error"}. handle = 이메일 소문자 / 인스타 계정명 소문자."""
raw = str(address or "").strip().strip("<>").strip()
if raw.lower().startswith("mailto:"):
raw = raw[7:]
if not raw:
return {"kind": None, "handle": "", "error": "주소가 비었습니다."}
if "@" in raw and not raw.startswith("@") and "/" not in raw:
if _EMAIL_RE.match(raw) and len(raw) <= 320:
return {"kind": "email", "handle": raw.lower(), "error": ""}
return {"kind": None, "handle": "", "error": f"이메일 주소가 올바르지 않습니다: {raw}"}
for rx in (_IG_ME_RE, _IG_URL_RE):
m = rx.match(raw)
if m:
user = _ig_user(m.group(1))
if user:
return {"kind": "instagram", "handle": user, "error": ""}
return {"kind": None, "handle": "", "error": f"인스타그램 계정 주소가 아닙니다: {raw}"}
user = _ig_user(raw)
if user and (raw.startswith("@") or re.search(r"[A-Za-z]", raw)):
return {"kind": "instagram", "handle": user, "error": ""}
return {"kind": None, "handle": "", "error": f"이메일도 인스타그램 주소도 아닙니다: {raw}"}
def _looks_explicit(part: str) -> bool:
"""이메일·@계정·인스타 주소처럼 '주소'가 분명한 칸인가(계정명만 쓴 칸보다 먼저 주소로 고른다)."""
p = part.strip()
return "@" in p or "instagram.com" in p.lower() or "instagr.am" in p.lower() or "ig.me/" in p.lower()
def parse_line(line: str) -> dict[str, Any] | None:
"""붙여 넣은 한 줄 → {"address", "name", ...detect}. 빈 줄·#주석 = None.
칸 나누기 = 탭 · 쉼표 · (둘 다 없으면) 공백. 주소가 분명한 칸(이메일·@·인스타 링크)을 주소로, 나머지는 이름.
둘 다 분명하지 않으면 '주소, 이름' 순서로 본다."""
s = line.strip()
if not s or s.startswith("#"):
return None
parts = [p.strip() for p in re.split(r"\t|,", s) if p.strip()]
if len(parts) == 1:
parts = s.split()
addr_i = next((i for i, p in enumerate(parts) if _looks_explicit(p) and detect(p)["kind"]), None)
if addr_i is None:
addr_i = next((i for i, p in enumerate(parts) if detect(p)["kind"]), 0)
address = parts[addr_i]
name = " ".join(p for i, p in enumerate(parts) if i != addr_i).strip()
return {"address": address, "name": name[:100], **detect(address)}
def parse_bulk(text: str) -> list[dict[str, Any]]:
"""여러 줄 붙여넣기 → 줄마다 parse_line(빈 줄 건너뜀), 같은 주소는 처음 것만(dup=True 표시)."""
out: list[dict[str, Any]] = []
seen: set[tuple[str, str]] = set()
for i, line in enumerate(str(text or "").splitlines(), 1):
r = parse_line(line)
if r is None:
continue
r["line"] = i
key = (r["kind"] or "", r["handle"])
r["dup"] = bool(r["kind"]) and key in seen
seen.add(key)
out.append(r)
return out
def normalize_template(value: dict[str, Any] | None) -> dict[str, Any]:
"""설정 값 정리 — 빠진 칸은 기본값, 길이 제한."""
v = dict(DEFAULT_TEMPLATE)
for k, val in (value or {}).items():
if k in v:
v[k] = val
v["subject"] = str(v["subject"] or "").strip()[:SUBJECT_MAX]
v["body"] = str(v["body"] or "").replace("\r\n", "\n")[:BODY_MAX]
v["footer"] = str(v["footer"] or "").replace("\r\n", "\n").strip()[:FOOTER_MAX]
v["sender_name"] = str(v["sender_name"] or "").strip()[:60]
v["ad_label"] = bool(v["ad_label"])
return v
def needs_name(template: dict[str, Any]) -> bool:
return NAME_TAG in (template.get("subject") or "") or NAME_TAG in (template.get("body") or "")
def fill(text: str, name: str) -> str:
return str(text or "").replace(NAME_TAG, str(name or "").strip())
def subject_for(template: dict[str, Any], name: str) -> str:
s = fill(template.get("subject") or "", name)
return ("(광고) " + s) if template.get("ad_label") and not s.startswith("(광고)") else s
def _body_text(template: dict[str, Any], name: str) -> str:
body = fill(template.get("body") or "", name).rstrip()
footer = (template.get("footer") or "").strip()
return body + ("\n\n" + fill(footer, name) if footer else "")
def plain_text(template: dict[str, Any], name: str) -> str:
"""메일 글 부분·DM 글 — **굵게** 표시는 별표만 뺀다."""
return re.sub(r"\*\*(.+?)\*\*", r"\1", _body_text(template, name))
_URL_RE = re.compile(r"https?://[^\s<>\"']+")
def html_body(template: dict[str, Any], name: str, image_cids: list[str] | None = None) -> str:
"""메일 HTML — 사용자 글은 늘 escape, **굵게** → <b>, 주소 → 링크, 줄바꿈 그대로, 사진은 본문 아래(cid)."""
text = escape(_body_text(template, name))
text = re.sub(r"\*\*(.+?)\*\*", r"<b>\1</b>", text)
text = _URL_RE.sub(lambda m: f'<a href="{m.group(0)}" style="color:#1a56db">{m.group(0)}</a>', text)
imgs = "".join(f'<p style="margin:12px 0 0"><img src="cid:{c}" alt="" style="max-width:100%;height:auto;border-radius:6px"></p>'
for c in (image_cids or []))
return ('<div style="font-family:Pretendard,\'Malgun Gothic\',sans-serif;font-size:14px;line-height:1.7;color:#111;white-space:pre-wrap">'
f"{text}</div>{imgs}")
def dm_link(handle: str) -> str:
"""인스타 DM 창 — ig.me/m/계정(앱·웹 모두 그 사람과의 대화로)."""
return f"https://ig.me/m/{handle}"
def profile_link(handle: str) -> str:
return f"https://www.instagram.com/{handle}/"
@@ -0,0 +1,102 @@
{% extends "erp_base.html" %}
{#- 안내문 발송(2026-10-27) — 리스트(주소 + 이름) → 메일은 [선택한 메일 보내기](본인 Gmail, 한 사람에 한 통), 인스타는 [DM 보내기](문구 복사 + DM 창)
→ 보낸 뒤 [보냄]. 주소를 보고 메일/DM 을 정한다(store.detect). 본문 {이름} = 그 줄 이름. -#}
{% block head_extra %}<link rel="stylesheet" href="/static/outreach.css?v=20261027a" />{% endblock %}
{% block content %}
<section class="otr" id="otr" data-needs-name="{{ '1' if '{이름}' in (template.subject ~ template.body) else '' }}">
<div class="otr-top">
<div class="otr-top-main">
<button type="button" class="erp-btn erp-btn-primary" id="otr-add-open">+ 리스트 추가</button>
<a class="erp-btn erp-btn-outline" href="/outreach/settings">설정</a>
</div>
<div class="otr-gmail">
{% if gmail.connected %}
<span class="otr-gmail-on">보내는 메일: <b>{{ gmail.email }}</b> (Gmail 연결됨)</span>
<form method="post" action="/outreach/gmail/disconnect" onsubmit="return confirm('Gmail 연결을 끊을까요? 입출고·휴가 메일 연결도 함께 끊깁니다.');">
<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm">연결 끊기</button></form>
{% elif gmail.available %}
<span class="otr-gmail-off">메일은 내 Gmail 로 보냅니다 —</span>
<a class="erp-btn erp-btn-primary erp-btn-sm" href="/outreach/gmail/connect">Gmail 연결</a>
{% else %}
<span class="otr-gmail-off">Gmail 연결을 쓸 수 없는 서버입니다(입출고 DB·구글 OAuth·APP_ENCRYPTION_KEY 필요) — 메일은 보낼 수 없고 DM 만 됩니다.</span>
{% endif %}
</div>
</div>
{% if msg %}<p class="otr-msg" role="status">{{ msg }}</p>{% endif %}
<div class="erp-card otr-tpl">
<div class="otr-tpl-head"><b>보낼 내용</b><span class="erp-muted">(설정에서 바꿉니다)</span></div>
<div class="otr-tpl-subject">{% if template.ad_label %}(광고) {% endif %}{{ template.subject }}</div>
<div class="otr-tpl-body">{{ template.body[:160] }}{% if template.body | length > 160 %}…{% endif %}</div>
<div class="erp-muted otr-tpl-meta">보내는 이름 {{ template.sender_name or '—' }} · 본문 아래 사진 {{ images | length }}장 · <code>{이름}</code> = 줄마다 그 사람 이름</div>
</div>
{#- 리스트 추가 — 붙여 넣기 → [미리보기](메일/DM/오류 판별) → [리스트에 추가] -#}
<div class="erp-card otr-add" id="otr-add" hidden>
<div class="otr-add-head"><b>리스트 추가</b>
<span class="erp-muted">한 줄에 한 사람 — <code>주소, 이름</code> (쉼표·탭·띄어쓰기). 주소 = 이메일(<code>name@domain.com</code>) 또는
인스타(<code>@계정</code> · <code>instagram.com/계정</code> · 계정명). 엑셀에서 두 칸을 복사해 붙여도 됩니다.</span></div>
<textarea class="erp-input otr-add-text" id="otr-add-text" rows="6" placeholder="kim@miras.co.kr, 김철수&#10;@mira.kitchen 미라네&#10;https://www.instagram.com/lee_s/ 이수진"></textarea>
<div class="otr-add-actions">
<button type="button" class="erp-btn erp-btn-outline" id="otr-add-preview">미리보기</button>
<button type="button" class="erp-btn erp-btn-primary" id="otr-add-save" disabled>리스트에 추가</button>
<button type="button" class="erp-btn erp-btn-outline" id="otr-add-close">닫기</button>
<span class="erp-muted" id="otr-add-sum"></span>
</div>
<div class="erp-table-wrap otr-add-preview" id="otr-add-result" hidden></div>
</div>
<div class="erp-card otr-list">
<div class="otr-filter" role="tablist" aria-label="보기">
{% for key, label in (('all', '전체'), ('email', '메일'), ('instagram', 'DM'), ('대기', '대기'), ('보냄', '보냄'), ('실패', '실패')) %}
<button type="button" class="otr-seg{% if key == 'all' %} is-active{% endif %}" data-filter="{{ key }}">{{ label }} <span class="otr-cnt" data-cnt="{{ key }}"></span></button>
{% endfor %}
</div>
<div class="erp-table-wrap">
<table class="erp-table otr-table">
<thead><tr><th class="otr-c-check"><input type="checkbox" id="otr-check-all" aria-label="전체 고르기" /></th>
<th>구분</th><th>이름</th><th>주소</th><th>상태</th><th>보낸 때</th><th class="otr-c-acts"></th></tr></thead>
<tbody id="otr-tbody"></tbody>
</table>
</div>
<p class="erp-muted otr-empty" id="otr-empty" hidden>리스트가 비었습니다 — [+ 리스트 추가]로 넣으세요.</p>
<div class="otr-send-bar">
<span id="otr-selected">고른 줄 0</span>
<button type="button" class="erp-btn erp-btn-primary" id="otr-send"{% if not gmail.connected %} disabled title="Gmail 연결 뒤 보낼 수 있습니다"{% endif %}>고른 메일 보내기</button>
<button type="button" class="erp-btn erp-btn-outline" id="otr-reset">고른 줄 다시 대기로</button>
<button type="button" class="erp-btn erp-btn-outline otr-danger" id="otr-delete">고른 줄 지우기</button>
<span class="erp-muted otr-send-note">메일 = 한 사람에 한 통(본인 Gmail, 1초 간격). DM = 줄의 [DM 보내기] → 문구가 복사되고 인스타 DM 창이 열리면 붙여 넣어 보낸 뒤 [보냄].</span>
</div>
</div>
{% if logs %}
<div class="erp-card otr-logs">
<div class="otr-tpl-head"><b>최근 보낸 기록</b><span class="erp-muted">({{ logs | length }})</span></div>
<ul>
{% for l in logs %}
<li class="{{ 'is-ok' if l.ok else 'is-fail' }}"><span class="otr-when">{{ l.sent_at[5:16] | replace('T', ' ') }}</span>
<b>{{ '메일' if l.kind == 'email' else 'DM' }}</b> {{ l.name or '(이름 없음)' }} · {{ l.address }}
<span class="erp-muted">— {{ l.sent_by }}{% if not l.ok %} · <span class="otr-err">{{ l.error }}</span>{% endif %}</span></li>
{% endfor %}
</ul>
</div>
{% endif %}
</section>
{#- 미리보기 창 -#}
<div class="otr-modal" id="otr-preview" hidden>
<div class="otr-modal-card" role="dialog" aria-modal="true" aria-label="미리보기">
<div class="otr-modal-head"><b id="otr-pv-title">미리보기</b><button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-close>닫기</button></div>
<div class="otr-pv-subject" id="otr-pv-subject"></div>
<iframe class="otr-pv-frame" id="otr-pv-frame" title="본문 미리보기" sandbox></iframe>
</div>
</div>
<script type="application/json" id="otr-data">{{ {"rows": rows} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/outreach.js?v=20261027a" defer></script>{% endblock %}
@@ -0,0 +1,59 @@
{% extends "erp_base.html" %}
{#- 안내문 발송 설정(2026-10-27) — 메일 제목·본문({이름})·보내는 이름·끝 문구·(광고) 표시 + 본문 아래 사진. 메일·DM 모두 이 내용. -#}
{% block head_extra %}<link rel="stylesheet" href="/static/outreach.css?v=20261027a" />{% endblock %}
{% block content %}
<section class="otr otr-settings">
<div class="otr-top"><div class="otr-top-main"><a class="erp-btn erp-btn-outline" href="/outreach/">◀ 리스트</a></div></div>
{% if msg %}<p class="otr-msg" role="status">{{ msg }}</p>{% endif %}
<form method="post" action="/outreach/settings" class="erp-card otr-set-card" id="otr-set-form">
<div class="otr-tpl-head"><b>메일 제목 · 본문</b>
<span class="erp-muted">{% if template.is_default %}기본 문구(아직 저장 안 함){% else %}마지막 저장 {{ template.updated_by }} · {{ template.updated_at[:16] | replace('T', ' ') }}{% endif %}</span></div>
<label class="erp-field otr-field"><span>메일 제목</span>
<input class="erp-input" type="text" name="subject" maxlength="200" required value="{{ template.subject }}" /></label>
<label class="otr-check"><input type="checkbox" name="ad_label" value="1"{% if template.ad_label %} checked{% endif %} />
제목 앞에 <b>(광고)</b> 붙이기 <span class="erp-muted">— 영리 목적 광고성 메일은 정보통신망법 제50조에 따라 제목 앞 "(광고)"·수신 거부 방법을 적어야 합니다(법무 확인 권장)</span></label>
<label class="erp-field otr-field"><span>보내는 이름</span>
<input class="erp-input" type="text" name="sender_name" maxlength="60" value="{{ template.sender_name }}" placeholder="받는 사람 메일함에 보이는 이름" /></label>
<label class="erp-field otr-field"><span>본문 <small class="erp-muted"><code>{이름}</code> = 그 사람 이름 · <code>**굵게**</code> = 메일에서 굵은 글씨(DM 은 별표만 빠짐) · 주소는 메일에서 링크</small></span>
<textarea class="erp-input otr-body" name="body" rows="24" required id="otr-body">{{ template.body }}</textarea></label>
<label class="erp-field otr-field"><span>끝 문구 <small class="erp-muted">(본문 맨 아래 — 수신 거부 안내 등, 비워도 됨)</small></span>
<textarea class="erp-input" name="footer" rows="2" maxlength="2000" placeholder="예: 더 이상 받기를 원하지 않으시면 이 메일에 '수신 거부'라고 회신해 주세요.">{{ template.footer }}</textarea></label>
<div class="otr-set-actions">
<button type="submit" class="erp-btn erp-btn-primary">저장</button>
<button type="button" class="erp-btn erp-btn-outline" id="otr-default">기본 문구로 되돌리기</button>
<span class="erp-muted">되돌리기는 칸만 바꿉니다 — [저장]을 눌러야 적용</span>
</div>
</form>
<div class="erp-card otr-set-card" id="images">
<div class="otr-tpl-head"><b>본문 아래 사진</b><span class="erp-muted">메일 본문 맨 아래에 순서대로(최대 {{ max_images }}장, 가로 700px 로 줄여 저장). DM 에는 붙지 않습니다.</span></div>
<div class="otr-images">
{% for im in images %}
<figure class="otr-image">
<img src="/outreach/images/{{ im.id }}" alt="{{ im.filename }}" loading="lazy" />
<figcaption>{{ loop.index }}. {{ im.filename }}</figcaption>
<div class="otr-image-acts">
{% if not loop.first %}<form method="post" action="/outreach/settings/images/{{ im.id }}/move"><input type="hidden" name="direction" value="-1" /><button class="erp-btn erp-btn-outline erp-btn-sm" title="앞으로">◀</button></form>{% endif %}
{% if not loop.last %}<form method="post" action="/outreach/settings/images/{{ im.id }}/move"><input type="hidden" name="direction" value="1" /><button class="erp-btn erp-btn-outline erp-btn-sm" title="뒤로">▶</button></form>{% endif %}
<form method="post" action="/outreach/settings/images/{{ im.id }}/delete" onsubmit="return confirm('이 사진을 뺄까요?');"><button class="erp-btn erp-btn-outline erp-btn-sm otr-danger">빼기</button></form>
</div>
</figure>
{% else %}
<p class="erp-muted">사진이 없습니다.</p>
{% endfor %}
</div>
{% if images | length < max_images %}
<form method="post" action="/outreach/settings/images" enctype="multipart/form-data" class="otr-upload">
<input type="file" name="files" accept="image/jpeg,image/png,image/webp,image/gif" multiple required />
<button type="submit" class="erp-btn erp-btn-primary">사진 넣기</button>
</form>
{% endif %}
</div>
</section>
<script type="application/json" id="otr-default-data">{{ default | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/outreach.js?v=20261027a" defer></script>{% endblock %}
+1 -1
View File
@@ -744,7 +744,7 @@ async def gmail_connect(request: Request) -> Any:
except gmail.GmailError as exc:
return RedirectResponse(url="/vacation/options?" + urlencode({"msg": str(exc)}), status_code=303)
request.session["_gmail_origin"] = "vacation"
request.session["_vacation_gmail_next"] = "/vacation/options"
request.session["_gmail_next"] = "/vacation/options"
return await client.authorize_redirect(
request, public_url_for(request, "inout_gmail_callback"),
access_type="offline", prompt="consent", include_granted_scopes="true",
+78
View File
@@ -0,0 +1,78 @@
/* 안내문 발송(2026-10-27) — 리스트·보내기·설정 */
.erp-page:has(> .otr) { box-sizing: border-box; } /* 셸 .erp-page width:100% + 여백 → 오른쪽 넘침 방지(실적·휴가와 같음) */
.otr { display: flex; flex-direction: column; gap: 14px; }
.otr > * { flex-shrink: 0; }
.otr-top { display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
.otr-top-main { display: flex; gap: 8px; }
.otr-gmail { display: flex; align-items: center; gap: 8px; font-size: 13px; flex-wrap: wrap; }
.otr-gmail form { margin: 0; }
.otr-gmail-on { color: #0f8a3a; }
.otr-gmail-off { color: #8a5a00; }
.otr-msg { margin: 0; padding: 8px 12px; border-radius: 8px; background: #eef6ff; color: #1a4fa0; font-size: 13px; }
.otr .erp-card { padding: 14px 16px; }
.otr-tpl-head { display: flex; align-items: baseline; gap: 8px; margin-bottom: 8px; font-size: 14px; flex-wrap: wrap; }
.otr-tpl-head .erp-muted { font-size: 12px; }
.otr-tpl-subject { font-weight: 700; font-size: 15px; }
.otr-tpl-body { margin-top: 4px; color: #444; font-size: 13px; white-space: pre-wrap; }
.otr-tpl-meta { margin-top: 6px; font-size: 12px; }
.otr-add-head { display: flex; flex-direction: column; gap: 4px; margin-bottom: 8px; font-size: 13px; }
.otr-add-text { width: 100%; min-width: 0; box-sizing: border-box; font-family: ui-monospace, Consolas, monospace; font-size: 13px; resize: vertical; }
.otr-add-actions { display: flex; align-items: center; gap: 8px; margin-top: 8px; flex-wrap: wrap; }
.otr-add-preview { margin-top: 10px; max-height: 320px; overflow: auto; }
.otr-filter { display: flex; gap: 4px; margin-bottom: 10px; flex-wrap: wrap; }
.otr-seg { border: 1px solid #d8dce2; background: #fff; border-radius: 999px; padding: 4px 12px; font: inherit; font-size: 13px; cursor: pointer; }
.otr-seg.is-active { background: #111; border-color: #111; color: #fff; }
.otr-cnt { opacity: .7; font-size: 12px; margin-left: 2px; }
.otr-table td { vertical-align: middle; }
.otr-c-check { width: 32px; text-align: center; }
.otr-c-acts { white-space: nowrap; text-align: right; }
.otr-c-acts .erp-btn + .erp-btn { margin-left: 4px; }
.otr-kind { display: inline-block; min-width: 38px; text-align: center; padding: 2px 8px; border-radius: 999px; font-size: 12px; font-weight: 700; }
.otr-kind.is-email { background: #e8effb; color: #1a56db; }
.otr-kind.is-instagram { background: #fbe8f3; color: #c1358a; }
.otr-kind.is-bad { background: #fdecec; color: #c22b10; }
.otr-name { width: 100%; min-width: 120px; box-sizing: border-box; border: 1px solid transparent; border-radius: 6px; padding: 4px 6px; font: inherit; background: transparent; }
.otr-name:hover, .otr-name:focus { border-color: #d8dce2; background: #fff; outline: none; }
.otr-row.is-noname .otr-name { border-color: #f0b4a8; background: #fff7f5; }
.otr-addr { font-size: 13px; word-break: break-all; }
.otr-addr a { color: #c1358a; text-decoration: none; }
.otr-st { display: inline-block; padding: 2px 8px; border-radius: 6px; font-size: 12px; font-weight: 600; }
.otr-st.is-wait { background: #f1f2f4; color: #555; }
.otr-st.is-busy { background: #fff4d6; color: #8a5a00; }
.otr-st.is-done { background: #e6f4ea; color: #0f8a3a; }
.otr-st.is-fail { background: #fdecec; color: #c22b10; }
.otr-st-err { margin-top: 2px; font-size: 11.5px; color: #c22b10; max-width: 280px; }
.otr-when { white-space: nowrap; font-size: 12.5px; color: #666; font-variant-numeric: tabular-nums; }
.otr-empty { margin: 12px 0 0; }
.otr-send-bar { display: flex; align-items: center; gap: 8px; margin-top: 12px; flex-wrap: wrap; font-size: 13px; }
.otr-send-note { flex-basis: 100%; font-size: 12px; }
.otr-danger { color: #c22b10; }
.otr-err { color: #c22b10; }
.otr-warn { color: #8a5a00; }
.otr-logs ul { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; font-size: 13px; max-height: 260px; overflow: auto; }
.otr-logs li.is-fail b { color: #c22b10; }
.otr-modal { position: fixed; inset: 0; z-index: 2000; background: rgba(15, 23, 42, .4); display: flex; align-items: center; justify-content: center; }
.otr-modal[hidden] { display: none; }
.otr-modal-card { width: min(760px, 94vw); height: min(86vh, 900px); background: #fff; border-radius: 12px; padding: 14px; display: flex; flex-direction: column; gap: 8px; box-sizing: border-box; }
.otr-modal-head { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
.otr-pv-subject { font-weight: 700; font-size: 14px; }
.otr-pv-frame { flex: 1; width: 100%; border: 1px solid #e3e5e8; border-radius: 8px; background: #fff; }
.otr-toast { position: fixed; left: 50%; bottom: 28px; transform: translateX(-50%); z-index: 2100; max-width: min(640px, 92vw);
padding: 10px 16px; border-radius: 10px; background: #111; color: #fff; font-size: 13.5px; box-shadow: 0 8px 24px rgba(0, 0, 0, .2); }
.otr-toast.is-bad { background: #c22b10; }
.otr-toast[hidden] { display: none; }
/* 설정 */
.otr-set-card { display: flex; flex-direction: column; gap: 10px; }
.otr-field { display: flex; flex-direction: column; gap: 4px; }
.otr-field .erp-input { width: 100%; min-width: 0; box-sizing: border-box; }
.otr-body { font-size: 14px; line-height: 1.6; resize: vertical; }
.otr-check { display: flex; align-items: baseline; gap: 6px; font-size: 13px; }
.otr-set-actions { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.otr-images { display: flex; gap: 12px; flex-wrap: wrap; }
.otr-image { margin: 0; width: 200px; border: 1px solid #e3e5e8; border-radius: 8px; padding: 8px; display: flex; flex-direction: column; gap: 6px; }
.otr-image img { width: 100%; height: 150px; object-fit: cover; border-radius: 6px; background: #f6f7f9; }
.otr-image figcaption { font-size: 12px; color: #555; word-break: break-all; }
.otr-image-acts { display: flex; gap: 4px; }
.otr-image-acts form { margin: 0; }
.otr-upload { display: flex; gap: 8px; align-items: center; margin-top: 8px; flex-wrap: wrap; }
.otr .erp-btn:disabled { opacity: .45; cursor: default; }
+256
View File
@@ -0,0 +1,256 @@
/* 안내문 발송(2026-10-27) — 리스트 화면: 붙여 넣기 → 미리보기(메일/DM/오류) → 추가, 걸러 보기, 이름 고치기,
메일 = 고른 줄 [고른 메일 보내기](서버가 본인 Gmail 로 한 통씩, 보내는 동안 2초마다 다시 읽음),
DM = [DM 보내기](그 사람 이름이 들어간 문구를 클립보드에 + ig.me DM 창을 새 탭) → [보냄]. 설정 화면 = [기본 문구로 되돌리기]. */
(function () {
"use strict";
function esc(s) {
return String(s == null ? "" : s).replace(/[&<>"']/g, function (c) {
return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c];
});
}
async function api(method, url, body) {
const res = await fetch(url, { method: method, headers: body ? { "Content-Type": "application/json" } : {},
body: body ? JSON.stringify(body) : undefined, credentials: "same-origin" });
let data = {};
try { data = await res.json(); } catch (_) { data = {}; }
if (!res.ok) { const e = new Error(data.message || data.detail || ("HTTP " + res.status)); e.status = res.status; e.data = data; throw e; }
return data;
}
function toast(msg, bad) {
let el = document.getElementById("otr-toast");
if (!el) { el = document.createElement("div"); el.id = "otr-toast"; el.className = "otr-toast"; document.body.appendChild(el); }
el.textContent = msg;
el.classList.toggle("is-bad", !!bad);
el.hidden = false;
clearTimeout(el._t);
el._t = setTimeout(function () { el.hidden = true; }, 4000);
}
async function copyText(text) {
try { await navigator.clipboard.writeText(text); return true; } catch (_) { /* 아래로 */ }
const ta = document.createElement("textarea");
ta.value = text; ta.style.position = "fixed"; ta.style.top = "-1000px";
document.body.appendChild(ta); ta.select();
let ok = false;
try { ok = document.execCommand("copy"); } catch (_) { ok = false; }
ta.remove();
return ok;
}
// ── 설정 화면 ──
const defBtn = document.getElementById("otr-default");
if (defBtn) {
defBtn.addEventListener("click", function () {
let d = {};
try { d = JSON.parse(document.getElementById("otr-default-data").textContent); } catch (_) { d = {}; }
if (!confirm("제목·본문·보내는 이름·끝 문구를 기본 문구로 바꿀까요? ([저장]을 눌러야 적용)")) return;
const f = document.getElementById("otr-set-form");
f.subject.value = d.subject || "";
f.body.value = d.body || "";
f.sender_name.value = d.sender_name || "";
f.footer.value = d.footer || "";
f.ad_label.checked = !!d.ad_label;
});
}
// ── 리스트 화면 ──
const root = document.getElementById("otr");
const tbody = document.getElementById("otr-tbody");
if (!root || !tbody) return;
let rows = [];
try { rows = JSON.parse(document.getElementById("otr-data").textContent).rows || []; } catch (_) { rows = []; }
let filter = "all";
const picked = new Set();
let pollTimer = null;
function visible(r) {
if (filter === "all") return true;
if (filter === "email" || filter === "instagram") return r.kind === filter;
return r.status === filter;
}
function when(iso) { return iso ? iso.slice(5, 16).replace("T", " ") : ""; }
function render() {
const counts = { all: rows.length, email: 0, instagram: 0, "대기": 0, "보냄": 0, "실패": 0 };
rows.forEach(function (r) { counts[r.kind]++; if (counts[r.status] != null) counts[r.status]++; });
document.querySelectorAll("[data-cnt]").forEach(function (n) { n.textContent = counts[n.dataset.cnt] || 0; });
const shown = rows.filter(visible);
tbody.innerHTML = shown.map(function (r) {
const status = r.status === "실패" ? '<span class="otr-st is-fail" title="' + esc(r.last_error) + '">실패</span>' +
(r.last_error ? '<div class="otr-st-err">' + esc(r.last_error) + "</div>" : "")
: '<span class="otr-st is-' + ({ "대기": "wait", "발송중": "busy", "보냄": "done" }[r.status] || "wait") + '">' + esc(r.status) + "</span>";
const acts = r.kind === "instagram"
? '<button type="button" class="erp-btn erp-btn-primary erp-btn-sm" data-act="dm">DM 보내기</button>' +
(r.status !== "보냄" ? '<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-act="dm-sent">보냄</button>' : "")
: '<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-act="preview">미리보기</button>';
const addr = r.kind === "instagram"
? '<a href="' + esc(r.profile_link) + '" target="_blank" rel="noopener">@' + esc(r.handle) + "</a>"
: esc(r.handle);
return '<tr data-id="' + r.id + '" class="otr-row is-' + r.kind + (r.needs_name ? " is-noname" : "") + '">' +
'<td class="otr-c-check"><input type="checkbox" data-pick' + (picked.has(r.id) ? " checked" : "") + ' aria-label="고르기" /></td>' +
'<td><span class="otr-kind is-' + r.kind + '">' + esc(r.kind_label) + "</span></td>" +
'<td><input class="otr-name" type="text" maxlength="100" value="' + esc(r.name) + '" placeholder="' +
(r.needs_name ? "이름 필요({이름})" : "이름") + '" aria-label="이름" /></td>' +
'<td class="otr-addr">' + addr + "</td>" +
"<td>" + status + "</td>" +
'<td class="otr-when">' + esc(when(r.sent_at)) + (r.sent_via ? ' <small class="erp-muted">' + (r.sent_via === "dm" ? "DM" : "Gmail") + "</small>" : "") + "</td>" +
'<td class="otr-c-acts">' + acts + "</td></tr>";
}).join("");
document.getElementById("otr-empty").hidden = rows.length > 0;
const sel = rows.filter(function (r) { return picked.has(r.id); });
const mails = sel.filter(function (r) { return r.kind === "email" && (r.status === "대기" || r.status === "실패"); }).length;
document.getElementById("otr-selected").textContent = "고른 줄 " + sel.length + " · 보낼 메일 " + mails;
const all = document.getElementById("otr-check-all");
all.checked = shown.length > 0 && shown.every(function (r) { return picked.has(r.id); });
if (rows.some(function (r) { return r.status === "발송중"; })) startPoll(); else stopPoll();
}
async function reload() {
const d = await api("GET", "/outreach/api/recipients");
rows = d.rows || [];
const ids = new Set(rows.map(function (r) { return r.id; }));
Array.from(picked).forEach(function (id) { if (!ids.has(id)) picked.delete(id); });
render();
}
function startPoll() { if (!pollTimer) pollTimer = setInterval(function () { reload().catch(function () {}); }, 2000); }
function stopPoll() { if (pollTimer) { clearInterval(pollTimer); pollTimer = null; } }
function rowOf(node) { const tr = node.closest("tr[data-id]"); return tr ? rows.find(function (r) { return r.id === +tr.dataset.id; }) : null; }
document.querySelectorAll("[data-filter]").forEach(function (b) {
b.addEventListener("click", function () {
filter = b.dataset.filter;
document.querySelectorAll("[data-filter]").forEach(function (x) { x.classList.toggle("is-active", x === b); });
render();
});
});
document.getElementById("otr-check-all").addEventListener("change", function (e) {
rows.filter(visible).forEach(function (r) { if (e.target.checked) picked.add(r.id); else picked.delete(r.id); });
render();
});
tbody.addEventListener("change", function (e) {
if (e.target.matches("[data-pick]")) {
const r = rowOf(e.target);
if (e.target.checked) picked.add(r.id); else picked.delete(r.id);
render();
}
});
// 이름 — 칸을 떠나면(또는 Enter) 저장
tbody.addEventListener("focusout", async function (e) {
if (!e.target.matches(".otr-name")) return;
const r = rowOf(e.target);
const v = e.target.value.trim();
if (!r || v === (r.name || "")) return;
try {
const d = await api("PUT", "/outreach/api/recipients/" + r.id, { name: v });
Object.assign(r, d.row);
render();
} catch (err) { toast("이름 저장 실패: " + err.message, true); e.target.value = r.name || ""; }
});
tbody.addEventListener("keydown", function (e) {
if (e.target.matches(".otr-name") && e.key === "Enter" && !e.isComposing) { e.preventDefault(); e.target.blur(); }
});
tbody.addEventListener("click", async function (e) {
const btn = e.target.closest("[data-act]");
if (!btn) return;
const r = rowOf(btn);
if (!r) return;
if (btn.dataset.act === "dm") {
if (r.needs_name) { toast("이름을 먼저 넣으세요 — 본문에 {이름}이 있습니다.", true); return; }
// 누르는 순간 바로(브라우저가 막지 않게) — 문구 복사 + DM 창 새 탭. 문구는 화면 데이터에 미리 있다.
const win = window.open(r.dm_link, "_blank", "noopener");
const ok = await copyText(r.dm_text || "");
toast(ok ? "@" + r.handle + " DM 문구를 복사했습니다 — 열린 인스타 DM 창에 붙여 넣어(Ctrl+V) 보낸 뒤 [보냄]을 누르세요."
: "문구를 복사하지 못했습니다 — [미리보기]가 아니라 DM 창에 직접 적어 주세요.", !ok);
if (!win) toast("인스타 창이 막혔습니다 — 브라우저 팝업 허용 뒤 다시 누르세요(문구는 복사됨).", true);
} else if (btn.dataset.act === "dm-sent") {
btn.disabled = true;
try { const d = await api("POST", "/outreach/api/recipients/" + r.id + "/dm-sent"); Object.assign(r, d.row); render(); }
catch (err) { btn.disabled = false; toast("기록 실패: " + err.message, true); }
} else if (btn.dataset.act === "preview") {
try { showPreview(await api("GET", "/outreach/api/recipients/" + r.id + "/preview"), r); }
catch (err) { toast("미리보기 실패: " + err.message, true); }
}
});
// 미리보기 창
const pv = document.getElementById("otr-preview");
function showPreview(d, r) {
document.getElementById("otr-pv-title").textContent = (d.kind === "email" ? "메일 미리보기 → " : "DM 미리보기 → ") + d.to;
document.getElementById("otr-pv-subject").textContent = d.kind === "email" ? "제목: " + d.subject + " · 보내는 이름: " + (d.sender_name || "") : "";
document.getElementById("otr-pv-frame").srcdoc = d.kind === "email" ? d.html
: '<pre style="font-family:sans-serif;white-space:pre-wrap;font-size:14px;line-height:1.6">' + esc(d.text) + "</pre>";
pv.hidden = false;
}
pv.addEventListener("click", function (e) { if (e.target === pv || e.target.closest("[data-close]")) pv.hidden = true; });
document.addEventListener("keydown", function (e) { if (e.key === "Escape" && !pv.hidden) pv.hidden = true; });
// 보내기 · 다시 대기 · 지우기
const sendBtn = document.getElementById("otr-send");
sendBtn.addEventListener("click", async function () {
const sel = rows.filter(function (r) { return picked.has(r.id) && r.kind === "email" && (r.status === "대기" || r.status === "실패"); });
if (!sel.length) { toast("보낼 메일 줄(대기·실패)을 고르세요.", true); return; }
const noName = sel.filter(function (r) { return r.needs_name; }).length;
if (!confirm(sel.length + "명에게 메일을 보낼까요?" + (noName ? "\n(이름 없는 " + noName + "명은 보내지 않고 '실패'로 남습니다)" : ""))) return;
sendBtn.disabled = true;
try {
const d = await api("POST", "/outreach/api/send", { ids: sel.map(function (r) { return r.id; }) });
toast(d.queued + "통을 보내는 중입니다 — 상태가 '보냄'으로 바뀝니다.");
await reload();
} catch (err) {
toast(err.data && err.data.reconnect ? err.message : "보내기 실패: " + err.message, true);
} finally { sendBtn.disabled = false; }
});
document.getElementById("otr-reset").addEventListener("click", async function () {
const sel = rows.filter(function (r) { return picked.has(r.id) && (r.status === "보냄" || r.status === "실패"); });
if (!sel.length) { toast("보냄·실패 줄을 고르세요.", true); return; }
if (!confirm(sel.length + "줄을 다시 '대기'로 둘까요? (다시 보낼 수 있게)")) return;
for (const r of sel) {
try { const d = await api("PUT", "/outreach/api/recipients/" + r.id, { status: "대기" }); Object.assign(r, d.row); }
catch (err) { toast("실패: " + err.message, true); break; }
}
render();
});
document.getElementById("otr-delete").addEventListener("click", async function () {
const ids = Array.from(picked);
if (!ids.length) { toast("지울 줄을 고르세요.", true); return; }
if (!confirm(ids.length + "줄을 리스트에서 지울까요? (보낸 기록은 남습니다)")) return;
try { await api("POST", "/outreach/api/recipients/delete", { ids: ids }); ids.forEach(function (i) { picked.delete(i); }); await reload(); }
catch (err) { toast("지우기 실패: " + err.message, true); }
});
// 리스트 추가 — 미리보기(판별) → 추가
const addBox = document.getElementById("otr-add"), addText = document.getElementById("otr-add-text");
const addSave = document.getElementById("otr-add-save"), addResult = document.getElementById("otr-add-result");
document.getElementById("otr-add-open").addEventListener("click", function () { addBox.hidden = false; addText.focus(); });
document.getElementById("otr-add-close").addEventListener("click", function () { addBox.hidden = true; });
addText.addEventListener("input", function () { addSave.disabled = true; });
document.getElementById("otr-add-preview").addEventListener("click", async function () {
try {
const d = await api("POST", "/outreach/api/recipients/parse", { text: addText.value });
const ok = d.rows.filter(function (r) { return r.kind && !r.dup && !r.exists; });
addResult.hidden = false;
addResult.innerHTML = '<table class="erp-table otr-table"><thead><tr><th>줄</th><th>구분</th><th>이름</th><th>주소</th><th></th></tr></thead><tbody>' +
d.rows.map(function (r) {
const note = !r.kind ? '<span class="otr-err">' + esc(r.error) + "</span>" : r.dup ? "같은 주소가 위에 있음(건너뜀)"
: r.exists ? "이미 리스트에 있음(이름이 비었으면 채움)" : r.name ? "" : '<span class="otr-warn">이름 없음</span>';
return '<tr class="' + (r.kind ? "" : "is-bad") + '"><td>' + r.line + '</td><td><span class="otr-kind is-' + (r.kind || "bad") + '">' +
esc(r.kind_label) + "</span></td><td>" + esc(r.name) + "</td><td>" + esc(r.kind === "instagram" ? "@" + r.handle : r.handle || r.address) +
"</td><td>" + note + "</td></tr>";
}).join("") + "</tbody></table>";
const bad = d.rows.filter(function (r) { return !r.kind; }).length;
document.getElementById("otr-add-sum").textContent = "새로 " + ok.length + "명 (메일 " + ok.filter(function (r) { return r.kind === "email"; }).length +
" · DM " + ok.filter(function (r) { return r.kind === "instagram"; }).length + ")" + (bad ? " · 오류 " + bad + "줄(추가 안 됨)" : "");
addSave.disabled = !d.rows.some(function (r) { return r.kind && !r.dup; });
} catch (err) { toast("미리보기 실패: " + err.message, true); }
});
addSave.addEventListener("click", async function () {
addSave.disabled = true;
try {
const d = await api("POST", "/outreach/api/recipients", { text: addText.value });
toast("추가 " + d.added + "명" + (d.existed ? " · 이미 있던 " + d.existed + "명" : "") + (d.invalid ? " · 오류 " + d.invalid + "줄" : ""));
addText.value = ""; addResult.hidden = true; document.getElementById("otr-add-sum").textContent = "";
addBox.hidden = true;
await reload();
} catch (err) { addSave.disabled = false; toast("추가 실패: " + err.message, true); }
});
render();
})();
+1
View File
@@ -35,6 +35,7 @@ MODULE_KEYS: tuple[str, ...] = (
"performance",
"asset",
"inout",
"outreach",
"expense_approver",
"vacation_approver",
)
+12
View File
@@ -290,6 +290,18 @@ cd /opt/www/main && docker compose up -d --build
---
## outreach_db 스키마 / 초기화 (안내문 발송, 2026-10-27)
DDL: `scripts/sql/outreach_db_init.sql` (멱등). DB·역할(`outreach_app`)·테이블·인덱스·트리거. **JSON 폴백 없음** — `OUTREACH_DB_URL` 미설정 시 "설정 필요" 안내.
생성·연결 명령은 `docs/DEPLOYMENT.md` "안내문 발송 DB 생성".
| 테이블 | 용도 |
| --- | --- |
| `outreach_settings` | 키 `template` = 메일 제목·본문({이름})·보내는 이름·끝 문구·(광고) 표시(JSONB) |
| `outreach_images` | 메일 본문 아래 사진(가로 700px JPEG 로 줄여 BYTEA, 순서) — 최대 10장 |
| `outreach_recipients` | 리스트 — `kind` email·instagram(주소를 보고 판별), `handle`(이메일 소문자·인스타 계정명), 이름·메모, 상태 대기→발송중→보냄/실패, `UNIQUE(kind, handle)` |
| `outreach_logs` | 보낸 기록(메일·DM, 성공·오류) — 줄을 지워도 남음, 본문·토큰은 안 남김 |
## malaysia_stock_db 스키마 / 초기화
DDL: `scripts/sql/malaysia_stock_db_init.sql` (멱등). DB·역할(`malaysia_app`)·테이블·인덱스·트리거·창고/아이템 seed 를 한 번에 생성. **JSON 폴백 없음** — `MALAYSIA_STOCK_DB_URL` 미설정 시 모듈이 "설정 필요" 안내만 표시. 상품명은 `itemcode_db` 읽기 전용 재사용.
+20
View File
@@ -342,6 +342,25 @@ curl -s http://127.0.0.1:8080/inout/health # {"status":"ok"} — DSN
```
그다음 ERP 관리자 화면에서 쓸 사람에게 **입출고 관리** 권한 → 입출고 관리 → 옵션에서 공장·발주 담당·입고 담당 지정.
## 안내문 발송 DB 생성 (outreach_db, 2026-10-27)
입출고 DB 와 같은 방법(새 DB — 기존 DB·데이터는 건드리지 않음, 초기화 SQL 멱등, 비밀번호는 URL 인코딩).
```bash
cd /opt/www/main && git pull
docker exec postgres-db psql -U postgres -lqt | cut -d| -f1 | grep -w outreach_db || echo "outreach_db 없음 — 새로 만든다"
read -s -p "outreach_app password: " APP_PWD; echo
docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/outreach_db_init.sql
ENC=$(APP_PWD="$APP_PWD" python3 -c "import os,urllib.parse;print(urllib.parse.quote(os.environ['APP_PWD'],safe=''))")
grep -q "^OUTREACH_DB_URL=" .env && sed -i "s|^OUTREACH_DB_URL=.*|OUTREACH_DB_URL=postgresql://outreach_app:${ENC}@postgres-db:5432/outreach_db|" .env \
|| printf '\nOUTREACH_DB_URL=postgresql://outreach_app:%s@postgres-db:5432/outreach_db\n' "$ENC" >> .env
docker compose up --build -d --force-recreate web
docker exec dbx-main python -c "import os,psycopg; psycopg.connect(os.environ['OUTREACH_DB_URL']).execute('select 1 from outreach_recipients limit 1'); print('DB OK')"
```
그다음 ERP 관리자 화면에서 쓸 사람에게 **안내문 발송** 권한 → 안내문 발송 → [Gmail 연결](입출고·휴가와 같은 연결) → 설정에서 제목·본문·사진 확인.
백업: 매일 `docker exec postgres-db pg_dump -U postgres outreach_db > /var/backups/postgres/outreach_db_$(date +%F).sql`.
백업: 매일 `docker exec postgres-db pg_dump -U postgres inout_db > /var/backups/postgres/inout_db_$(date +%F).sql`.
## 연간 목표 주차별 매출 목표 두 칸 마이그레이션 (project_db 030)
@@ -545,6 +564,7 @@ docker compose down # 컨테이너 제거 (볼륨 유지)
| `APP_ENCRYPTION_KEY` | 쇼핑몰 API 인증정보 암호화 마스터 키(32바이트, `openssl rand -hex 32`). DB 에 저장하지 않음. **분실 시 저장된 인증정보 복구 불가 — 별도 안전 보관**. 쇼핑몰별 ID/Key/Secret 은 `.env` 에 넣지 않고 실적 → 설정 화면에서 입력 |
| `APP_ENCRYPTION_KEY_VERSION` | 현재 마스터 키 버전(기본 1). 교체 시 올리고 예전 키는 `APP_ENCRYPTION_KEY_V{n}` 로 남긴 뒤 설정 화면에서 재암호화(`docs/PERFORMANCE_MODULE.md`) |
| `PERFORMANCE_SYNC_DAYS` | [매출 업데이트] 수집 기간(오늘 포함 최근 N일, 기본 7, 최대 90) |
| `OUTREACH_DB_URL` | 안내문 발송 DB DSN (예: `postgresql://outreach_app:<pwd>@postgres-db:5432/outreach_db`, 비밀번호는 URL 인코딩). 미설정 시 모듈 비활성(설정 필요 안내). 권한키 `outreach`. 메일은 `INOUT_DB_URL` 의 Gmail 연결 재사용 |
| `INOUT_DB_URL` | 입출고 관리 DB DSN (예: `postgresql://inout_app:<pwd>@postgres-db:5432/inout_db`). 미설정 시 입출고 모듈 비활성(설정 필요 안내). 권한키 `inout`. 제품은 `ITEMCODE_DB_URL`(단품) 재사용 |
---
+3
View File
@@ -23,6 +23,7 @@
| 말레이시아 재고 | 말레이시아 창고 재고관리 (`app/modules/malaysia/`) — 낱개 입출고/조정, 세트 BOM, 일일 재고조사(세트 분해 자동 반영), 현재고 현황. 상품명은 `itemcode_db` 읽기 전용 참조 |
| 입출고 관리 | 본사 → 공장 제품 제작 발주, 물류 입고(여러 번 나눠), 발주 대비 미입고·초과 입고 관리 (`app/modules/inout/`, `inout_db`) — 발주 담당·입고 담당·공장은 모듈 옵션에서 지정, 제품은 `itemcode_db` 단품 읽기 전용. `docs/INOUT_MODULE.md` |
| 긴급 공지 | 수퍼관리자가 정한 시각에 전체/고른 사람의 ERP 화면 정가운데에 띄우는 공지(`app/modules/notice/`, project_db 024) — [확인] 전까지 다시 뜸, 확인 현황. `docs/NOTICE_MODULE.md` |
| 안내문 발송 | 리스트(이메일·인스타 주소 + 이름)에 `{이름}`을 넣은 안내문 — 메일 일괄 발송(보내는 사람 본인 Gmail)·인스타 DM 반자동(문구 복사 + DM 창) (`app/modules/outreach/`, `outreach_db`) |
| 실적 | 쇼핑몰 통합 매출 (`app/modules/performance/`) — 쇼핑몰별 어댑터로 수집 → `performance_db` 저장 → 일자×쇼핑몰 표·KPI·월/연 누적·그래프. 수수료율 이력, API 인증정보는 설정 화면 입력 + AES-256-GCM 암호화 저장. 1단계는 모의 데이터·구조까지(실제 API 는 쇼핑몰별로 순차 연동). `docs/PERFORMANCE_MODULE.md` |
### 권한 키 (`MODULE_KEYS`)
@@ -37,6 +38,7 @@
| `expense` / `vacation` / `cupang` / `malaysia` / `performance` | 접근 | 내부 모듈 진입 (`performance` 설정 화면·API 는 추가로 `admin` 필요) |
| `expense_approver` | 결재 | 개인경비 승인/반려/정산 |
| `asset` | 접근 | 자산관리 조회·등록·수정·배정·반납·보고서 |
| `outreach` | 접근 | 안내문 발송 — 리스트·메일 발송·DM·설정 |
| `inout` | 접근 | 입출고 관리 조회. 발주·입고 입력은 모듈 옵션의 발주 담당·입고 담당(ERP 관리자는 둘 다 + 옵션) |
| `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) |
@@ -111,6 +113,7 @@ app/modules/<name>/
| `cupang_db` | 쿠팡 밀크런 출고/입고센터/박스규칙 (`CUPANG_DB_URL` 필수, JSON 폴백 없음) |
| `vacation_db` | 휴가 신청/공휴일/연차잔여 (`VACATION_DB_URL` 필수, JSON 폴백 없음) |
| `malaysia_stock_db` | 말레이시아 창고 재고/세트BOM/재고조사 (`MALAYSIA_STOCK_DB_URL` 필수, JSON 폴백 없음) |
| `outreach_db` | 안내문 발송 — 리스트·보낸 기록·제목/본문 설정·사진 (`OUTREACH_DB_URL` 필수, JSON 폴백 없음) |
| `performance_db` | 실적 — 쇼핑몰 설정/수수료 이력/인증정보(암호문)/매출 사건 (`PERFORMANCE_DB_URL` 필수, JSON 폴백 없음) |
> 신규 DB 생성은 서버 실행 명령을 제공하고 사용자가 직접 진행한다 (사용자 지시: 2026-10-06). 대상·상태·백업 확인 명령을 제공하고 이름은 `_db`로 끝낸다. 기존 DB 삭제·덮어쓰기는 별도 승인 대상이다. 상세는 `DATABASES.md`.
+122
View File
@@ -0,0 +1,122 @@
-- =====================================================================
-- outreach_db 초기화 스크립트 (PostgreSQL) — 안내문 발송 모듈(2026-10-27)
-- =====================================================================
-- 리스트(이메일 주소·인스타그램 주소 + 이름)에 안내문을 보낸다 — 이메일은 보내는 사람 본인 Gmail 로 한 통씩,
-- 인스타는 DM 문구 복사 + DM 창 열기(반자동 — 인스타 공식 API 는 처음 연락하는 사람에게 DM 을 보낼 수 없다).
-- 멱등(idempotent): 여러 번 실행해도 안전. 기존 데이터를 삭제하지 않는다. DROP/TRUNCATE 없음.
--
-- 실행 방법 (운영 PostgreSQL 컨테이너명: postgres-db, 백업 먼저):
--
-- 1) DB / 역할 / 테이블 생성 (superuser 로 1회)
-- read -s -p "outreach_app password: " APP_PWD; echo
-- docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/outreach_db_init.sql
--
-- 2) main-app .env 에 연결 정보 등록
-- OUTREACH_DB_URL=postgresql://outreach_app:<APP_PWD>@postgres-db:5432/outreach_db
--
-- 3) main-app 재기동
-- cd /opt/www/main && docker compose up -d --build web
-- =====================================================================
\set ON_ERROR_STOP on
SELECT 'CREATE DATABASE outreach_db ENCODING ''UTF8'' TEMPLATE template0'
WHERE NOT EXISTS (SELECT 1 FROM pg_database WHERE datname = 'outreach_db')
\gexec
SELECT 'CREATE ROLE outreach_app LOGIN PASSWORD ' || quote_literal(:'app_password')
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'outreach_app')
\gexec
SELECT 'ALTER ROLE outreach_app WITH LOGIN PASSWORD ' || quote_literal(:'app_password')
\gexec
GRANT CONNECT ON DATABASE outreach_db TO outreach_app;
\connect outreach_db
CREATE OR REPLACE FUNCTION outreach_set_updated_at() RETURNS trigger AS $$
BEGIN
NEW.updated_at := now();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- ════════════════════════════════════════════════════════════
-- 1) 설정 — 키 하나 = 값(JSONB). 'template' = {subject, body, sender_name, footer, ad_label}
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS outreach_settings (
key TEXT PRIMARY KEY,
value JSONB NOT NULL DEFAULT '{}'::jsonb,
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- ════════════════════════════════════════════════════════════
-- 2) 메일 본문 아래 사진 — 설정에서 올림(서버가 가로 600px JPEG 로 줄여 저장), 순서대로
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS outreach_images (
id SERIAL PRIMARY KEY,
filename TEXT NOT NULL DEFAULT '',
data BYTEA NOT NULL,
width INTEGER NOT NULL DEFAULT 0,
height INTEGER NOT NULL DEFAULT 0,
sort_order INTEGER NOT NULL DEFAULT 0,
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
-- ════════════════════════════════════════════════════════════
-- 3) 리스트 — 주소 하나 = 한 줄. kind 는 주소를 보고 정함(email | instagram), handle = 정리한 주소(이메일 소문자 / 인스타 계정명)
-- status: 대기 → 발송중 → 보냄 | 실패 (다시 보내려면 대기로)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS outreach_recipients (
id BIGSERIAL PRIMARY KEY,
kind TEXT NOT NULL CHECK (kind IN ('email', 'instagram')),
handle TEXT NOT NULL CHECK (char_length(handle) BETWEEN 1 AND 320),
address TEXT NOT NULL DEFAULT '', -- 입력한 그대로(보여 주기)
name TEXT NOT NULL DEFAULT '' CHECK (char_length(name) <= 100),
memo TEXT NOT NULL DEFAULT '' CHECK (char_length(memo) <= 500),
status TEXT NOT NULL DEFAULT '대기' CHECK (status IN ('대기', '발송중', '보냄', '실패')),
sent_at TIMESTAMPTZ,
sent_by TEXT NOT NULL DEFAULT '',
sent_via TEXT NOT NULL DEFAULT '' CHECK (sent_via IN ('', 'gmail', 'dm')),
last_error TEXT NOT NULL DEFAULT '',
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
UNIQUE (kind, handle)
);
CREATE INDEX IF NOT EXISTS idx_outreach_recipients_status ON outreach_recipients (status, id);
DROP TRIGGER IF EXISTS trg_outreach_recipients_updated_at ON outreach_recipients;
CREATE TRIGGER trg_outreach_recipients_updated_at BEFORE UPDATE ON outreach_recipients
FOR EACH ROW EXECUTE FUNCTION outreach_set_updated_at();
-- ════════════════════════════════════════════════════════════
-- 4) 보낸 기록 — 한 번 보낼 때마다 한 줄(받는 사람을 지워도 남음). 본문·토큰은 남기지 않는다.
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS outreach_logs (
id BIGSERIAL PRIMARY KEY,
recipient_id BIGINT,
kind TEXT NOT NULL DEFAULT '',
address TEXT NOT NULL DEFAULT '',
name TEXT NOT NULL DEFAULT '',
subject TEXT NOT NULL DEFAULT '',
via TEXT NOT NULL DEFAULT '',
sent_by TEXT NOT NULL DEFAULT '',
ok BOOLEAN NOT NULL DEFAULT FALSE,
error TEXT NOT NULL DEFAULT '',
sent_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_outreach_logs_recipient ON outreach_logs (recipient_id, sent_at);
-- ════════════════════════════════════════════════════════════
-- 5) 권한 (outreach_app: CRUD only)
-- ════════════════════════════════════════════════════════════
GRANT USAGE ON SCHEMA public TO outreach_app;
GRANT SELECT, INSERT, UPDATE, DELETE ON outreach_settings, outreach_images, outreach_recipients, outreach_logs TO outreach_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO outreach_app;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO outreach_app;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT USAGE, SELECT ON SEQUENCES TO outreach_app;
SELECT 'outreach_db ready' AS status;
+145
View File
@@ -0,0 +1,145 @@
// 안내문 발송 리스트 화면(2026-10-27) — 실제 브라우저(Chromium).
// python tests/js/render_outreach.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/outreach.browser.test.js
// 구분 배지(메일/DM)·걸러 보기, [DM 보내기] = 그 사람 이름이 든 문구 복사 + ig.me DM 창 새 탭, [보냄] 기록, 이름 없는 줄 표시,
// 붙여넣기 미리보기(메일/DM/오류) → 추가, 고른 메일 보내기(메일 줄만, 확인 창), 미리보기 창. 서버 API 는 테스트 안 가짜.
const fs = require("fs"), path = require("path");
const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", "..");
const fails = [];
function check(name, cond, extra) {
if (cond) console.log("PASS " + name);
else { console.log("FAIL " + name + (extra !== undefined ? " → " + JSON.stringify(extra) : "")); fails.push(name); }
}
(async function () {
const exe = process.env.PJ_TEST_BROWSER;
const browser = await chromium.launch(exe ? { executablePath: exe } : {});
const calls = [];
try {
const ctx = await browser.newContext({ viewport: { width: 1400, height: 900 }, permissions: ["clipboard-read", "clipboard-write"] });
await ctx.route("**/*", function (r) {
const req = r.request(), u = new URL(req.url()), url = u.pathname;
if (u.host === "ig.me") return r.fulfill({ status: 200, contentType: "text/html", body: "<title>ig</title>" });
if (url.startsWith("/static/")) {
const f = path.join(ROOT, "app", url);
if (!fs.existsSync(f)) return r.fulfill({ status: 404, body: "" });
return r.fulfill({ status: 200, contentType: f.endsWith(".css") ? "text/css" : "application/javascript", body: fs.readFileSync(f) });
}
if (url.startsWith("/outreach/api/")) {
const body = req.postData() ? JSON.parse(req.postData()) : null;
calls.push({ method: req.method(), url: url, body: body });
const json = function (o, s) { return r.fulfill({ status: s || 200, contentType: "application/json", body: JSON.stringify(o) }); };
if (url === "/outreach/api/recipients/2/dm-sent") {
return json({ row: { id: 2, kind: "instagram", kind_label: "DM", handle: "mira.kitchen", address: "@mira.kitchen", name: "미라",
status: "보냄", sent_at: "2026-10-27T11:00:00+09:00", sent_via: "dm", dm_link: "https://ig.me/m/mira.kitchen",
profile_link: "https://www.instagram.com/mira.kitchen/", dm_text: "x", needs_name: false, last_error: "" } });
}
if (url === "/outreach/api/recipients/parse") {
return json({ rows: [
{ line: 1, address: "new@x.com", name: "새사람", kind: "email", kind_label: "메일", handle: "new@x.com", error: "", dup: false, exists: false },
{ line: 2, address: "@hong", name: "홍", kind: "instagram", kind_label: "DM", handle: "hong", error: "", dup: false, exists: false },
{ line: 3, address: "홍길동", name: "", kind: null, kind_label: "오류", handle: "", error: "이메일도 인스타그램 주소도 아닙니다: 홍길동", dup: false, exists: false }] });
}
if (url === "/outreach/api/recipients" && req.method() === "POST") return json({ ok: true, added: 2, existed: 0, invalid: 1 });
if (url === "/outreach/api/send") return json({ ok: true, queued: body.ids.length }, 202);
if (url === "/outreach/api/recipients/1/preview") {
return json({ subject: "누적매출 300억", html: "<p>안녕하세요, 김철수님.</p>", text: "안녕하세요, 김철수님.", kind: "email", to: "kim@miras.co.kr", sender_name: "미라네주방" });
}
if (url === "/outreach/api/recipients" && req.method() === "GET") {
const data = JSON.parse(fs.readFileSync(path.join(__dirname, ".out", "outreach.html"), "utf8")
.match(/<script type="application\/json" id="otr-data">([\s\S]*?)<\/script>/)[1]);
return json(data);
}
return json({});
}
r.fulfill({ status: 200, contentType: "text/html; charset=utf-8", body: fs.readFileSync(path.join(__dirname, ".out", "outreach.html"), "utf8") });
});
const p = await ctx.newPage();
p.on("dialog", function (d) { d.accept(); });
// http 테스트 주소는 보안 컨텍스트가 아니라 navigator.clipboard 가 없다 → 화면이 쓰는 예비 복사(execCommand)를 잡아 본다
// (운영은 https 라 navigator.clipboard.writeText 로 복사)
await p.addInitScript(function () {
const orig = document.execCommand.bind(document);
document.execCommand = function (cmd) {
if (cmd === "copy") { const a = document.activeElement; window.__copied = a && "value" in a ? a.value : ""; return true; }
return orig.apply(document, arguments);
};
});
await p.goto("http://erp.test/outreach/");
await p.waitForTimeout(200);
const rowsInfo = function () {
return p.evaluate(function () {
return Array.from(document.querySelectorAll("#otr-tbody tr")).map(function (tr) {
return { id: +tr.dataset.id, kind: tr.querySelector(".otr-kind").textContent, name: tr.querySelector(".otr-name").value,
status: tr.querySelector(".otr-st").textContent, noname: tr.classList.contains("is-noname"),
acts: Array.from(tr.querySelectorAll("[data-act]")).map(function (b) { return b.dataset.act; }) };
});
});
};
const r0 = await rowsInfo();
check("구분 배지 = 주소를 보고 메일/DM, DM 줄은 [DM 보내기]·[보냄], 메일 줄은 [미리보기]",
JSON.stringify(r0.map(function (r) { return r.kind; })) === '["메일","DM","메일","메일"]' &&
JSON.stringify(r0[1].acts) === '["dm","dm-sent"]' && JSON.stringify(r0[0].acts) === '["preview"]', r0);
check("본문 {이름} 인데 이름 없는 줄 = 표시", r0[2].noname && !r0[0].noname, r0[2]);
const cnt = await p.evaluate(function () {
const o = {}; document.querySelectorAll("[data-cnt]").forEach(function (n) { o[n.dataset.cnt] = n.textContent; }); return o;
});
check("걸러 보기 개수", cnt.all === "4" && cnt.email === "3" && cnt.instagram === "1" && cnt["보냄"] === "1", cnt);
await p.click('[data-filter="instagram"]');
check("DM 만 보기", (await rowsInfo()).length === 1);
await p.click('[data-filter="all"]');
// DM 보내기 — 문구 복사 + DM 창
const [igPage] = await Promise.all([ctx.waitForEvent("page"), p.click('tr[data-id="2"] [data-act="dm"]')]);
await igPage.waitForLoadState().catch(function () {});
const clip = await p.evaluate(function () {
return navigator.clipboard ? navigator.clipboard.readText() : (window.__copied || "");
});
check("[DM 보내기] = ig.me/m/계정 새 탭", /ig\.me\/m\/mira\.kitchen/.test(igPage.url()), igPage.url());
check("[DM 보내기] = 이름이 들어간 DM 문구 복사(별표 없음)", clip.indexOf("안녕하세요, 미라님.") === 0 && clip.indexOf("**") < 0 &&
clip.indexOf("'미라네주방'입니다") > 0, clip.slice(0, 80));
await igPage.close();
await p.click('tr[data-id="2"] [data-act="dm-sent"]');
await p.waitForTimeout(100);
const r1 = await rowsInfo();
check("[보냄] → 보냄, 버튼 빠짐", r1[1].status === "보냄" && JSON.stringify(r1[1].acts) === '["dm"]' &&
calls.some(function (c) { return c.url === "/outreach/api/recipients/2/dm-sent"; }), r1[1]);
// 미리보기 창
await p.click('tr[data-id="1"] [data-act="preview"]');
await p.waitForTimeout(100);
const pv = await p.evaluate(function () {
return { shown: !document.getElementById("otr-preview").hidden, subject: document.getElementById("otr-pv-subject").textContent,
doc: document.getElementById("otr-pv-frame").srcdoc };
});
check("미리보기 창 = 제목·본문(그 사람 이름)", pv.shown && /누적매출 300억/.test(pv.subject) && /김철수님/.test(pv.doc), pv);
await p.keyboard.press("Escape");
// 고른 메일 보내기 — 전부 고르면 메일·대기만(1·3), DM·보냄 빠짐
await p.check("#otr-check-all");
check("고른 줄 수 표시", /고른 줄 4 · 보낼 메일 2/.test(await p.textContent("#otr-selected")), await p.textContent("#otr-selected"));
await p.click("#otr-send");
await p.waitForTimeout(200);
const sendCall = calls.find(function (c) { return c.url === "/outreach/api/send"; });
check("고른 메일 보내기 → 메일·대기 줄만 보냄", !!sendCall && JSON.stringify(sendCall.body.ids) === "[1,3]", sendCall);
// 리스트 추가 — 미리보기(판별) → 추가
await p.click("#otr-add-open");
await p.fill("#otr-add-text", "new@x.com 새사람\n@hong 홍\n홍길동");
check("미리보기 전엔 [리스트에 추가] 꺼짐", await p.isDisabled("#otr-add-save"));
await p.click("#otr-add-preview");
await p.waitForTimeout(100);
const prev = await p.evaluate(function () {
return { kinds: Array.from(document.querySelectorAll("#otr-add-result .otr-kind")).map(function (n) { return n.textContent; }),
sum: document.getElementById("otr-add-sum").textContent, err: document.querySelector("#otr-add-result .otr-err").textContent };
});
check("붙여넣기 미리보기 = 메일/DM/오류 + 요약", JSON.stringify(prev.kinds) === '["메일","DM","오류"]' &&
/새로 2명 \(메일 1 · DM 1\) · 오류 1줄/.test(prev.sum) && /인스타그램 주소도 아닙니다/.test(prev.err), prev);
await p.click("#otr-add-save");
await p.waitForTimeout(150);
const add = calls.find(function (c) { return c.method === "POST" && c.url === "/outreach/api/recipients"; });
check("[리스트에 추가] → 붙여 넣은 글 그대로 서버로, 창 닫힘", !!add && /new@x\.com 새사람/.test(add.body.text) &&
await p.evaluate(function () { return document.getElementById("otr-add").hidden; }), add);
} finally {
await browser.close();
}
if (fails.length) { console.log("\n" + fails.length + " FAILED"); process.exit(1); }
console.log("\nALL PASS");
})().catch(function (e) { console.error(e); process.exit(1); });
+44
View File
@@ -0,0 +1,44 @@
"""안내문 발송 화면(index.html)을 진짜 ERP 셸로 렌더 — 브라우저 테스트용(2026-10-27).
python tests/js/render_outreach.py # → tests/js/.out/outreach.html
화면 데이터는 실제 router._view 로 만든다(저장소 없이 줄만 가짜).
"""
from __future__ import annotations
import os
import sys
import jinja2
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, ROOT)
OUT_DIR = os.path.join(ROOT, "tests", "js", ".out")
from app.modules.outreach import store # noqa: E402
from app.modules.outreach.router import _view # noqa: E402
def main() -> None:
os.makedirs(OUT_DIR, exist_ok=True)
env = jinja2.Environment(loader=jinja2.FileSystemLoader([
os.path.join(ROOT, "app", "templates"), os.path.join(ROOT, "app", "modules", "outreach", "templates")]), autoescape=True)
t = {**store.normalize_template(None), "updated_by": "", "updated_at": "", "is_default": True}
base = {"id": 0, "memo": "", "status": "대기", "sent_at": "", "sent_by": "", "sent_via": "", "last_error": ""}
raw = [
{**base, "id": 1, "kind": "email", "handle": "kim@miras.co.kr", "address": "kim@miras.co.kr", "name": "김철수"},
{**base, "id": 2, "kind": "instagram", "handle": "mira.kitchen", "address": "@mira.kitchen", "name": "미라"},
{**base, "id": 3, "kind": "email", "handle": "noname@miras.co.kr", "address": "noname@miras.co.kr", "name": ""},
{**base, "id": 4, "kind": "email", "handle": "done@miras.co.kr", "address": "done@miras.co.kr", "name": "보냄씨",
"status": "보냄", "sent_at": "2026-10-27T10:00:00+09:00", "sent_via": "gmail"},
]
ctx = {"user": {"email": "me@miras.co.kr", "name": "나", "picture": ""}, "is_admin": False, "nav_items": [],
"page_title": "안내문 발송", "page_subtitle": "", "template": t, "images": [], "rows": [_view(r, t) for r in raw],
"logs": [], "gmail": {"available": True, "connected": True, "email": "me@miras.co.kr"}, "msg": ""}
with open(os.path.join(OUT_DIR, "outreach.html"), "w", encoding="utf-8") as f:
f.write(env.get_template("outreach/index.html").render(**ctx))
if __name__ == "__main__":
main()
+437
View File
@@ -0,0 +1,437 @@
"""안내문 발송(outreach, 2026-10-27).
1) store — 주소 판별(메일/인스타), 붙여넣기 해석, {이름}·(광고)·끝 문구, 메일 HTML(escape·굵게·링크·사진), DM 글.
2) send.send_batch — 본인 Gmail 로 한 사람에 한 통, 이름 없음·연결 끊김·한 사람 실패 처리(가짜 Gmail).
3) 실제 앱(격리된 하위 프로세스, 가짜 저장소) — 메뉴·권한·설정 필요 안내·화면·API·Gmail 없을 때 409.
4) 실제 PostgreSQL(OUTREACH_TEST_DB_URL 이 localhost 일 때만) — 추가·중복·두 번 눌러도 한 번(claim)·기록·설정·사진.
"""
import os
import subprocess
import sys
import tempfile
import unittest
import uuid
from pathlib import Path
from unittest.mock import patch
from urllib.parse import urlparse
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app.modules.outreach import send, store # noqa: E402
DSN = os.getenv("OUTREACH_TEST_DB_URL", "")
DB_ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
class DetectParseTests(unittest.TestCase):
def test_detect(self):
ok = {"Kim@Miras.co.kr": ("email", "kim@miras.co.kr"), "mailto:a@b.com": ("email", "a@b.com"),
"@mira.kitchen": ("instagram", "mira.kitchen"), "mira_kitchen": ("instagram", "mira_kitchen"),
"https://www.instagram.com/Lee_S/?hl=ko": ("instagram", "lee_s"), "instagram.com/park.j": ("instagram", "park.j"),
"ig.me/m/hong": ("instagram", "hong"), "https://instagr.am/choi": ("instagram", "choi")}
for a, (k, h) in ok.items():
d = store.detect(a)
self.assertEqual((d["kind"], d["handle"]), (k, h), a)
for bad in ("", "홍길동", "a@b", "bad..name", ".dot", "instagram.com/p/abc123", "https://instagram.com/reel/x", "12345", "a" * 31):
self.assertIsNone(store.detect(bad)["kind"], bad)
def test_parse_bulk(self):
rows = store.parse_bulk("kim@miras.co.kr, 김철수\n홍길동\t@hong.gd\n\n# 주석\nhttps://instagram.com/lee_s 이수진\n"
"@hong.gd 홍길동 또\n박지성 park_js\n주소없음 홍\n")
got = [(r["kind"], r["handle"], r["name"], r["dup"]) for r in rows]
self.assertEqual(got, [("email", "kim@miras.co.kr", "김철수", False), ("instagram", "hong.gd", "홍길동", False),
("instagram", "lee_s", "이수진", False), ("instagram", "hong.gd", "홍길동 또", True),
("instagram", "park_js", "박지성", False), (None, "", "홍", False)])
self.assertEqual([r["line"] for r in rows], [1, 2, 5, 6, 7, 8])
class RenderTests(unittest.TestCase):
T = store.normalize_template({"subject": "{이름}님께 제안", "body": "안녕하세요, {이름}님.\n**미라네주방**입니다.\nhttps://miras.co.kr/",
"footer": "수신 거부는 회신", "ad_label": True, "sender_name": "미라네주방"})
def test_default_template_is_users_text(self):
d = store.DEFAULT_TEMPLATE
self.assertEqual(d["subject"], "누적매출 300억. 800만개 판매 신화 미라클통 '미라네주방'입니다.")
self.assertTrue(d["body"].startswith("안녕하세요, {이름}님.\n주방의 본질을 지키며"))
self.assertTrue(d["body"].rstrip().endswith("미라네주방 팀 드림\nhttps://miras.co.kr/"))
self.assertEqual(d["body"].count("{이름}"), 6)
self.assertTrue(store.needs_name(d))
def test_subject_text_html_dm(self):
self.assertEqual(store.subject_for(self.T, "김철수"), "(광고) 김철수님께 제안")
self.assertEqual(store.plain_text(self.T, "김철수"), "안녕하세요, 김철수님.\n미라네주방입니다.\nhttps://miras.co.kr/\n\n수신 거부는 회신")
h = store.html_body(self.T, "<script>x</script>", ["c1@dbx", "c2@dbx"])
self.assertIn("&lt;script&gt;x&lt;/script&gt;님", h)
self.assertNotIn("<script>", h)
self.assertIn("<b>미라네주방</b>", h)
self.assertIn('<a href="https://miras.co.kr/"', h)
self.assertEqual(h.count('src="cid:'), 2)
self.assertEqual(store.dm_link("mira.kitchen"), "https://ig.me/m/mira.kitchen")
class FakeDB:
def __init__(self, template=None, images=()):
self.t = store.normalize_template(template)
self.images = list(images)
self.done = []
def get_template(self):
return dict(self.t)
def list_images(self, with_data=False):
return self.images
def finish_send(self, rid, *, ok, via, by, subject, error=""):
self.done.append((rid, ok, via, by, subject, error))
class FakeInout:
def __init__(self, connected=True):
self.tok = {"me@miras.co.kr": {"refresh_token_enc": "enc"}} if connected else {}
self.deleted, self.marked = [], []
def gmail_token(self, email):
return self.tok.get(email)
def delete_gmail_token(self, email):
self.deleted.append(email)
def mark_gmail(self, email, error=""):
self.marked.append(email)
class SendBatchTests(unittest.TestCase):
USER = {"email": "me@miras.co.kr", "name": "나"}
ROWS = [{"id": 1, "handle": "a@x.com", "name": "에이"}, {"id": 2, "handle": "b@x.com", "name": ""},
{"id": 3, "handle": "c@x.com", "name": "씨"}]
def _run(self, db, inout, fail_on=None, exc=None):
from app.modules.inout import gmail
sent = []
def fake_send(refresh, raw):
text = raw.decode("utf-8", "replace")
to = next(r["handle"] for r in self.ROWS if r["handle"] in text.split("Subject:")[0])
if fail_on and to == fail_on:
raise exc
sent.append((refresh, to, raw))
return "gid"
with patch.object(gmail, "decrypt_token", return_value="R"), patch.object(gmail, "send", side_effect=fake_send):
res = send.send_batch(db, inout, rows=[dict(r) for r in self.ROWS], user=self.USER, gap=0)
return res, sent
def test_sends_one_each_skips_no_name(self):
import email as em
import email.policy # noqa: F401
db = FakeDB(images=[{"id": 9, "data": b"\xff\xd8jpeg"}])
res, sent = self._run(db, FakeInout())
self.assertEqual(res, {"sent": 2, "failed": 1})
self.assertEqual([s[1] for s in sent], ["a@x.com", "c@x.com"])
msg = em.message_from_bytes(sent[0][2], policy=em.policy.default)
self.assertIn("me@miras.co.kr", msg["From"])
self.assertEqual(msg["To"], "a@x.com")
html = next(p for p in msg.walk() if p.get_content_type() == "text/html").get_content()
self.assertIn("안녕하세요, 에이님.", html)
self.assertIn("cid:outreach-9@dbx", html)
self.assertTrue(any(p.get("Content-ID") == "<outreach-9@dbx>" for p in msg.walk()))
self.assertEqual([(d[0], d[1]) for d in db.done], [(1, True), (2, False), (3, True)])
self.assertIn("이름 없음", db.done[1][5])
def test_not_connected_fails_all(self):
db = FakeDB()
res, sent = self._run(db, FakeInout(connected=False))
self.assertEqual((res, sent), ({"sent": 0, "failed": 3}, []))
self.assertTrue(all(not d[1] and "Gmail 이 연결되지" in d[5] for d in db.done))
def test_disconnect_midway_stops_rest_and_one_bad_address_continues(self):
from app.modules.inout import gmail
db, inout = FakeDB({"body": "본문"}), FakeInout()
res, _ = self._run(db, inout, fail_on="a@x.com", exc=gmail.GmailNotConnected("끊김"))
self.assertEqual(res, {"sent": 0, "failed": 3})
self.assertEqual(inout.deleted, ["me@miras.co.kr"])
db2 = FakeDB({"body": "본문"})
res2, sent2 = self._run(db2, FakeInout(), fail_on="a@x.com", exc=gmail.GmailError("주소 오류"))
self.assertEqual(res2, {"sent": 2, "failed": 1}) # {이름} 없는 본문 = 이름 없어도 보냄
self.assertEqual([s[1] for s in sent2], ["b@x.com", "c@x.com"])
# ── 실제 앱 ─────────────────────────────────────────────
PRELUDE = '''
from unittest.mock import patch
from fastapi.testclient import TestClient
import app.main as main
from app.modules.outreach import store as ostore
from app.modules.outreach import send as osend
def U(email, role="user", outreach=True):
return {"email": email, "name": email.split("@")[0], "role": role, "is_super_admin": False, "modules": {"outreach": outreach}}
who = {"u": None}
me, other = U("me@miras.co.kr"), U("x@miras.co.kr", outreach=False)
users = [me, other]
batches = []
class Store:
def __init__(self):
self.t = ostore.normalize_template(None); self.rows = []; self.seq = 0; self.saved = None
def get_template(self):
return {**self.t, "updated_by": "", "updated_at": "", "is_default": self.saved is None}
def save_template(self, value, by): # db.save_template 과 같은 검사
t = ostore.normalize_template(value)
if not t["subject"] or not t["body"].strip(): raise ValueError("메일 제목·본문을 쓰세요.")
self.t = t; self.saved = by; return self.get_template()
def list_images(self, with_data=False): return []
def list_logs(self, limit=200): return []
def list_recipients(self): return [dict(r) for r in self.rows]
def get_recipient(self, rid): return next((dict(r) for r in self.rows if r["id"] == rid), None)
def add_recipients(self, rows, by):
out = {"added": 0, "existed": 0, "invalid": 0}
for r in rows:
d = ostore.detect(r["address"])
if not d["kind"]: out["invalid"] += 1; continue
if any(x["kind"] == d["kind"] and x["handle"] == d["handle"] for x in self.rows): out["existed"] += 1; continue
self.seq += 1
self.rows.append({"id": self.seq, "kind": d["kind"], "handle": d["handle"], "address": r["address"], "name": r["name"],
"memo": "", "status": "대기", "sent_at": "", "sent_by": "", "sent_via": "", "last_error": ""})
out["added"] += 1
return out
def update_recipient(self, rid, name=None, memo=None, status=None):
r = next(x for x in self.rows if x["id"] == rid)
if name is not None: r["name"] = name
if status is not None: r["status"] = status
return dict(r)
def delete_recipients(self, ids):
n = len(self.rows); self.rows = [r for r in self.rows if r["id"] not in ids]; return n - len(self.rows)
def claim_for_send(self, ids):
got = [r for r in self.rows if r["id"] in ids and r["kind"] == "email" and r["status"] in ("대기", "실패")]
for r in got: r["status"] = "발송중"
return [dict(r) for r in got]
def mark_dm_sent(self, rid, by, subject):
r = next(x for x in self.rows if x["id"] == rid)
if r["kind"] != "instagram": raise ValueError("메일 줄은 [일괄 발송]으로 보냅니다.")
r.update(status="보냄", sent_via="dm", sent_by=by); return dict(r)
class Inout:
def __init__(self, on): self.on = on
def gmail_token(self, email): return {"refresh_token_enc": "x"} if self.on else None
st = Store()
def run(body, connected=False, configured=True):
main.app.state.outreach_store = st if configured else None
main.app.state.inout_store = Inout(connected)
with patch.object(main, "get_current_user_record", side_effect=lambda r: who["u"]), \\
patch.object(main, "get_session_user", side_effect=lambda r: who["u"]), \\
patch.object(main.user_store, "get", side_effect=lambda e: who["u"]), \\
patch.object(main.user_store, "list_all", side_effect=lambda: users), \\
patch.object(osend, "send_batch", side_effect=lambda *a, **kw: batches.append([r["id"] for r in kw["rows"]])), \\
patch("app.modules.inout.gmail.configured", return_value=True):
body(TestClient(main.app, follow_redirects=False))
'''
def _run(code: str) -> subprocess.CompletedProcess:
env = dict(os.environ)
for key in ("ASSET", "CAFE24", "CUPANG", "VACATION", "PROJECT", "DISPATCH", "PERFORMANCE", "MALAYSIA_STOCK",
"ITEMCODE", "EXPENSE", "INOUT", "OUTREACH"):
env[key + "_DB_URL"] = ""
env.update(SESSION_SECRET_KEY="local-outreach-test-only", SESSION_COOKIE_SECURE="false", PERFORMANCE_AUTO_SYNC="false",
PYTHONIOENCODING="utf-8")
with tempfile.TemporaryDirectory(prefix="outreach-web-") as directory:
env["DATA_DIR"] = directory
return subprocess.run([sys.executable, "-c", PRELUDE + code], cwd=ROOT, env=env, capture_output=True,
text=True, encoding="utf-8", timeout=120)
class OutreachWebTests(unittest.TestCase):
def test_registered_permission_and_unconfigured(self):
res = _run('''
from app.store import MODULE_KEYS
def body(c):
assert "outreach" in MODULE_KEYS and main.MODULE_LABELS["outreach"] == "안내문 발송"
who["u"] = me
assert any(x["key"] == "outreach" for x in main.build_erp_nav(me, active="outreach"))
r = c.get("/outreach/")
assert r.status_code == 503 and "OUTREACH_DB_URL" in r.text, r.status_code
assert c.get("/outreach/health").json() == {"status": "not_configured"}
who["u"] = other
assert c.get("/outreach/").status_code == 403
assert c.post("/outreach/api/recipients", json={"text": "a@b.com"}).status_code == 403
print("OK")
run(body, configured=False)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_flow(self):
res = _run('''
def body(c):
who["u"] = me
t = c.get("/outreach/").text
assert "안내문 발송" in t and "누적매출 300억" in t and "Gmail 연결" in t and "고른 메일 보내기" in t
# 설정 — 기본 문구, 저장, (광고)
s = c.get("/outreach/settings").text
assert "기본 문구(아직 저장 안 함)" in s and "주방의 본질을 지키며" in s and "정보통신망법" in s
r = c.post("/outreach/settings", data={"subject": "{이름}님 제안", "body": "안녕하세요 {이름}님", "sender_name": "미라네주방",
"footer": "수신 거부: 회신", "ad_label": "1"})
assert r.status_code == 303 and st.saved == "me@miras.co.kr" and st.t["ad_label"] is True
assert c.post("/outreach/settings", data={"subject": "", "body": "x"}).status_code == 400
# 붙여넣기 미리보기 → 추가
text = "kim@miras.co.kr, 김철수\\n@mira.kitchen 미라\\n홍길동\\n@nobody\\n"
p = c.post("/outreach/api/recipients/parse", json={"text": text}).json()["rows"]
assert [x["kind_label"] for x in p] == ["메일", "DM", "오류", "DM"], p
a = c.post("/outreach/api/recipients", json={"text": text}).json()
assert (a["added"], a["invalid"]) == (3, 1), a
p2 = c.post("/outreach/api/recipients/parse", json={"text": "kim@miras.co.kr"}).json()["rows"]
assert p2[0]["exists"] is True
rows = c.get("/outreach/api/recipients").json()["rows"]
kim, mira, nobody = rows
assert mira["dm_link"] == "https://ig.me/m/mira.kitchen" and "안녕하세요 미라님" in mira["dm_text"]
assert nobody["needs_name"] is True and kim["needs_name"] is False
# 미리보기 — 제목 (광고)·이름
pv = c.get(f"/outreach/api/recipients/{kim['id']}/preview").json()
assert pv["subject"] == "(광고) 김철수님 제안" and "안녕하세요 김철수님" in pv["html"] and "수신 거부: 회신" in pv["text"]
# 이름 고치기
assert c.put(f"/outreach/api/recipients/{nobody['id']}", json={"name": "노바디"}).json()["row"]["needs_name"] is False
# 메일 보내기 — Gmail 없음 = 409(재연결 안내)
r = c.post("/outreach/api/send", json={"ids": [kim["id"]]})
assert r.status_code == 409 and r.json()["reconnect"] is True
# DM 보냄 — 인스타 줄만
assert c.post(f"/outreach/api/recipients/{kim['id']}/dm-sent").status_code == 400
assert c.post(f"/outreach/api/recipients/{mira['id']}/dm-sent").json()["row"]["status"] == "보냄"
print("OK1")
run(body)
def body2(c):
who["u"] = me
kim = st.rows[0]
r = c.post("/outreach/api/send", json={"ids": [r["id"] for r in st.rows]})
assert r.status_code == 202 and r.json()["queued"] == 1, r.text # 메일 줄만(DM 은 빠짐)
assert batches == [[kim["id"]]], batches
assert c.post("/outreach/api/send", json={"ids": [kim["id"]]}).status_code == 409 # 이미 발송중 — 두 번 안 보냄
assert c.post("/outreach/api/send", json={"ids": []}).status_code == 400
assert "보내는 메일: <b>me@miras.co.kr</b>" in c.get("/outreach/").text
assert c.post("/outreach/api/recipients/delete", json={"ids": [st.rows[1]["id"]]}).json()["deleted"] == 1
print("OK2")
run(body2, connected=True)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK2", res.stdout)
def test_gmail_callback_outreach_origin(self):
"""안내문 발송에서 시작한 Gmail 연결 — 입출고 콜백이 outreach 권한으로 처리하고 안내문 화면으로."""
res = _run('''
from app.modules.inout import gmail
from starlette.requests import Request
class Inout2(Inout):
saved = []
def save_gmail_token(self, email, refresh_token_enc, scopes): self.saved.append(email)
class Client:
async def authorize_access_token(self, request):
return {"userinfo": {"email": "me@miras.co.kr"}, "scope": "openid email " + gmail.GMAIL_SCOPE, "refresh_token": "R"}
@main.app.get("/__mark")
def mark(request: Request):
request.session["_gmail_origin"] = "outreach"; request.session["_gmail_next"] = "/outreach/"; return {}
def body(c):
inout = Inout2(False)
main.app.state.inout_store = inout
who["u"] = me
with patch.object(gmail, "oauth_client", return_value=Client()), patch.object(gmail, "encrypt_token", return_value="enc"):
c.get("/__mark")
r = c.get("/inout/gmail/callback")
assert r.status_code == 303 and r.headers["location"].startswith("/outreach/?msg="), (r.status_code, r.headers.get("location"))
assert inout.saved == ["me@miras.co.kr"]
who["u"] = other # 안내문 권한 없으면 거절
c.get("/__mark")
assert c.get("/inout/gmail/callback").status_code == 403
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "OUTREACH_TEST_DB_URL(localhost) 미설정")
class OutreachDBTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
from app.modules.outreach.db import OutreachDBStore
cls.st = OutreachDBStore(DSN)
@classmethod
def tearDownClass(cls):
cls.st.close()
def test_recipients_claim_finish_logs(self):
import threading
st = self.st
tag = uuid.uuid4().hex[:6]
res = st.add_recipients([{"address": f"Kim{tag}@miras.co.kr", "name": "김"}, {"address": f"@mira{tag}", "name": ""},
{"address": "홍길동", "name": "x"}, {"address": f"kim{tag}@MIRAS.co.kr", "name": "다른 이름"}], by="me@x.com")
self.assertEqual(res, {"added": 2, "existed": 1, "invalid": 1})
rows = {r["handle"]: r for r in st.list_recipients() if tag in r["handle"]}
kim, mira = rows[f"kim{tag}@miras.co.kr"], rows[f"mira{tag}"]
self.assertEqual((kim["kind"], kim["name"], mira["kind"]), ("email", "김", "instagram")) # 이미 있는 이름은 그대로
st.add_recipients([{"address": f"@mira{tag}", "name": "미라"}], by="me@x.com") # 빈 이름은 채움
self.assertEqual(st.get_recipient(mira["id"])["name"], "미라")
# 동시에 두 번 잡아도 한 번만
got = []
ts = [threading.Thread(target=lambda: got.append(st.claim_for_send([kim["id"], mira["id"]]))) for _ in range(4)]
[t.start() for t in ts]
[t.join() for t in ts]
self.assertEqual(sorted(len(g) for g in got), [0, 0, 0, 1])
self.assertEqual(st.get_recipient(kim["id"])["status"], "발송중")
self.assertEqual(st.delete_recipients([kim["id"]]), 0) # 보내는 중엔 못 지움
st.finish_send(kim["id"], ok=False, via="gmail", by="me@x.com", subject="제목", error="오류")
self.assertEqual((st.get_recipient(kim["id"])["status"], st.get_recipient(kim["id"])["last_error"]), ("실패", "오류"))
self.assertEqual(len(st.claim_for_send([kim["id"]])), 1) # 실패는 다시 잡힘
st.finish_send(kim["id"], ok=True, via="gmail", by="me@x.com", subject="제목")
k = st.get_recipient(kim["id"])
self.assertEqual((k["status"], k["sent_via"], k["last_error"], bool(k["sent_at"])), ("보냄", "gmail", "", True))
self.assertEqual(st.claim_for_send([kim["id"]]), []) # 보낸 줄은 안 잡힘
self.assertEqual(st.mark_dm_sent(mira["id"], by="me@x.com", subject="s")["status"], "보냄")
with self.assertRaises(ValueError):
st.mark_dm_sent(kim["id"], by="me@x.com", subject="s")
logs = [l for l in st.list_logs() if tag in l["address"].lower()]
self.assertEqual(sorted((l["kind"], l["ok"]) for l in logs), [("email", False), ("email", True), ("instagram", True)])
self.assertEqual(st.update_recipient(kim["id"], status="대기")["status"], "대기")
with self.assertRaises(ValueError):
st.update_recipient(kim["id"], status="보냄")
# 서버가 보내던 중 멈춘 줄 → 실패
st.claim_for_send([kim["id"]])
self.assertGreaterEqual(st.release_stuck(), 1)
self.assertEqual(st.get_recipient(kim["id"])["status"], "실패")
self.assertEqual(st.delete_recipients([kim["id"], mira["id"]]), 2)
def test_template_and_images(self):
st = self.st
t = st.get_template()
self.assertTrue(t["subject"])
saved = st.save_template({"subject": "제목 {이름}", "body": "본문", "ad_label": True, "sender_name": "미라네"}, by="Me@X.com")
self.assertEqual((saved["subject"], saved["ad_label"], saved["updated_by"], saved["is_default"]), ("제목 {이름}", True, "me@x.com", False))
with self.assertRaises(ValueError):
st.save_template({"subject": "", "body": "x"}, by="me")
ids = [st.add_image(filename=f"{i}.jpg", data=b"\xff\xd8" + bytes([i]), width=10, height=10, by="me") for i in range(2)]
try:
self.assertEqual([im["id"] for im in st.list_images() if im["id"] in ids], ids)
st.move_image(ids[1], -1)
self.assertEqual([im["id"] for im in st.list_images() if im["id"] in ids], [ids[1], ids[0]])
self.assertEqual(bytes(st.get_image(ids[0])["data"]), b"\xff\xd8\x00")
self.assertEqual(st.list_images(with_data=True)[0].keys() >= {"data"}, True)
finally:
for i in ids:
st.delete_image(i)
st.save_template(dict(store.DEFAULT_TEMPLATE), by="me")
if __name__ == "__main__":
unittest.main()