614332a1e6
카페24 화면과 몇몇 날짜만 안 맞는데 어느 날·어느 쪽(결제/환불)인지,
저장값이 예전 규칙이라서인지 규칙 자체가 틀린 건지 구분할 방법이 없었다.
- GET /performance/api/marketplaces/{code}/daily-check?from=&to=&live=1 (관리자, 62일)
db = 저장된 날짜별 결제합계·결제 건수·환불합계(c24: 사건 전체 = 카페24 화면 범위)
live = 지금 API·현재 규칙으로 다시 계산(adapter.collect, 저장 안 함)
- 설정 → 카페24 매출 대조 카드에 "일별 한 번에 비교": 카페24 표 붙여넣기 →
날짜별 차이(저장값/API), 판정(일치 / 다시 가져오면 해결 / 규칙 차이(결제·환불)),
[다시 가져오기] 버튼, 날짜 클릭 시 그날 상세 대조
- 테스트 추가
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
197 lines
11 KiB
Python
197 lines
11 KiB
Python
"""① 수집 서비스 — 쇼핑몰 API → 어댑터 → 공통 사건 → DB. 화면(버튼)과 분리된 공통 로직.
|
|
|
|
- 버튼(매출 업데이트)·연결 테스트·향후 cron/worker 모두 이 서비스를 부른다.
|
|
- 같은 쇼핑몰은 동시에 한 번만(perf_sync_runs 의 running 부분 유니크 인덱스).
|
|
- 쇼핑몰 하나가 실패해도 나머지는 계속한다. 실패한 쇼핑몰만 상태가 오류로 바뀐다.
|
|
- 오류 문구·원본 데이터는 비밀값을 가린 뒤에만 저장/로그한다.
|
|
|
|
매출 기준일(sales_date) — 한 곳에서만 정한다(`sales_date_for`):
|
|
결제(SALE) = 결제일(payment_date, 없으면 event_date)
|
|
취소/반품 = 발생일(event_date) — 지난 실적이 나중에 바뀌지 않게
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
import os
|
|
from dataclasses import asdict
|
|
from datetime import date, timedelta
|
|
from typing import Any, Iterable
|
|
|
|
from app.timezone import today_kst
|
|
|
|
from .adapters.base import STATUS_LABELS, AdapterContext, AdapterError, MarketplaceAdapter, SaleEvent
|
|
from .adapters.registry import all_adapters, get_adapter
|
|
from .credentials import CredentialService
|
|
from .security.crypto import CryptoConfigError, DecryptError
|
|
from .security.redact import redact_mapping, redact_text
|
|
|
|
logger = logging.getLogger("performance.sync")
|
|
|
|
DEFAULT_SYNC_DAYS = 7
|
|
|
|
|
|
def sync_days() -> int:
|
|
try:
|
|
return max(1, min(90, int(os.getenv("PERFORMANCE_SYNC_DAYS", str(DEFAULT_SYNC_DAYS)))))
|
|
except ValueError:
|
|
return DEFAULT_SYNC_DAYS
|
|
|
|
|
|
def sales_date_for(ev: SaleEvent) -> date:
|
|
if ev.event_type == "SALE":
|
|
return ev.payment_date or ev.event_date
|
|
return ev.event_date
|
|
|
|
|
|
def event_row(ev: SaleEvent, known_secrets: Iterable[str] = ()) -> dict[str, Any]:
|
|
row = asdict(ev)
|
|
row["sales_date"] = sales_date_for(ev)
|
|
row["raw"] = redact_mapping(ev.raw or {}, known_secrets)
|
|
return row
|
|
|
|
|
|
class SyncService:
|
|
def __init__(self, store: Any, creds: CredentialService, *, app_state: Any = None) -> None:
|
|
self._store = store
|
|
self._creds = creds
|
|
self._app_state = app_state
|
|
|
|
def _ctx(self, adapter: MarketplaceAdapter, *, overrides: dict[str, str] | None = None,
|
|
persist: bool = True, user: str = "") -> AdapterContext:
|
|
acc = self._creds.accessor(adapter.code, overrides=overrides, persist=persist, user=user)
|
|
return AdapterContext(code=adapter.code, credentials=acc, app_state=self._app_state)
|
|
|
|
@staticmethod
|
|
def _failure(exc: Exception, ctx: AdapterContext | None) -> tuple[str, str]:
|
|
known = ctx.credentials.known_secrets() if ctx is not None else []
|
|
if isinstance(exc, AdapterError):
|
|
return exc.status, redact_text(exc.message, known)
|
|
if isinstance(exc, (DecryptError, CryptoConfigError)):
|
|
return "not_configured", redact_text(str(exc), known)
|
|
return "api_error", redact_text(f"예상하지 못한 오류: {type(exc).__name__}: {exc}", known)
|
|
|
|
# ── 연결 테스트 ─────────────────────────────────────────
|
|
def test_connection(self, code: str, *, values: dict[str, str] | None = None, user: str = "") -> dict[str, Any]:
|
|
"""values 를 주면 저장하지 않은 새 입력값으로 시험(저장된 상태는 바꾸지 않음)."""
|
|
adapter = get_adapter(code)
|
|
if adapter is None:
|
|
return {"ok": False, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."}
|
|
unsaved = bool(values)
|
|
ctx = None
|
|
try:
|
|
ctx = self._ctx(adapter, overrides=values, persist=not unsaved, user=user)
|
|
message = adapter.test_connection(ctx)
|
|
status, ok = "ok", True
|
|
except Exception as exc: # noqa: BLE001 — 어떤 오류든 상태로 바꿔 화면에 보여 준다
|
|
status, message = self._failure(exc, ctx)
|
|
ok = False
|
|
logger.info("performance test %s: %s %s", code, status, message)
|
|
if not unsaved:
|
|
self._store.record_test(code, status=status, ok=ok, error="" if ok else message)
|
|
return {"ok": ok, "status": status, "label": STATUS_LABELS.get(status, status),
|
|
"message": message, "unsaved": unsaved}
|
|
|
|
# ── 동기화 ──────────────────────────────────────────────
|
|
def sync_marketplace(self, code: str, start: date, end: date, *, trigger: str = "manual",
|
|
user: str = "") -> dict[str, Any]:
|
|
adapter = get_adapter(code)
|
|
result: dict[str, Any] = {"code": code, "ok": False, "skipped": False, "fetched": 0, "upserted": 0}
|
|
if adapter is None:
|
|
return {**result, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."}
|
|
run_id = self._store.start_run(code, trigger=trigger, range_from=start, range_to=end, user=user)
|
|
if run_id is None:
|
|
return {**result, "skipped": True, "status": "running", "message": "이미 업데이트 중입니다."}
|
|
ctx = None
|
|
try:
|
|
ctx = self._ctx(adapter, user=user)
|
|
fetched, events = adapter.collect(ctx, start, end)
|
|
known = ctx.credentials.known_secrets()
|
|
rows = [event_row(ev, known) for ev in events]
|
|
# 다른 쇼핑몰 열로 보낸 사건 — 등록된 쇼핑몰이 아니면 이 쇼핑몰 열에 둔다(합계가 빠지지 않게).
|
|
registered = {m["code"] for m in self._store.list_marketplaces()}
|
|
for r in rows:
|
|
if r.get("marketplace_code") not in registered:
|
|
r["marketplace_code"] = code
|
|
if adapter.replace_range:
|
|
# 그 기간을 통째로 다시 받은 쇼핑몰 — 기간 안 예전 행을 지우고 새로 넣는다(한 트랜잭션).
|
|
rows = [r for r in rows if start <= r["sales_date"] <= end]
|
|
upserted = self._store.replace_events(code, start, end, rows, id_prefix=adapter.event_prefix)
|
|
else:
|
|
upserted = self._store.upsert_events(code, rows)
|
|
self._store.finish_run(run_id, ok=True, fetched=fetched, upserted=upserted)
|
|
self._store.record_sync(code, status="ok", ok=True)
|
|
return {**result, "ok": True, "status": "ok", "fetched": fetched, "upserted": upserted,
|
|
"message": f"{upserted}건 반영"}
|
|
except Exception as exc: # noqa: BLE001 — 한 쇼핑몰 실패가 전체를 멈추지 않게
|
|
status, message = self._failure(exc, ctx)
|
|
logger.warning("performance sync %s failed: %s %s", code, status, message)
|
|
self._store.finish_run(run_id, ok=False, error=message)
|
|
self._store.record_sync(code, status=status, ok=False, error=message)
|
|
return {**result, "status": status, "label": STATUS_LABELS.get(status, status), "message": message}
|
|
|
|
def sync_all(self, *, start: date | None = None, end: date | None = None, codes: list[str] | None = None,
|
|
trigger: str = "manual", user: str = "") -> list[dict[str, Any]]:
|
|
end = end or today_kst()
|
|
start = start or (end - timedelta(days=sync_days() - 1))
|
|
enabled = {m["code"] for m in self._store.list_marketplaces() if m["enabled"]}
|
|
targets = [a.code for a in all_adapters() if a.code in enabled and (not codes or a.code in codes)]
|
|
return [self.sync_marketplace(c, start, end, trigger=trigger, user=user) for c in targets]
|
|
|
|
# ── 쇼핑몰 화면과 대조 ────────────────────────────────
|
|
def reconcile(self, code: str, day: date, *, user: str = "") -> dict[str, Any]:
|
|
"""어댑터가 지원하면(reconcile) 그날 원천 금액을 항목별로 합산해 돌려준다. DB 는 바꾸지 않는다."""
|
|
adapter = get_adapter(code)
|
|
if adapter is None or not hasattr(adapter, "reconcile"):
|
|
return {"ok": False, "message": "이 쇼핑몰은 대조 기능을 지원하지 않습니다."}
|
|
ctx = None
|
|
try:
|
|
ctx = self._ctx(adapter, user=user)
|
|
return {"ok": True, **adapter.reconcile(ctx, day)}
|
|
except Exception as exc: # noqa: BLE001
|
|
status, message = self._failure(exc, ctx)
|
|
return {"ok": False, "status": status, "label": STATUS_LABELS.get(status, status), "message": message}
|
|
|
|
def daily_check(self, code: str, start: date, end: date, *, live: bool = False, user: str = "") -> dict[str, Any]:
|
|
"""쇼핑몰 화면 일별 매출과 날짜별로 맞춰 보는 용도. DB 는 바꾸지 않는다.
|
|
db = 지금 저장된 값(날짜별 결제·환불·결제 건수)
|
|
live = live=True 일 때 지금 API·현재 규칙으로 다시 계산한 값(매출 업데이트와 같은 계산, 저장 안 함).
|
|
db 만 틀리고 live 가 맞으면 → 예전에 받은 뒤 규칙·주문이 바뀐 것(다시 가져오면 해결)."""
|
|
adapter = get_adapter(code)
|
|
if adapter is None:
|
|
return {"ok": False, "message": "알 수 없는 쇼핑몰입니다."}
|
|
prefix = adapter.event_prefix if adapter.replace_range else ""
|
|
out: dict[str, Any] = {"ok": True, "db": self._store.daily_breakdown(code, start, end, id_prefix=prefix)}
|
|
if not live:
|
|
return out
|
|
ctx = None
|
|
try:
|
|
ctx = self._ctx(adapter, user=user)
|
|
_, events = adapter.collect(ctx, start, end)
|
|
except Exception as exc: # noqa: BLE001
|
|
status, message = self._failure(exc, ctx)
|
|
return {**out, "live_error": f"{STATUS_LABELS.get(status, status)} — {message}"}
|
|
days: dict[str, dict[str, Any]] = {}
|
|
for ev in events:
|
|
d = sales_date_for(ev)
|
|
if not (start <= d <= end):
|
|
continue
|
|
row = days.setdefault(d.isoformat(), {"date": d.isoformat(), "paid": 0, "orders": 0, "refund": 0})
|
|
if ev.event_type == "SALE":
|
|
row["paid"] += ev.amount
|
|
row["orders"] += 1
|
|
else:
|
|
row["refund"] -= ev.amount
|
|
out["live"] = sorted(days.values(), key=lambda r: r["date"])
|
|
return out
|
|
|
|
# ── 테스트(모의) 데이터 ────────────────────────────────
|
|
def generate_samples(self, start: date, end: date, codes: list[str]) -> int:
|
|
from .adapters import mock # noqa: WPS433
|
|
|
|
n = 0
|
|
for code in codes:
|
|
n += self._store.upsert_events(code, (event_row(ev) for ev in mock.generate(code, start, end)),
|
|
is_sample=True)
|
|
return n
|