Files
dbx-main/app/modules/performance/db.py
T
king c710e184e7 feat(performance): 업데이트 중에도 [매출 업데이트]로 진행 창 다시 보기 · 서버 재시작으로 남은 진행 기록 정리
- 버튼은 업데이트 중 '업데이트 중 · 진행 보기', 누르면 진행 중 작업(수동·자동)을 새로 시작하지 않고 진행 창으로
- 서버 시작 때 perf_sync_runs running 행을 '중단됨(서버 재시작)'으로 정리 — 30분 막힘 방지

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

747 lines
43 KiB
Python

"""performance_db PostgreSQL 저장소.
- 드라이버: psycopg 3 (`psycopg[binary,pool]`) — 다른 모듈과 동일 패턴.
- 연결 정보: 환경변수 `PERFORMANCE_DB_URL`
(예: postgresql://performance_app:<pwd>@postgres-db:5432/performance_db)
- 스키마는 앱이 만들지 않는다. `scripts/sql/performance_db_init.sql` 을 superuser 가 사전 적용.
- 연결 풀은 lazy open — 부팅 시 DB 가 잠시 끊겨도 컨테이너가 죽지 않게.
이 저장소는 인증정보를 **암호문 그대로만** 읽고 쓴다. 암·복호화는 credentials.py 의 몫.
"""
from __future__ import annotations
from datetime import date, datetime, timedelta
from decimal import Decimal
from typing import Any, Iterable
from psycopg import errors as pg_errors
from psycopg.rows import dict_row
from psycopg.types.json import Jsonb
from psycopg_pool import ConnectionPool
from app.timezone import to_kst_iso
# running 상태로 이 시간 넘게 남은 동기화는 죽은 것으로 보고 정리한다(서버 재시작 등).
STALE_RUN_AFTER = timedelta(minutes=30)
class ManualMigrationNeeded(Exception):
"""수동 입력(마이그레이션 002: perf_marketplaces.manual_input · perf_manual_sales)이 아직 적용되지 않음."""
def _iso(v: Any) -> Any:
if isinstance(v, datetime):
return to_kst_iso(v)
if isinstance(v, date):
return v.isoformat()
return v
class PerformanceDBStore:
def __init__(self, dsn: str, *, min_size: int = 1, max_size: int = 5):
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 list_marketplaces(self) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM perf_marketplaces ORDER BY sort_order, code").fetchall()
return [{k: _iso(v) for k, v in r.items()} for r in rows]
def update_marketplace(self, code: str, *, enabled: bool | None = None,
include_in_sales: bool | None = None,
manual_input: bool | None = None) -> dict[str, Any] | None:
sets, params = [], []
if manual_input is not None:
sets.append("manual_input = %s")
params.append(bool(manual_input))
if enabled is not None:
sets.append("enabled = %s")
params.append(bool(enabled))
if include_in_sales is not None:
sets.append("include_in_sales = %s")
params.append(bool(include_in_sales))
if not sets:
return None
params.append(code)
try:
with self._pool.connection() as conn:
row = conn.execute(
f"UPDATE perf_marketplaces SET {', '.join(sets)} WHERE code = %s RETURNING *", params
).fetchone()
except pg_errors.UndefinedColumn:
raise ManualMigrationNeeded() from None
return {k: _iso(v) for k, v in row.items()} if row else None
# ════════════════════════════════════════════════════════════
# 수수료율 이력
# ════════════════════════════════════════════════════════════
def rate_table(self) -> dict[str, list[tuple[date, Decimal]]]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT marketplace_code, effective_from, rate_percent FROM perf_commission_rates "
"WHERE rule_type = 'marketplace' ORDER BY marketplace_code, effective_from"
).fetchall()
out: dict[str, list[tuple[date, Decimal]]] = {}
for r in rows:
out.setdefault(r["marketplace_code"], []).append((r["effective_from"], Decimal(r["rate_percent"])))
return out
def list_rates(self, code: str) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT id, rate_percent, effective_from, memo, created_by, created_at "
"FROM perf_commission_rates WHERE marketplace_code = %s AND rule_type = 'marketplace' "
"ORDER BY effective_from DESC",
(code,),
).fetchall()
return [{k: (str(v) if isinstance(v, Decimal) else _iso(v)) for k, v in r.items()} for r in rows]
def set_rate(self, code: str, *, rate_percent: Decimal, effective_from: date,
memo: str = "", user: str = "") -> None:
"""같은 적용 시작일이면 덮어쓴다(오타 수정), 다르면 이력으로 추가."""
with self._pool.connection() as conn:
conn.execute(
"""
INSERT INTO perf_commission_rates
(marketplace_code, rule_type, rate_percent, effective_from, memo, created_by)
VALUES (%s, 'marketplace', %s, %s, %s, %s)
ON CONFLICT (marketplace_code, rule_type, effective_from) DO UPDATE
SET rate_percent = EXCLUDED.rate_percent, memo = EXCLUDED.memo,
created_by = EXCLUDED.created_by, created_at = now()
""",
(code, rate_percent, effective_from, memo, user),
)
def delete_rate(self, code: str, rate_id: int) -> bool:
with self._pool.connection() as conn:
cur = conn.execute(
"DELETE FROM perf_commission_rates WHERE id = %s AND marketplace_code = %s", (rate_id, code)
)
return cur.rowcount > 0
# ════════════════════════════════════════════════════════════
# 인증정보(암호문)
# ════════════════════════════════════════════════════════════
def credential_rows(self, code: str) -> dict[str, dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT credential_key, encrypted_value, key_version, updated_at, updated_by "
"FROM perf_credentials WHERE marketplace_code = %s",
(code,),
).fetchall()
return {r["credential_key"]: r for r in rows}
def credential_keys_by_code(self) -> dict[str, set[str]]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT marketplace_code, credential_key FROM perf_credentials").fetchall()
out: dict[str, set[str]] = {}
for r in rows:
out.setdefault(r["marketplace_code"], set()).add(r["credential_key"])
return out
def upsert_credential(self, code: str, key: str, *, encrypted_value: str, key_version: int,
user: str = "") -> None:
with self._pool.connection() as conn:
conn.execute(
"""
INSERT INTO perf_credentials (marketplace_code, credential_key, encrypted_value, key_version, updated_by)
VALUES (%s, %s, %s, %s, %s)
ON CONFLICT (marketplace_code, credential_key) DO UPDATE
SET encrypted_value = EXCLUDED.encrypted_value, key_version = EXCLUDED.key_version,
updated_by = EXCLUDED.updated_by
""",
(code, key, encrypted_value, key_version, user),
)
def delete_credential(self, code: str, key: str) -> None:
with self._pool.connection() as conn:
conn.execute(
"DELETE FROM perf_credentials WHERE marketplace_code = %s AND credential_key = %s", (code, key)
)
def all_credential_rows(self) -> list[dict[str, Any]]:
with self._pool.connection() as conn:
return conn.execute(
"SELECT marketplace_code, credential_key, encrypted_value, key_version FROM perf_credentials"
).fetchall()
# ════════════════════════════════════════════════════════════
# 연결 상태
# ════════════════════════════════════════════════════════════
def statuses(self) -> dict[str, dict[str, Any]]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM perf_connection_status").fetchall()
return {r["marketplace_code"]: {k: _iso(v) for k, v in r.items()} for r in rows}
def record_test(self, code: str, *, status: str, ok: bool, error: str = "") -> None:
with self._pool.connection() as conn:
conn.execute(
"""
INSERT INTO perf_connection_status (marketplace_code, status, last_test_at, last_test_ok,
last_error, last_error_at)
VALUES (%s, %s, now(), %s, %s, CASE WHEN %s = '' THEN NULL ELSE now() END)
ON CONFLICT (marketplace_code) DO UPDATE
SET status = EXCLUDED.status, last_test_at = now(), last_test_ok = EXCLUDED.last_test_ok,
last_error = CASE WHEN EXCLUDED.last_error = '' THEN perf_connection_status.last_error
ELSE EXCLUDED.last_error END,
last_error_at = CASE WHEN EXCLUDED.last_error = '' THEN perf_connection_status.last_error_at
ELSE now() END
""",
(code, status, ok, error, error),
)
def record_sync(self, code: str, *, status: str, ok: bool, error: str = "") -> None:
with self._pool.connection() as conn:
conn.execute(
"""
INSERT INTO perf_connection_status (marketplace_code, status, last_sync_at,
last_success_sync_at, last_error, last_error_at)
VALUES (%s, %s, now(), CASE WHEN %s THEN now() END, %s, CASE WHEN %s = '' THEN NULL ELSE now() END)
ON CONFLICT (marketplace_code) DO UPDATE
SET status = EXCLUDED.status, last_sync_at = now(),
last_success_sync_at = CASE WHEN %s THEN now()
ELSE perf_connection_status.last_success_sync_at END,
last_error = CASE WHEN EXCLUDED.last_error = '' THEN perf_connection_status.last_error
ELSE EXCLUDED.last_error END,
last_error_at = CASE WHEN EXCLUDED.last_error = '' THEN perf_connection_status.last_error_at
ELSE now() END
""",
(code, status, ok, error, error, ok),
)
# ════════════════════════════════════════════════════════════
# 매출 사건
# ════════════════════════════════════════════════════════════
def upsert_events(self, code: str, events: Iterable[dict[str, Any]], *, is_sample: bool = False) -> int:
"""같은 (쇼핑몰, 사건 종류, 외부 사건 ID)는 덮어쓴다 — 여러 번 동기화해도 중복 없음."""
rows = self._event_rows(code, events, is_sample)
if not rows:
return 0
with self._pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.executemany(self._UPSERT_SQL, rows)
return len(rows)
def replace_events(self, code: str, start: date, end: date, events: Iterable[dict[str, Any]],
*, id_prefix: str = "") -> int:
"""기간(sales_date) 안 이 어댑터가 만든 실데이터(is_sample 아님)를 지우고 새로 넣는다 — 한 트랜잭션.
지우는 대상: 이 쇼핑몰(code)의 행 + (id_prefix 가 있으면) 다른 쇼핑몰 열로 보냈던 이 어댑터의 행
(external_event_id 가 id_prefix 로 시작). 다른 쇼핑몰의 직접 연동분·테스트 데이터는 건드리지 않는다.
실패하면 롤백되어 예전 데이터가 그대로 남는다."""
rows = self._event_rows(code, events, False)
with self._pool.connection() as conn:
with conn.transaction():
if id_prefix:
conn.execute(
"DELETE FROM perf_sales_events WHERE is_sample = FALSE AND sales_date BETWEEN %s AND %s "
"AND (marketplace_code = %s OR left(external_event_id, %s) = %s)",
(start, end, code, len(id_prefix), id_prefix),
)
else:
conn.execute(
"DELETE FROM perf_sales_events WHERE marketplace_code = %s AND is_sample = FALSE "
"AND sales_date BETWEEN %s AND %s",
(code, start, end),
)
if rows:
with conn.cursor() as cur:
cur.executemany(self._UPSERT_SQL, rows)
return len(rows)
@staticmethod
def _event_rows(code: str, events: Iterable[dict[str, Any]], is_sample: bool) -> list[tuple]:
"""행마다 집계할 쇼핑몰 = 사건의 marketplace_code(다른 쇼핑몰 대신 받은 주문), 없으면 code."""
return [
(e.get("marketplace_code") or code, e["event_type"], e["external_event_id"], e["external_order_id"],
e.get("external_line_id", ""),
e.get("order_date"), e.get("payment_date"), e["event_date"], e["sales_date"],
e.get("product_name", ""), e.get("option_name", ""), int(e.get("quantity") or 0),
int(e["amount"]), int(e.get("discount_amount") or 0), e.get("order_status", ""),
Jsonb(e.get("raw") or {}), is_sample)
for e in events
]
_UPSERT_SQL = """
INSERT INTO perf_sales_events
(marketplace_code, event_type, external_event_id, external_order_id, external_line_id,
order_date, payment_date, event_date, sales_date, product_name, option_name, quantity,
amount, discount_amount, order_status, raw_data, is_sample, synced_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, now())
ON CONFLICT (marketplace_code, event_type, external_event_id) DO UPDATE
SET external_order_id = EXCLUDED.external_order_id, external_line_id = EXCLUDED.external_line_id,
order_date = EXCLUDED.order_date, payment_date = EXCLUDED.payment_date,
event_date = EXCLUDED.event_date, sales_date = EXCLUDED.sales_date,
product_name = EXCLUDED.product_name, option_name = EXCLUDED.option_name,
quantity = EXCLUDED.quantity, amount = EXCLUDED.amount,
discount_amount = EXCLUDED.discount_amount, order_status = EXCLUDED.order_status,
raw_data = EXCLUDED.raw_data, is_sample = EXCLUDED.is_sample, synced_at = now()
"""
def daily_amounts(self, start: date, end: date, codes: list[str]) -> dict[tuple[date, str], int]:
"""날짜 × 쇼핑몰 총매출. 수동 입력이 켜진 쇼핑몰은 수동 값을 넣은 날 그 값이 API 수집값을 대신한다
(실적 화면·회의록 머리 카드가 같은 숫자를 보게 여기서 합친다)."""
if not codes:
return {}
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT sales_date, marketplace_code, SUM(amount)::BIGINT AS amount "
"FROM perf_sales_events WHERE sales_date BETWEEN %s AND %s AND marketplace_code = ANY(%s) "
"GROUP BY sales_date, marketplace_code",
(start, end, codes),
).fetchall()
out = {(r["sales_date"], r["marketplace_code"]): int(r["amount"] or 0) for r in rows}
out.update(self.manual_amounts(start, end, codes))
return out
# ════════════════════════════════════════════════════════════
# 수동 입력 매출(마이그레이션 002)
# ════════════════════════════════════════════════════════════
def manual_amounts(self, start: date, end: date, codes: list[str], *,
active_only: bool = True) -> dict[tuple[date, str], int]:
"""수동 입력 값. active_only = 그 쇼핑몰 수동 입력이 켜진 것만(집계에 쓰는 값). 002 미적용이면 비어 있음."""
if not codes:
return {}
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT s.sales_date, s.marketplace_code, s.amount FROM perf_manual_sales s "
"JOIN perf_marketplaces m ON m.code = s.marketplace_code "
"WHERE s.sales_date BETWEEN %s AND %s AND s.marketplace_code = ANY(%s)"
+ (" AND m.manual_input" if active_only else ""),
(start, end, codes),
).fetchall()
except (pg_errors.UndefinedTable, pg_errors.UndefinedColumn):
return {}
return {(r["sales_date"], r["marketplace_code"]): int(r["amount"]) for r in rows}
def api_amount(self, code: str, day: date) -> int:
"""그날 API 수집 합계(수동 값과 무관) — 수동 입력 칸에 참고로 보여 준다."""
with self._pool.connection() as conn:
row = conn.execute(
"SELECT COALESCE(SUM(amount), 0)::BIGINT AS amount FROM perf_sales_events "
"WHERE marketplace_code = %s AND sales_date = %s", (code, day),
).fetchone()
return int(row["amount"] or 0)
def set_manual_sale(self, code: str, day: date, amount: int | None, *, user: str = "") -> None:
"""수동 값 저장(amount None = 지움 → 그날은 다시 API 값)."""
try:
with self._pool.connection() as conn:
if amount is None:
conn.execute("DELETE FROM perf_manual_sales WHERE marketplace_code = %s AND sales_date = %s",
(code, day))
else:
conn.execute(
"INSERT INTO perf_manual_sales (marketplace_code, sales_date, amount, updated_by) "
"VALUES (%s, %s, %s, %s) ON CONFLICT (marketplace_code, sales_date) DO UPDATE "
"SET amount = EXCLUDED.amount, updated_by = EXCLUDED.updated_by",
(code, day, int(amount), user),
)
except pg_errors.UndefinedTable:
raise ManualMigrationNeeded() from None
def set_manual_sales_bulk(self, entries: list[tuple[str, date, int]], *, user: str = "") -> int:
"""엑셀 업로드 — (쇼핑몰, 날짜, 금액) 여러 개를 한 트랜잭션으로 저장(덮어씀). 하나라도 실패하면 모두 취소."""
if not entries:
return 0
try:
with self._pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.executemany(
"INSERT INTO perf_manual_sales (marketplace_code, sales_date, amount, updated_by) "
"VALUES (%s, %s, %s, %s) ON CONFLICT (marketplace_code, sales_date) DO UPDATE "
"SET amount = EXCLUDED.amount, updated_by = EXCLUDED.updated_by",
[(code, day, int(amount), user) for code, day, amount in entries],
)
except pg_errors.UndefinedTable:
raise ManualMigrationNeeded() from None
return len(entries)
# ════════════════════════════════════════════════════════════
# 광고비(마이그레이션 005)
# ════════════════════════════════════════════════════════════
def ad_amounts(self, start: date, end: date) -> tuple[dict[tuple[date, str], int], dict[tuple[date, str], str]]:
"""(날짜, 채널) → 금액, (날짜, 채널) → 입력 방식(manual/upload/api). 005 미적용이면 AdMigrationNeeded."""
from .ad_spend import AdMigrationNeeded # noqa: WPS433
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT spend_date, channel_code, amount, source FROM perf_ad_spend "
"WHERE spend_date BETWEEN %s AND %s", (start, end),
).fetchall()
except pg_errors.UndefinedTable:
raise AdMigrationNeeded() from None
return ({(r["spend_date"], r["channel_code"]): int(r["amount"]) for r in rows},
{(r["spend_date"], r["channel_code"]): r["source"] for r in rows})
def set_ad_spend(self, code: str, day: date, amount: int | None, *, source: str = "manual", user: str = "") -> None:
"""광고비 한 칸 저장(amount None = 지움)."""
self.set_ad_spend_bulk(code, [(day, amount)], source=source, user=user)
def set_ad_spend_bulk(self, code: str, entries: list[tuple[date, int | None]], *, source: str = "manual",
user: str = "", roas: dict[date, Any] | None = None,
metrics: dict[date, dict[str, Any]] | None = None) -> int:
"""여러 날을 한 트랜잭션으로(같은 날은 덮어씀, 금액 None 은 지움). 하나라도 실패하면 모두 취소.
roas·metrics 를 주면(보고서 업로드, 마이그레이션 006) 그 날의 ROAS·상세 항목도 덮어쓴다 — 안 주면(직접 입력) 그대로 둔다."""
from .ad_spend import AdMigrationNeeded # noqa: WPS433
if not entries:
return 0
report = roas is not None or metrics is not None
try:
with self._pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
gone = [(code, d) for d, a in entries if a is None]
if gone:
cur.executemany("DELETE FROM perf_ad_spend WHERE channel_code = %s AND spend_date = %s", gone)
if report:
keep6 = [(code, d, int(a), source, user, (roas or {}).get(d),
Jsonb((metrics or {}).get(d)) if (metrics or {}).get(d) is not None else None)
for d, a in entries if a is not None]
if keep6:
cur.executemany(
"INSERT INTO perf_ad_spend (channel_code, spend_date, amount, source, updated_by, roas, metrics) "
"VALUES (%s, %s, %s, %s, %s, %s, %s) ON CONFLICT (channel_code, spend_date) DO UPDATE "
"SET amount = EXCLUDED.amount, source = EXCLUDED.source, updated_by = EXCLUDED.updated_by, "
"roas = EXCLUDED.roas, metrics = EXCLUDED.metrics",
keep6,
)
else:
keep = [(code, d, int(a), source, user) for d, a in entries if a is not None]
if keep:
cur.executemany(
"INSERT INTO perf_ad_spend (channel_code, spend_date, amount, source, updated_by) "
"VALUES (%s, %s, %s, %s, %s) ON CONFLICT (channel_code, spend_date) DO UPDATE "
"SET amount = EXCLUDED.amount, source = EXCLUDED.source, updated_by = EXCLUDED.updated_by",
keep,
)
except pg_errors.UndefinedTable:
raise AdMigrationNeeded("005") from None
except pg_errors.UndefinedColumn:
raise AdMigrationNeeded("006") from None
return len(entries)
def ad_roas(self, start: date, end: date) -> dict[tuple[date, str], Decimal]:
"""(날짜, 채널) → 보고서 ROAS(%) — 값이 있는 칸만. 005·006 미적용이면 빈 값(화면은 ROAS 없이)."""
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT spend_date, channel_code, roas FROM perf_ad_spend "
"WHERE spend_date BETWEEN %s AND %s AND roas IS NOT NULL", (start, end),
).fetchall()
except (pg_errors.UndefinedTable, pg_errors.UndefinedColumn):
return {}
return {(r["spend_date"], r["channel_code"]): r["roas"] for r in rows}
def ad_details(self, code: str, start: date, end: date) -> list[dict[str, Any]]:
"""한 채널의 일자별 광고비·ROAS·보고서 항목(날짜 순). 006 미적용이면 AdMigrationNeeded."""
from .ad_spend import AdMigrationNeeded # noqa: WPS433
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT spend_date, amount, roas, metrics, source FROM perf_ad_spend "
"WHERE channel_code = %s AND spend_date BETWEEN %s AND %s ORDER BY spend_date",
(code, start, end),
).fetchall()
except pg_errors.UndefinedTable:
raise AdMigrationNeeded("005") from None
except pg_errors.UndefinedColumn:
raise AdMigrationNeeded("006") from None
return [{"date": r["spend_date"].isoformat(), "amount": int(r["amount"]), "roas": r["roas"],
"metrics": r["metrics"] or {}, "source": r["source"]} for r in rows]
def daily_breakdown(self, code: str, start: date, end: date, *, id_prefix: str = "") -> list[dict[str, Any]]:
"""쇼핑몰 화면(일별 매출내역) 대조용 — 날짜별 결제(SALE 합·건수)·환불(그 밖, 양수)·마지막 수집 시각.
id_prefix 가 있으면 이 어댑터가 다른 쇼핑몰 열로 보낸 사건까지 합친다(카페24 화면 합계와 같은 범위)."""
where = "(marketplace_code = %s OR left(external_event_id, %s) = %s)" if id_prefix else "marketplace_code = %s"
params: tuple = (code, len(id_prefix), id_prefix) if id_prefix else (code,)
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT sales_date, "
" COALESCE(SUM(amount) FILTER (WHERE event_type = 'SALE'), 0)::BIGINT AS paid, "
" COUNT(*) FILTER (WHERE event_type = 'SALE')::INT AS orders, "
" COALESCE(-SUM(amount) FILTER (WHERE event_type <> 'SALE'), 0)::BIGINT AS refund, "
" MAX(synced_at) AS synced_at "
f"FROM perf_sales_events WHERE is_sample = FALSE AND sales_date BETWEEN %s AND %s AND {where} "
"GROUP BY sales_date ORDER BY sales_date",
(start, end, *params),
).fetchall()
return [{"date": r["sales_date"].isoformat(), "paid": int(r["paid"]), "orders": int(r["orders"]),
"refund": int(r["refund"]), "synced_at": _iso(r["synced_at"])} for r in rows]
def list_events(self, code: str, start: date, end: date, *, limit: int = 500) -> list[dict[str, Any]]:
"""금액 클릭 상세(Drill-down). raw_data 는 보내지 않는다."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT id, event_type, external_order_id, external_line_id, order_date, payment_date, "
" event_date, sales_date, product_name, option_name, quantity, amount, "
" discount_amount, order_status, is_sample, "
# 주문 내역 칸(2026-10-19) — 카페24 적립금(결제 +, 환불 −) · 네이버 배송비 · 네이버 환불금액(raw_data 의 숫자만)
" raw_data ->> 'points' AS points, raw_data ->> 'ship' AS ship, raw_data ->> 'refund' AS refund "
"FROM perf_sales_events WHERE marketplace_code = %s AND sales_date BETWEEN %s AND %s "
"ORDER BY sales_date, external_order_id, event_type LIMIT %s",
(code, start, end, limit),
).fetchall()
out = []
for r in rows:
row = {k: _iso(v) for k, v in r.items()}
for k in ("points", "ship", "refund"):
try:
row[k] = int(round(float(row[k]))) if row.get(k) not in (None, "") else None
except (TypeError, ValueError):
row[k] = None
out.append(row)
return out
def sample_count(self) -> int:
with self._pool.connection() as conn:
row = conn.execute("SELECT COUNT(*) AS n FROM perf_sales_events WHERE is_sample").fetchone()
return int(row["n"] or 0)
def delete_sample_events(self) -> int:
"""테스트 데이터만(is_sample) 지운다 — 조건이 있는 삭제."""
with self._pool.connection() as conn:
cur = conn.execute("DELETE FROM perf_sales_events WHERE is_sample = TRUE")
return cur.rowcount
# ════════════════════════════════════════════════════════════
# 동기화 실행(중복 실행 방지)
# ════════════════════════════════════════════════════════════
def start_run(self, code: str, *, trigger: str, range_from: date, range_to: date, user: str) -> int | None:
"""running 행을 만든다. 이미 돌고 있으면 None(부분 유니크 인덱스로 막힘)."""
import psycopg # noqa: WPS433
with self._pool.connection() as conn:
conn.execute(
"UPDATE perf_sync_runs SET status = 'failed', finished_at = now(), "
"error = '중단됨(시간 초과로 정리)' "
"WHERE marketplace_code = %s AND status = 'running' AND started_at < now() - %s",
(code, STALE_RUN_AFTER),
)
try:
row = conn.execute(
"INSERT INTO perf_sync_runs (marketplace_code, trigger, range_from, range_to, started_by) "
"VALUES (%s, %s, %s, %s, %s) RETURNING id",
(code, trigger, range_from, range_to, user),
).fetchone()
except psycopg.errors.UniqueViolation:
return None
return int(row["id"])
def finish_run(self, run_id: int, *, ok: bool, fetched: int = 0, upserted: int = 0, error: str = "") -> None:
with self._pool.connection() as conn:
conn.execute(
"UPDATE perf_sync_runs SET status = %s, fetched_count = %s, upserted_count = %s, "
"error = %s, finished_at = now() WHERE id = %s",
("success" if ok else "failed", fetched, upserted, error, run_id),
)
def last_update_at(self) -> str | None:
"""대시보드 "마지막 업데이트" — 성공한 동기화 중 가장 최근."""
with self._pool.connection() as conn:
row = conn.execute(
"SELECT MAX(finished_at) AS t FROM perf_sync_runs WHERE status = 'success'"
).fetchone()
return _iso(row["t"]) if row and row["t"] else None
def abandon_running_runs(self) -> int:
"""서버 시작 때 1번(2026-10-19) — 남아 있는 running 행은 지난 프로세스가 업데이트 도중 끝난 것(앱은 프로세스 하나,
진행 작업은 메모리에만)이라 '중단됨'으로 정리한다. 안 하면 30분(STALE_RUN_AFTER) 동안 [매출 업데이트]가 '업데이트 중'으로
보이고 그 쇼핑몰 업데이트가 '이미 진행 중'으로 건너뛰어진다. 정리한 행 수."""
with self._pool.connection() as conn:
cur = conn.execute("UPDATE perf_sync_runs SET status = 'failed', finished_at = now(), "
"error = '중단됨(서버 재시작)' WHERE status = 'running'")
return cur.rowcount
def running_codes(self) -> list[str]:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT marketplace_code FROM perf_sync_runs WHERE status = 'running' "
"AND started_at >= now() - %s",
(STALE_RUN_AFTER,),
).fetchall()
return [r["marketplace_code"] for r in rows]
# ════════════════════════════════════════════════════════════
# 광고 API 연동(마이그레이션 007) — 인증정보(암호문)·연결 상태·가져온 광고비
# 읽기는 007 미적용이면 빈 값(설정 화면은 안내만), 쓰기는 AdMigrationNeeded("007").
# ════════════════════════════════════════════════════════════
def ad_api_ready(self) -> bool:
try:
with self._pool.connection() as conn:
conn.execute("SELECT 1 FROM perf_ad_credentials LIMIT 1").fetchall()
except pg_errors.UndefinedTable:
return False
return True
def ad_credential_rows(self, code: str) -> dict[str, dict[str, Any]]:
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT credential_key, encrypted_value, key_version, updated_at, updated_by "
"FROM perf_ad_credentials WHERE channel_code = %s", (code,),
).fetchall()
except pg_errors.UndefinedTable:
return {}
return {r["credential_key"]: r for r in rows}
def ad_credential_keys_by_code(self) -> dict[str, set[str]]:
try:
with self._pool.connection() as conn:
rows = conn.execute("SELECT channel_code, credential_key FROM perf_ad_credentials").fetchall()
except pg_errors.UndefinedTable:
return {}
out: dict[str, set[str]] = {}
for r in rows:
out.setdefault(r["channel_code"], set()).add(r["credential_key"])
return out
def upsert_ad_credential(self, code: str, key: str, *, encrypted_value: str, key_version: int, user: str = "") -> None:
from .ad_spend import AdMigrationNeeded # noqa: WPS433
try:
with self._pool.connection() as conn:
conn.execute(
"""
INSERT INTO perf_ad_credentials (channel_code, credential_key, encrypted_value, key_version, updated_by)
VALUES (%s, %s, %s, %s, %s)
ON CONFLICT (channel_code, credential_key) DO UPDATE
SET encrypted_value = EXCLUDED.encrypted_value, key_version = EXCLUDED.key_version,
updated_by = EXCLUDED.updated_by
""",
(code, key, encrypted_value, key_version, user),
)
except pg_errors.UndefinedTable:
raise AdMigrationNeeded("007") from None
def delete_ad_credential(self, code: str, key: str) -> None:
from .ad_spend import AdMigrationNeeded # noqa: WPS433
try:
with self._pool.connection() as conn:
conn.execute("DELETE FROM perf_ad_credentials WHERE channel_code = %s AND credential_key = %s", (code, key))
except pg_errors.UndefinedTable:
raise AdMigrationNeeded("007") from None
def all_ad_credential_rows(self) -> list[dict[str, Any]]:
try:
with self._pool.connection() as conn:
return conn.execute(
"SELECT channel_code AS marketplace_code, credential_key, encrypted_value, key_version "
"FROM perf_ad_credentials"
).fetchall()
except pg_errors.UndefinedTable:
return []
def ad_source_statuses(self) -> dict[str, dict[str, Any]]:
try:
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM perf_ad_source_status").fetchall()
except pg_errors.UndefinedTable:
return {}
return {r["channel_code"]: {k: _iso(v) for k, v in r.items()} for r in rows}
def record_ad_status(self, code: str, *, status: str, ok: bool, error: str = "", kind: str = "test") -> None:
"""연결 테스트(kind=test) 또는 가져오기(kind=sync) 결과. 오류가 없으면 예전 오류 문구는 그대로 둔다."""
if kind == "sync":
sql = """
INSERT INTO perf_ad_source_status (channel_code, status, last_sync_at, last_success_sync_at, last_error, last_error_at)
VALUES (%(c)s, %(s)s, now(), CASE WHEN %(ok)s THEN now() END, %(e)s, CASE WHEN %(e)s = '' THEN NULL ELSE now() END)
ON CONFLICT (channel_code) DO UPDATE
SET status = EXCLUDED.status, last_sync_at = now(),
last_success_sync_at = CASE WHEN %(ok)s THEN now() ELSE perf_ad_source_status.last_success_sync_at END,
last_error = CASE WHEN %(e)s = '' THEN perf_ad_source_status.last_error ELSE %(e)s END,
last_error_at = CASE WHEN %(e)s = '' THEN perf_ad_source_status.last_error_at ELSE now() END
"""
else:
sql = """
INSERT INTO perf_ad_source_status (channel_code, status, last_test_at, last_test_ok, last_error, last_error_at)
VALUES (%(c)s, %(s)s, now(), %(ok)s, %(e)s, CASE WHEN %(e)s = '' THEN NULL ELSE now() END)
ON CONFLICT (channel_code) DO UPDATE
SET status = EXCLUDED.status, last_test_at = now(), last_test_ok = %(ok)s,
last_error = CASE WHEN %(e)s = '' THEN perf_ad_source_status.last_error ELSE %(e)s END,
last_error_at = CASE WHEN %(e)s = '' THEN perf_ad_source_status.last_error_at ELSE now() END
"""
try:
with self._pool.connection() as conn:
conn.execute(sql, {"c": code, "s": status, "ok": ok, "e": error})
except pg_errors.UndefinedTable:
return # 007 미적용 — 상태 기록만 못 함(가져오기 자체는 막지 않음)
def replace_ad_api_range(self, code: str, start: date, end: date,
days: list[tuple[date, int, Any, dict[str, Any] | None]], *, user: str = "") -> int:
"""광고 API 로 가져온 기간을 한 트랜잭션으로 반영 — days 의 날은 덮어쓰고(source='api', ROAS·보고서 항목 포함,
직접 입력·업로드 값이 있던 날도 API 값으로), 기간 안에서 API 가 돌려주지 않은 날은 **예전 API 값만** 지운다
(직접 입력·업로드 값은 그대로). days = [(날짜, 금액, ROAS, 항목)]. 반영한 날 수."""
from .ad_spend import AdMigrationNeeded # noqa: WPS433
keep = {d for d, _, _, _ in days}
try:
with self._pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
old = cur.execute(
"SELECT spend_date FROM perf_ad_spend WHERE channel_code = %s AND source = 'api' "
"AND spend_date BETWEEN %s AND %s", (code, start, end),
).fetchall()
gone = [(code, r["spend_date"]) for r in old if r["spend_date"] not in keep]
if gone:
cur.executemany("DELETE FROM perf_ad_spend WHERE channel_code = %s AND spend_date = %s "
"AND source = 'api'", gone)
rows = [(code, d, int(a), "api", user, r, Jsonb(m) if m is not None else None) for d, a, r, m in days]
if rows:
cur.executemany(
"INSERT INTO perf_ad_spend (channel_code, spend_date, amount, source, updated_by, roas, metrics) "
"VALUES (%s, %s, %s, %s, %s, %s, %s) ON CONFLICT (channel_code, spend_date) DO UPDATE "
"SET amount = EXCLUDED.amount, source = EXCLUDED.source, updated_by = EXCLUDED.updated_by, "
"roas = EXCLUDED.roas, metrics = EXCLUDED.metrics",
rows,
)
except pg_errors.UndefinedTable:
raise AdMigrationNeeded("005") from None
except pg_errors.UndefinedColumn:
raise AdMigrationNeeded("006") from None
return len(days)
class AdCredentialTable:
"""광고 API 인증정보 표(perf_ad_credentials)를 쇼핑몰 인증정보 저장소와 같은 이름으로 — credentials.CredentialService 가
그대로 쓴다(저장·요약·재암호화). 채널 코드가 쇼핑몰 코드 자리에 들어간다."""
def __init__(self, store: Any) -> None:
self._store = store
def credential_rows(self, code: str) -> dict[str, dict[str, Any]]:
return self._store.ad_credential_rows(code)
def credential_keys_by_code(self) -> dict[str, set[str]]:
return self._store.ad_credential_keys_by_code()
def upsert_credential(self, code: str, key: str, *, encrypted_value: str, key_version: int, user: str = "") -> None:
self._store.upsert_ad_credential(code, key, encrypted_value=encrypted_value, key_version=key_version, user=user)
def delete_credential(self, code: str, key: str) -> None:
self._store.delete_ad_credential(code, key)
def all_credential_rows(self) -> list[dict[str, Any]]:
return self._store.all_ad_credential_rows()