48cd7f0878
- 이름 목록: × 한 명씩 빼기·[전체 삭제], 이름 넣기는 목록에 더함
- 본문: 바로 고침(plaintext-only), {이름} 자리 = 분홍 칩, 이름 누르면 고친 글 + 이름 복사
- 저장한 본문(본문 오른쪽): 설정 DM 문구 + 저장한 것, 고르기·[저장]·[새 본문으로 저장]·× 지우기
- outreach_db 마이그레이션 002 outreach_dm_bodies + POST/PUT/DELETE /outreach/api/dm-bodies
(002 미적용이면 목록 안내만, API 503)
- 캐시 버전 20261030c, 단위·API·실제 PG·브라우저 테스트
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
370 lines
18 KiB
Python
370 lines
18 KiB
Python
"""안내문 발송 — 순수 함수(DB 없음): 주소 판별(이메일 / 인스타그램), 리스트 붙여넣기 해석, {이름} 바꾸기, 메일 HTML·DM 글.
|
|
|
|
- 주소를 보고 정한다: `name@domain.tld` = 메일, `@계정`·`instagram.com/계정`·`ig.me/m/계정`·계정명만(영문·숫자·.·_) = 인스타 DM.
|
|
- 본문 `{이름}` = 그 줄 이름. 메일 본문 = 설정 화면 편집기의 HTML(`fmt: "html"`) — 저장·읽을 때마다 `sanitize_html`(허용 태그·스타일만).
|
|
예전 글·기본 문구(`fmt` 없음 = 글)는 `text_to_html`(`**굵게**` → 굵게, 주소 → 링크, 줄마다 문단).
|
|
- DM 글 = 설정 `dm_body`(인스타 DM 용 글, 서식 없음). 비어 있으면 메일 본문 글 + 끝 문구.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from html import escape
|
|
from html.parser import HTMLParser
|
|
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": "",
|
|
"dm_body": "",
|
|
"fmt": "text", # body 형식 — 기본 문구는 글, 설정 화면에서 저장하면 "html"
|
|
"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, 100000, 2000 # BODY_MAX = 정리한 HTML 길이
|
|
DM_MAX = 1000 # 인스타 DM 한 통 글자 수 한도
|
|
|
|
|
|
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]
|
|
body = str(v["body"] or "")[:BODY_MAX * 3]
|
|
v["body"] = sanitize_html(body if v["fmt"] == "html" else text_to_html(body))
|
|
v["fmt"] = "html"
|
|
v["footer"] = str(v["footer"] or "").replace("\r\n", "\n").strip()[:FOOTER_MAX]
|
|
v["dm_body"] = str(v["dm_body"] or "").replace("\r\n", "\n").strip()[:DM_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], kind: str = "email") -> bool:
|
|
"""그 구분(메일/DM)으로 갈 글에 {이름}이 있는가 — DM 은 DM 문구(없으면 메일 본문)만 본다."""
|
|
if kind == "instagram" and (template.get("dm_body") or "").strip():
|
|
return NAME_TAG in template["dm_body"]
|
|
body = html_to_text(template.get("body") or "")
|
|
if kind == "instagram":
|
|
return NAME_TAG in body or NAME_TAG in (template.get("footer") or "")
|
|
return NAME_TAG in (template.get("subject") or "") or NAME_TAG in body
|
|
|
|
|
|
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 plain_text(template: dict[str, Any], name: str) -> str:
|
|
"""메일 글 부분(HTML 메일의 글 버전)·DM 문구가 없을 때의 DM 글 — 본문 글 + 끝 문구."""
|
|
body = fill(html_to_text(template.get("body") or ""), name).rstrip()
|
|
footer = (template.get("footer") or "").strip()
|
|
return body + ("\n\n" + fill(footer, name) if footer else "")
|
|
|
|
|
|
def dm_text(template: dict[str, Any], name: str) -> str:
|
|
"""인스타 DM 글 — DM 문구가 있으면 그것, 없으면 메일 글(plain_text). **굵게** 는 별표만 뺀다."""
|
|
dm = (template.get("dm_body") or "").strip()
|
|
if not dm:
|
|
return plain_text(template, name)
|
|
return re.sub(r"\*\*(.+?)\*\*", r"\1", fill(dm, name))
|
|
|
|
|
|
def dm_saved_body(value: Any) -> tuple[str, str]:
|
|
"""DM 수동 보내기 탭에 저장할 본문 → (제목, 본문). 제목 = 첫 글 줄 40자(목록 표시용). 비었거나 너무 길면 ValueError."""
|
|
body = str(value or "").replace("\r\n", "\n").strip()
|
|
if not body:
|
|
raise ValueError("본문을 쓰세요.")
|
|
if len(body) > DM_MAX:
|
|
raise ValueError(f"본문은 {DM_MAX}자까지입니다(인스타 DM 한도) — 지금 {len(body)}자.")
|
|
title = next((ln.strip() for ln in body.split("\n") if ln.strip()), "")
|
|
return (title[:40] + ("…" if len(title) > 40 else "")), body
|
|
|
|
|
|
# ── 메일 본문 HTML ─────────────────────────────────────────
|
|
_URL_RE = re.compile(r"https?://[^\s<>\"']+")
|
|
_ALLOWED_TAGS = {"p", "br", "strong", "b", "em", "i", "u", "s", "strike", "span", "a", "ul", "ol", "li",
|
|
"h1", "h2", "h3", "blockquote", "sub", "sup"}
|
|
_DROP_WITH_CONTENT = {"script", "style", "iframe", "object", "head", "title", "template", "noscript", "svg", "math",
|
|
"textarea", "select"}
|
|
_STYLE_PROPS = {"color", "background-color", "font-size", "font-weight", "font-style", "text-decoration", "text-align"}
|
|
_STYLE_VALUE_RE = re.compile(r"^[#\w\s.,%()-]{1,60}$")
|
|
# {이름} — 편집기에서 글자마다 서식이 달라 태그가 끼어도 찾는다(태그는 남기고 글자만 이름으로)
|
|
_NAME_IN_HTML_RE = re.compile(r"\{((?:<[^>]*>)*)이((?:<[^>]*>)*)름((?:<[^>]*>)*)\}")
|
|
|
|
|
|
def _clean_style(value: str) -> str:
|
|
out = []
|
|
for decl in value.split(";"):
|
|
prop, _, val = decl.partition(":")
|
|
prop, val = prop.strip().lower(), val.strip()
|
|
if prop in _STYLE_PROPS and _STYLE_VALUE_RE.match(val) and not re.search(r"url|expression", val, re.I):
|
|
out.append(f"{prop}: {val}")
|
|
return "; ".join(out)
|
|
|
|
|
|
class _Sanitizer(HTMLParser):
|
|
"""허용 태그·속성(style 은 글자 서식만, a 는 http(s)/mailto 링크만)만 남기고 글은 escape. 태그 짝은 맞춰 닫는다.
|
|
편집기(Quill getSemanticHTML)가 띄어쓰기를 로 내보내 보통 띄어쓰기로 바꾼다(메일은 pre-wrap 이라 여러 칸도 그대로)."""
|
|
|
|
def __init__(self) -> None:
|
|
super().__init__(convert_charrefs=True)
|
|
self.out: list[str] = []
|
|
self.stack: list[str] = []
|
|
self.skip = 0
|
|
self.empty_p = False # 지금 연 <p> 에 아직 글이 없다 — 닫을 때 <br> 을 넣어 빈 줄 높이를 지킨다
|
|
|
|
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
|
|
if tag in _DROP_WITH_CONTENT:
|
|
self.skip += 1
|
|
return
|
|
if self.skip or tag not in _ALLOWED_TAGS:
|
|
return
|
|
if tag == "br":
|
|
self.out.append("<br>")
|
|
self.empty_p = False
|
|
return
|
|
a = {k: v or "" for k, v in attrs}
|
|
extra = ""
|
|
style = _clean_style(a.get("style", ""))
|
|
if style:
|
|
extra += f' style="{escape(style)}"'
|
|
href = a.get("href", "").strip()
|
|
if tag == "a" and re.match(r"^(https?:|mailto:)", href, re.I):
|
|
extra += f' href="{escape(href)}"'
|
|
self.out.append(f"<{tag}{extra}>")
|
|
self.stack.append(tag)
|
|
if tag == "p":
|
|
self.empty_p = True
|
|
|
|
def handle_endtag(self, tag: str) -> None:
|
|
if tag in _DROP_WITH_CONTENT:
|
|
self.skip = max(0, self.skip - 1)
|
|
return
|
|
if self.skip or tag not in self.stack:
|
|
return
|
|
while self.stack:
|
|
t = self.stack.pop()
|
|
if t == "p" and self.empty_p:
|
|
self.out.append("<br>")
|
|
self.empty_p = False
|
|
self.out.append(f"</{t}>")
|
|
if t == tag:
|
|
break
|
|
|
|
def handle_data(self, data: str) -> None:
|
|
if self.skip:
|
|
return
|
|
text = data.replace("\r", "").replace("\n", " ").replace("\xa0", " ")
|
|
if not text.strip() and (not self.stack or self.stack[-1] in ("ul", "ol")):
|
|
return
|
|
if text:
|
|
self.out.append(escape(text, quote=False))
|
|
self.empty_p = False
|
|
|
|
def result(self) -> str:
|
|
self.close()
|
|
while self.stack:
|
|
self.handle_endtag(self.stack[-1])
|
|
return "".join(self.out)
|
|
|
|
|
|
def sanitize_html(html: str) -> str:
|
|
p = _Sanitizer()
|
|
p.feed(str(html or ""))
|
|
return p.result()
|
|
|
|
|
|
def text_to_html(text: str) -> str:
|
|
"""글(예전 본문·기본 문구) → 본문 HTML — 줄마다 문단, 빈 줄 = <p><br></p>, **굵게** → <strong>, 주소 → 링크."""
|
|
out = []
|
|
for line in str(text or "").replace("\r\n", "\n").rstrip("\n").split("\n"):
|
|
h = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", escape(line, quote=False))
|
|
h = _URL_RE.sub(lambda m: f'<a href="{m.group(0)}">{m.group(0)}</a>', h)
|
|
out.append(f"<p>{h or '<br>'}</p>")
|
|
return "".join(out)
|
|
|
|
|
|
class _Text(HTMLParser):
|
|
def __init__(self) -> None:
|
|
super().__init__(convert_charrefs=True)
|
|
self.parts: list[str] = []
|
|
|
|
def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
|
|
if tag == "br":
|
|
self.parts.append("\x00") # 문단 끝 바로 앞의 <br>(빈 줄 표시)은 줄을 하나 더 만들지 않는다
|
|
elif tag == "li":
|
|
self.parts.append("- ")
|
|
|
|
def handle_endtag(self, tag: str) -> None:
|
|
if tag in ("p", "li", "h1", "h2", "h3", "blockquote"):
|
|
if self.parts and self.parts[-1] == "\x00":
|
|
self.parts.pop()
|
|
self.parts.append("\n")
|
|
|
|
def handle_data(self, data: str) -> None:
|
|
self.parts.append(data.replace("\xa0", " "))
|
|
|
|
|
|
def html_to_text(html: str) -> str:
|
|
"""본문 HTML → 글(메일 글 버전·DM·{이름} 찾기·리스트 화면 요약)."""
|
|
p = _Text()
|
|
p.feed(str(html or ""))
|
|
p.close()
|
|
return "".join(p.parts).replace("\x00", "\n").rstrip()
|
|
|
|
|
|
def fill_html(html: str, name: str) -> str:
|
|
return _NAME_IN_HTML_RE.sub(lambda m: escape(str(name or "").strip()) + m.group(1) + m.group(2) + m.group(3), str(html or ""))
|
|
|
|
|
|
def _p_margin(html: str) -> str:
|
|
"""메일 프로그램은 <p> 에 위아래 여백을 줘 편집기보다 줄 간격이 벌어진다 — margin:0 을 붙인다."""
|
|
return re.sub(r'<p( style=")?', lambda m: '<p style="margin:0;' if m.group(1) else '<p style="margin:0"', html)
|
|
|
|
|
|
def html_body(template: dict[str, Any], name: str, image_cids: list[str] | None = None) -> str:
|
|
"""메일 HTML — 본문(정리된 편집기 HTML, {이름} 바꿈) + 끝 문구(글 → escape·링크) + 사진은 본문 아래(cid)."""
|
|
body = fill_html(sanitize_html(template.get("body") or ""), name)
|
|
footer = (template.get("footer") or "").strip()
|
|
if footer:
|
|
body += "<p><br></p>" + text_to_html(fill(footer, name))
|
|
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"{_p_margin(body)}</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}/"
|