fix(performance): 토스쇼핑 환불 = 클레임 환불 완료 + 클레임 없는 결제취소(환불일) — 9/6 실데이터 11,900 일치

- 9/6: 9/5 주문(276435356)을 9/6 취소 11,900 — 클레임 refundedDt·canceledAt 둘 다 일치, 정산 REFUND 에는 없음
- merge_refunds: 클레임(CANCEL·RETURN, isRefunded, refundedDt) + 클레임 없는 CANCELED_PAYMENT(canceledAt),
  주문상품마다 한 번(toss:R{orderProductId}), 금액 = 주문상품 price(없으면 클레임 order.price), 교환·미환불 제외
- 수집 때 기간 앞 90일 주문도 불러 다른 날 주문의 환불을 잡는다, collect 직접 구현(정산 건별은 수집에 안 씀)
- 원본 데이터 확인: 환불 출처별 비교 첫 열 = 적용 규칙, 날짜별 표의 환불 = 저장되는 값
- performance.js 캐시 버전 20261001d, 테스트·문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-01 10:21:36 +09:00
parent 01000757f3
commit ff81d80cf9
6 changed files with 210 additions and 123 deletions
+124 -67
View File
@@ -17,11 +17,15 @@
주문 하나 = 사건 하나(`toss:{orderId}`), 날짜 = 주문 시각(orderedAt, 한국 날짜 — 토스쇼핑은 주문 = 결제),
금액 = 주문상품 price(판매가 × 수량) 합 — 할인 전, 배송비 제외. 할인(totalDiscountPrice = 토스쇼핑 할인 + 토스페이 할인)은
discount_amount 로만 보관. 결제 전(BEFORE_PAYMENT)만 빼고 결제 뒤 취소·반품도 주문일 매출에 둔다(화면 "매출"도 환불 전 금액).
- 환불 CANCEL — 정산 건별 목록 GET /api/v3/shopping-fep/settlement-steps?dateCondition=TRANSACTION_DATE&fromDate=&toDate=
&size=100&nextToken= 의 stepType=REFUND 줄(상품 줄만 — 배송비 줄은 orderProductId 가 없음). 날짜 = 환불 거래 일시
(transactionTs, 한국 날짜), 금액 = −|orderProductPrice|(정산 기준 금액, 없으면 판매가 × 수량). 결제완료 단계의 고객 취소는
클레임 목록에 안 잡히고 클레임 목록은 날짜로 거를 수 없어 정산 쪽을 쓴다. 사건 ID `toss:R{orderProductId}-{거래일시}`.
- 설정 화면 "쇼핑몰 원본 데이터 확인"에 날짜별 매출·환불·순 거래액 — 파트너스 화면과 같은지 본다.
- 환불 CANCEL/RETURN — 환불일에 뺀다. 주문상품 하나에 한 번(사건 ID `toss:R{orderProductId}`). `merge_refunds`:
① 클레임 목록 GET /api/v3/shopping-fep/claims(날짜 조건이 없어 전체를 넘긴다)의 환불 완료(isRefunded) CANCEL·RETURN —
날짜 = refundedDt(한국 날짜). 반품은 이것뿐(주문 내역엔 반품 완료 날짜가 없다).
② 클레임이 없는 결제취소 — 주문 내역의 canceledAt(한국 날짜). 결제완료 단계의 고객 취소는 클레임이 생기지 않는다(문서).
기간보다 CANCEL_LOOKBACK_DAYS(90)일 앞 주문까지 불러 다른 날 주문을 기간 안에 취소한 것도 잡는다.
금액 = 그 주문상품의 price(판매가 × 수량, 매출과 같은 기준), 주문 내역에 없으면(90일보다 오래된 주문) 클레임 order.price.
9/6 실데이터: 9/5 주문(276435356)을 9/6 취소 11,900 — 클레임(CANCEL/COMPLETED)·canceledAt 둘 다 9/6 = 화면 환불 11,900.
정산 건별(settlement-steps)의 REFUND 는 이 취소를 담지 않아(구매확정 전 취소는 정산에 안 올라옴) 쓰지 않는다.
- 설정 화면 "쇼핑몰 원본 데이터 확인"에 날짜별 매출·환불·순 거래액과 환불 출처별(정산·취소 시각·클레임) 비교.
- 구매자·수령인 이름·연락처·주소·요청사항은 저장하지 않는다.
"""
@@ -174,7 +178,7 @@ def cancel_rows(items: Iterable[dict[str, Any]], start: date, end: date) -> list
continue
status = str(it.get("orderProductStatus") or "")
out.append({"orderId": str(it["orderId"]), "orderProductId": str(it.get("orderProductId") or ""), "_day": day,
"amount": _won(it.get("price")), "note": f"{STATUS_KO.get(status, status)} · 주문일 "
"amount": _won(it.get("price")), "status": status, "note":f"{STATUS_KO.get(status, status)} · 주문일 "
f"{kst_day(it.get('orderedAt')) or '?'}"})
return out
@@ -195,6 +199,43 @@ def claim_rows(items: Iterable[dict[str, Any]], start: date, end: date) -> list[
return out
def merge_refunds(order_items: Iterable[dict[str, Any]], claims: Iterable[dict[str, Any]],
start: date, end: date) -> list[dict[str, Any]]:
"""환불 규칙 — 클레임 환불 완료(CANCEL·RETURN, refundedDt) + 클레임이 없는 결제취소(canceledAt), 주문상품마다 한 번.
금액은 주문 내역의 price(판매가 × 수량)를 우선(없으면 클레임 order.price). 날짜가 [start, end] 인 것만.
클레임이 있는 주문상품은 그 클레임 날짜만 쓴다(기간 밖이어도 취소 시각으로 다시 넣지 않음 — 날짜가 바뀌지 않게)."""
order_items = list(order_items)
by_op = {str(it.get("orderProductId")): it for it in order_items if it.get("orderProductId")}
out: dict[str, dict[str, Any]] = {}
claimed_ops: set[str] = set()
for c in claims:
order = c.get("order") if isinstance(c.get("order"), dict) else {}
product = c.get("product") if isinstance(c.get("product"), dict) else {}
kind = str(c.get("type") or "")
op = str(order.get("orderProductId") or "")
if not c.get("isRefunded") or kind not in ("CANCEL", "RETURN") or not order.get("id") or not op:
continue
claimed_ops.add(op)
day = kst_day(c.get("refundedDt"))
if day is None or not (start <= day <= end) or op in out:
continue
it = by_op.get(op) or {}
out[op] = {"orderId": str(order["id"]), "orderProductId": op, "_day": day, "type": kind,
"amount": _won(it["price"]) if "price" in it else _won(order.get("price")),
"qty": _won(it.get("quantity")) or _won(product.get("quantity")),
"name": str(it.get("productName") or product.get("name") or ""),
"order_day": kst_day(it.get("orderedAt") or order.get("createdDt"))}
for r in cancel_rows(order_items, start, end):
op = r["orderProductId"]
if not op or op in claimed_ops or op in out or r["status"] != "CANCELED_PAYMENT":
continue
it = by_op.get(op) or {}
out[op] = {"orderId": r["orderId"], "orderProductId": op, "_day": r["_day"], "type": "CANCEL",
"amount": r["amount"], "qty": _won(it.get("quantity")), "name": str(it.get("productName") or ""),
"order_day": kst_day(it.get("orderedAt"))}
return sorted(out.values(), key=lambda x: (x["_day"], x["orderId"], x["orderProductId"]))
def summary(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""원본 확인 표 — 항목별 채워진 줄·숫자 합계·예시 값(개인정보·자유 입력 항목은 값·합계 숨김)."""
fields = field_summary([flatten(r) for r in rows])
@@ -403,23 +444,52 @@ class TossAdapter(MarketplaceAdapter):
ctx.progress.step(items=len(rows))
yield from rows
# ── 수집 ──────────────────────────────────────────────
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
ctx.progress.plan(2 * len(self._windows(start, end)), "31일 구간") # 주문 내역 + 정산(환불)
yield from group_orders(self._items(ctx, start, end), start, end).values()
def _lookback_items(self, ctx: AdapterContext, start: date) -> list[dict[str, Any]]:
"""기간 앞 CANCEL_LOOKBACK_DAYS 일의 주문상품 — 다른 날 주문을 기간 안에 취소한 것을 찾는 용도."""
out: list[dict[str, Any]] = []
for a, b in self._windows(start - timedelta(days=CANCEL_LOOKBACK_DAYS), start - timedelta(days=1)):
rows = self._window_items(ctx, a, b)
ctx.progress.step(items=len(rows))
out.extend(rows)
return out
def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
yield from refund_rows(self._refund_items(ctx, start, end), start, end)
def _plan(self, ctx: AdapterContext, start: date, end: date, extra: int = 0) -> None:
"""진행 막대: 기간 주문 구간 + 앞 90일 주문 구간 + 클레임 목록 1단계 (+ 원본 확인의 정산 구간)."""
back = len(self._windows(start - timedelta(days=CANCEL_LOOKBACK_DAYS), start - timedelta(days=1)))
ctx.progress.plan(len(self._windows(start, end)) + back + 1 + extra, "단계")
def _claims_step(self, ctx: AdapterContext) -> list[dict[str, Any]]:
claims = self._claims(ctx)
ctx.progress.step(items=len(claims))
return claims
# ── 수집 ──────────────────────────────────────────────
def collect(self, ctx: AdapterContext, start: date, end: date) -> tuple[int, list[SaleEvent]]:
"""매출(주문일) + 환불(환불일, merge_refunds). 주문 내역은 환불 금액·취소 시각에도 쓰여 한 번만 부른다."""
self.authenticate(ctx)
self._plan(ctx, start, end)
items = list(self._items(ctx, start, end))
back = self._lookback_items(ctx, start)
claims = self._claims_step(ctx)
events: list[SaleEvent] = []
for o in group_orders(items, start, end).values():
events.extend(self.normalize_order(o))
for r in merge_refunds(back + items, claims, start, end):
events.extend(self.normalize_refund(r))
for ev in events:
ev.validate()
return len(items) + len(claims), events
def normalize_refund(self, r: dict[str, Any]) -> list[SaleEvent]:
oid, day = str(r.get("orderId") or ""), r.get("_day")
if not oid or day is None:
if not oid or day is None or not r.get("orderProductId"):
return []
kind = "RETURN" if r.get("type") == "RETURN" else "CANCEL"
return [SaleEvent(
event_type="CANCEL", external_event_id=f"{EVENT_PREFIX}R{r['orderProductId']}-{r.get('_ts') or day}"[:200],
external_order_id=oid, external_line_id=str(r.get("orderProductId") or ""), event_date=day,
order_date=r.get("order_day"), amount=-abs(int(r.get("amount") or 0)),
product_name=str(r.get("name") or "")[:200], quantity=int(r.get("qty") or 0), order_status="환불",
event_type=kind, external_event_id=f"{EVENT_PREFIX}R{r['orderProductId']}", external_order_id=oid,
external_line_id=str(r["orderProductId"]), event_date=day, order_date=r.get("order_day"),
amount=-abs(int(r.get("amount") or 0)), product_name=str(r.get("name") or "")[:200],
quantity=int(r.get("qty") or 0), order_status="반품 환불" if kind == "RETURN" else "취소 환불",
)]
def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]:
@@ -450,22 +520,18 @@ class TossAdapter(MarketplaceAdapter):
# ── 원본 데이터 확인(설정 화면 "쇼핑몰 원본 데이터 확인") ─────────
def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]:
"""기간(최대 31일)의 주문상품을 실제로 불러 항목별 합계·상태별 합계·날짜별 현재 규칙 매출을 돌려준다.
토스쇼핑 파트너스 화면 매출과 어느 항목이 맞는지 실데이터로 확정하는 용도. 개인정보 항목은 값 없이 이름만."""
"""기간(최대 31일)을 실제로 불러 항목별 합계·상태별 합계와 날짜별 매출·환불·순 거래액(= 저장되는 값)을 돌려준다.
환불은 출처별(클레임 환불 완료·주문 취소 시각·정산 REFUND)로도 나란히 보여 파트너스 화면과 맞춰 볼 수 있게.
개인정보 항목은 값 없이 이름만. 저장하지 않는다."""
self.authenticate(ctx)
to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1))
ctx.progress.plan(2 * len(self._windows(day, to)), "31일 구간")
self._plan(ctx, day, to, extra=len(self._windows(day, to)))
try:
items = list(self._items(ctx, day, to))
back = self._lookback_items(ctx, day)
except AdapterError as exc:
return {"date": day.isoformat(), "to": to.isoformat(), "probes": [
{"key": "orders", "label": "주문 내역", "path": ORDERS_PATH, "ok": False, "error": exc.message[:300]}]}
settle_err = ""
try:
settle = list(self._refund_items(ctx, day, to))
except AdapterError as exc:
settle, settle_err = [], exc.message[:300]
refunds = refund_rows(settle, day, to)
by_status: dict[str, list[dict[str, Any]]] = {}
for it in items:
by_status.setdefault(str(it.get("orderProductStatus") or "?"), []).append(it)
@@ -477,55 +543,46 @@ class TossAdapter(MarketplaceAdapter):
" — 결제 뒤 취소·반품(매출 포함)" if st in CLAIMED_STATUS else ""),
"path": "orderProductStatus", "ok": True, "count": len(rows),
"fields": [f for f in summary(rows) if f["sum"] is not None]})
if settle_err:
probes.append({"key": "settlement", "label": "정산 건별(거래일 기준 — 환불)", "path": SETTLEMENT_PATH,
"ok": False, "error": settle_err})
else:
probes.append({"key": "settlement", "label": "정산 건별(거래일 기준, 결제·환불·배송비 줄 전체)",
"path": SETTLEMENT_PATH + " (TRANSACTION_DATE)", "ok": True, "count": len(settle),
"fields": summary(settle)})
steps: dict[str, list[dict[str, Any]]] = {}
for it in settle:
kind = str(it.get("stepType") or "?") + ("" if it.get("orderProductId") else " · 배송비 줄")
steps.setdefault(kind, []).append(it)
for kind, rows in sorted(steps.items()):
probes.append({"key": f"step-{kind}", "label": f"정산 {kind}"
+ (" — 환불(순 거래액에서 뺌)" if kind == "REFUND" else ""),
"path": "stepType", "ok": True, "count": len(rows),
"fields": [f for f in summary(rows) if f["sum"] is not None]})
# ── 환불 후보 세 가지 — 파트너스 화면 "환불"과 어느 쪽이 같은지 날짜별로 나란히(실데이터로 규칙 확정용) ──
candidates: list[dict[str, Any]] = [
{"key": "settlement", "label": "① 정산 REFUND 상품 줄(거래일) — 현재 규칙", "rows": refunds, "error": settle_err}]
# ② 주문 취소 시각 — 기간보다 CANCEL_LOOKBACK_DAYS 전 주문까지 본다(다른 날 주문을 이 기간에 취소한 것)
look_from = day - timedelta(days=CANCEL_LOOKBACK_DAYS)
claims_err = ""
try:
back = [r for a, b in self._windows(look_from, day - timedelta(days=1)) for r in self._window_items(ctx, a, b)]
canceled = cancel_rows(back + items, day, to)
cand_err = ""
except AdapterError as exc:
canceled, cand_err = [], exc.message[:300]
candidates.append({"key": "canceled", "label": f"② 주문 취소 시각(canceledAt, {CANCEL_LOOKBACK_DAYS}일 전 주문까지)",
"rows": canceled, "error": cand_err})
# ③ 클레임 환불 완료 시각 — 클레임 목록은 날짜로 못 거른다(전체를 받아 refundedDt 로 거름)
try:
claims = self._claims(ctx)
claimed = claim_rows(claims, day, to)
claims = self._claims_step(ctx)
probes.append({"key": "claims", "label": "클레임 목록(전체 — 날짜 조건 없음)", "path": CLAIMS_PATH, "ok": True,
"count": len(claims), "fields": summary(claims)})
cand_err = ""
except AdapterError as exc:
claimed, cand_err = [], exc.message[:300]
probes.append({"key": "claims", "label": "클레임 목록", "path": CLAIMS_PATH, "ok": False, "error": cand_err})
candidates.append({"key": "claims", "label": "③ 클레임 환불 완료(refundedDt, 금액 order.price)",
"rows": claimed, "error": cand_err})
claims, claims_err = [], exc.message[:300]
probes.append({"key": "claims", "label": "클레임 목록", "path": CLAIMS_PATH, "ok": False, "error": claims_err})
settle_err = ""
try:
settle = list(self._refund_items(ctx, day, to))
probes.append({"key": "settlement", "label": "정산 건별(거래일 기준, 결제·환불·배송비 줄 전체 — 참고)",
"path": SETTLEMENT_PATH + " (TRANSACTION_DATE)", "ok": True, "count": len(settle),
"fields": summary(settle)})
except AdapterError as exc:
settle, settle_err = [], exc.message[:300]
probes.append({"key": "settlement", "label": "정산 건별(참고)", "path": SETTLEMENT_PATH, "ok": False,
"error": settle_err})
refunds = merge_refunds(back + items, claims, day, to) # 저장되는 환불(현재 규칙)
# ── 환불 출처별 — 파트너스 화면 "환불"과 맞춰 보는 용도 ──
candidates: list[dict[str, Any]] = [
{"key": "rule", "label": "적용 규칙(클레임 환불 + 클레임 없는 결제취소)", "rows": [
{**r, "note": f"{'반품' if r['type'] == 'RETURN' else '취소'} · 주문일 {r.get('order_day') or '?'}"}
for r in refunds], "error": claims_err},
{"key": "claims", "label": "클레임 환불 완료(refundedDt, 금액 order.price)", "rows": claim_rows(claims, day, to),
"error": claims_err},
{"key": "canceled", "label": f"주문 취소 시각(canceledAt, {CANCEL_LOOKBACK_DAYS}일 전 주문까지)",
"rows": cancel_rows(back + items, day, to), "error": ""},
{"key": "settlement", "label": "정산 REFUND 상품 줄(거래일) — 참고", "rows": [
{**r, "note": f"정산 REFUND · 주문일 {r.get('order_day') or '?'}"} for r in refund_rows(settle, day, to)],
"error": settle_err},
]
for c in candidates:
c["days"] = {}
for r in c["rows"]:
k = r["_day"].isoformat()
c["days"][k] = c["days"].get(k, 0) + r["amount"]
c["rows"] = [{"date": r["_day"].isoformat(), "orderId": r["orderId"], "orderProductId": r["orderProductId"],
"amount": r["amount"], "note": r.get("note") or f"정산 REFUND · 주문일 {r.get('order_day') or '?'}"}
"amount": r["amount"], "note": r.get("note") or ""}
for r in sorted(c["rows"], key=lambda x: (x["_day"], x["orderId"]))][:200]
days = []
@@ -542,5 +599,5 @@ class TossAdapter(MarketplaceAdapter):
"refund_candidates": candidates,
"day_cols": {"amount": "매출(주문일)", "claimed": "환불(환불일)", "ship": "순 거래액(저장되는 매출)"},
"rule": "순 거래액 = 매출 − 환불. 매출 = 주문일(orderedAt) 기준 주문상품 price(판매가 × 수량) 합(할인 전, "
"배송비 제외, 나중에 취소·반품된 주문 포함, 결제 전 제외). 환불 = 정산 건별 REFUND 상품 줄의 "
"orderProductPrice, 환불 거래일(transactionTs) 기준. 토스쇼핑 파트너스의 매출·환불·순 거래액과 비교"}
"배송비 제외, 나중에 취소·반품된 주문 포함, 결제 전 제외). 환불 = 클레임 환불 완료(취소·반품, refundedDt) + "
"클레임 없는 결제취소(canceledAt), 주문상품마다 한 번, 금액 = 그 주문상품 price. 환불일 기준"}