"""쿠팡 — 쿠팡 윙(마켓플레이스) Open API. 인증: Vendor ID + Access Key + Secret Key 로 요청마다 HMAC 서명(CEA 헤더). signed-date = UTC "yyMMddTHHmmssZ", message = signed-date + METHOD + path + query(물음표 없이, 보내는 그대로) Authorization: CEA algorithm=HmacSHA256, access-key=…, signed-date=…, signature=hex(HMAC-SHA256(secret, message)) (공식 문서 developers.coupangcorp.com → 시작하기 → HMAC Signature 생성 / Python Example, 2026-09-30 확인) OPEN API 키는 판매자당 1개(유효기간 180일). 발급 방식이 둘 — · 연동업체 선택(사방넷 등 1곳만): 그 업체 서버에서 쓰는 키. 우리 서버에서 부르면 막힐 수 있다. · 자체개발: 업체명·URL·허용 IP(최대 10개). 우리 서버 IP 를 넣어야 한다. 매출 수집 — 맞출 화면: WING → 비즈니스 인사이트 → **판매분석**(판매자배송 + 로켓그로스, 날짜 선택) 의 "매출(원)" (2026-10-12 사용자 지정). 판매분석 자체를 주는 Open API 는 없다(2026-10-12 developers.coupang.com API 목록 확인) — 그래서 주문 API 두 개를 결제일(한국 시간)로 합친다: - 판매자배송: 발주서 목록(일단위 페이징) GET /v2/providers/openapi/apis/api/v5/vendors/{vendorId}/ordersheets ?createdAtFrom=yyyy-mm-dd+09:00&createdAtTo=…&status=…&maxPerPage=50&nextToken= — 주문일 기준·한 번에 31일까지·상태(ACCEPT·INSTRUCT·DEPARTURE·DELIVERING·FINAL_DELIVERY·NONE_TRACKING)마다 따로. 결제일(paidAt)로 다시 거른다(주문일 하루 앞부터 조회). 줄 금액 = orderPrice(판매가 × 수량, 쿠폰 할인 전). 완료된 반품·결제 전 취소된 발주서는 이 목록에 없다(쿠팡 안내). - 로켓그로스: 주문 목록 GET /v2/providers/rg_open_api/apis/api/v1/vendors/{vendorId}/rg/orders ?paidDateFrom=yyyymmdd&paidDateTo=yyyymmdd&nextToken= — 결제일 기준·30일까지·분당 50회. 줄 금액 = unitSalesPrice × salesQuantity. 쿠팡 안내상 **출고된 주문만** 나온다(오늘 주문은 출고 뒤에 잡힐 수 있음). - SALE = 주문 하나(판매자배송 `coupang:{orderId}`, 로켓그로스 `coupang:rg:{orderId}`), 날짜 = 결제일. 결제 뒤 취소된 줄(canceled·cancelCount)도 결제일 매출에 둔다(지난 날짜가 나중에 줄지 않게) — 금액은 참고로 따로. 판매분석 "매출" 의 정확한 정의(할인 전·후, 취소 포함 여부)는 공개 문서가 없어 **설정 → 쇼핑몰 원본 데이터 확인** (reconcile)의 날짜별 후보 금액을 WING 숫자와 비교해 확정한다. 구매자 이름·연락처·주소는 저장·표시하지 않는다. 로켓(공급) 매출은 기존 쿠팡 밀크런 모듈의 cupang_sales 에 있다 — 여기에 넣지 않는다. """ from __future__ import annotations import hashlib import hmac import time from datetime import date, datetime, timedelta, timezone from typing import Any, Iterable from urllib.parse import quote, urlencode from .base import ( AdapterContext, AdapterError, ApiError, AuthFailed, CredentialField, MarketplaceAdapter, NotConfigured, SaleEvent, ) from .naver import field_summary, flatten HOST = "https://api-gateway.coupang.com" ORDERS_PATH = "/v2/providers/openapi/apis/api/v5/vendors/{vendor}/ordersheets" RG_ORDERS_PATH = "/v2/providers/rg_open_api/apis/api/v1/vendors/{vendor}/rg/orders" EVENT_PREFIX = "coupang:" RG_PREFIX = "coupang:rg:" STATUSES = ("ACCEPT", "INSTRUCT", "DEPARTURE", "DELIVERING", "FINAL_DELIVERY", "NONE_TRACKING") STATUS_KO = {"ACCEPT": "결제완료", "INSTRUCT": "상품준비중", "DEPARTURE": "배송지시", "DELIVERING": "배송중", "FINAL_DELIVERY": "배송완료", "NONE_TRACKING": "업체직송", "RG": "로켓그로스"} ORDER_SPAN_DAYS = 31 # 발주서 목록 한 번에 조회할 수 있는 기간(시작·끝 포함) RG_SPAN_DAYS = 30 # 로켓그로스 주문 목록 한 번에 조회할 수 있는 기간 PAGE_SIZE = 50 MAX_PAGES = 400 # 한 조회 2만 건 — 무한 반복 방지 CALL_INTERVAL_SEC = 0.25 # 발주서 목록 호출 간격 RG_CALL_INTERVAL_SEC = 1.25 # 로켓그로스 분당 50회 제한 RETRY_429 = 3 RETRY_TIMEOUT_1DAY = 2 # 하루 구간도 시간 초과면 잠깐 쉬고 다시 부르는 횟수 PROBE_MAX_DAYS = 31 KST_OFFSET = timedelta(hours=9) class GatewayTimeout(ApiError): """쿠팡 서버가 시간 안에 답하지 못함(502·503·504·응답 시간 초과) — 조회 기간을 줄이면 대개 풀린다.""" class TooManyPages(ApiError): """한 번 조회가 끝까지 받았는지 확인되지 않음(쪽 수 상한·커서 반복) — 조회 기간을 줄여 다시 부른다(F05).""" # 원본 확인·저장에서 통째로 빼는 항목(구매자·수령자·통관 정보·배송 메모·직접 입력 항목) PERSONAL_KEYS = frozenset({"orderer", "receiver", "overseaShippingInfoDto", "parcelPrintMessage"}) PERSONAL_ITEM_KEYS = frozenset({"etcInfoHeader", "etcInfoValue", "etcInfoValues"}) def signed_date(now: float | None = None) -> str: return time.strftime("%y%m%dT%H%M%SZ", time.gmtime(now)) def authorization(method: str, path: str, query: str, access_key: str, secret_key: str, *, now: float | None = None) -> str: """쿠팡 CEA HMAC 헤더. query 는 실제로 보내는 문자열 그대로(물음표 제외).""" dt = signed_date(now) sig = hmac.new(secret_key.encode("utf-8"), f"{dt}{method}{path}{query}".encode("utf-8"), hashlib.sha256).hexdigest() return f"CEA algorithm=HmacSHA256, access-key={access_key}, signed-date={dt}, signature={sig}" def build_query(params: dict[str, Any]) -> str: """쿠팡 예시와 같은 인코딩 — '+' 는 %2B, ':' 는 그대로(2026-09-30%2B09:00).""" return urlencode({k: v for k, v in params.items() if v is not None}, quote_via=quote, safe=":") def _won(value: Any) -> int: """금액 → 원 정수. 쿠팡 Money({"units": 15000, "nanos": 0})·숫자·문자열("27800") 모두.""" if isinstance(value, dict): return _won(value.get("units")) + int(round((_num(value.get("nanos")) or 0) / 1e9)) n = _num(value) return int(round(n)) if n is not None else 0 def _num(value: Any) -> float | None: if value is None or isinstance(value, bool): return None try: return float(str(value).replace(",", "").strip() or 0) except ValueError: return None def _kst_day(value: Any) -> date | None: """결제 시각 → 한국 날짜. ISO 문자열("2025-08-01T10:06:12+09:00", 시간대 없으면 한국 시간) 또는 밀리초 타임스탬프(1746093162000, 로켓그로스).""" if value is None or value == "": return None n = _num(value) if not isinstance(value, str) or value.strip().isdigit() else None if n is not None: secs = n / 1000 if n > 1e11 else n return (datetime.fromtimestamp(secs, tz=timezone.utc) + KST_OFFSET).date() s = str(value).strip().replace("Z", "+00:00") try: dt = datetime.fromisoformat(s if "T" in s or " " in s else s[:10]) except ValueError: try: return date.fromisoformat(s[:10]) except ValueError: return None if dt.tzinfo is not None: dt = (dt - dt.utcoffset()).replace(tzinfo=None) + KST_OFFSET # type: ignore[operator] return dt.date() def spans(start: date, end: date, days: int) -> list[tuple[date, date]]: """[start, end] 를 days 일(시작·끝 포함) 이하 구간으로 자른다.""" out, d = [], start while d <= end: e = min(end, d + timedelta(days=days - 1)) out.append((d, e)) d = e + timedelta(days=1) return out def safe_order(o: dict[str, Any]) -> dict[str, Any]: """개인정보 항목을 뺀 발주서(원본 확인·저장용).""" out = {k: v for k, v in o.items() if k not in PERSONAL_KEYS} if isinstance(out.get("orderItems"), list): out["orderItems"] = [{k: v for k, v in it.items() if k not in PERSONAL_ITEM_KEYS} for it in out["orderItems"] if isinstance(it, dict)] return out def line_records(o: dict[str, Any]) -> list[dict[str, str]]: """발주서 하나 → 줄(orderItems)마다 평평한 기록 하나 — 원본 확인 표의 항목별 합계용.""" base = flatten({k: v for k, v in safe_order(o).items() if k != "orderItems"}) items = safe_order(o).get("orderItems") or [{}] return [{**base, **flatten(it, "orderItems")} for it in items] def seller_lines(orders: Iterable[dict[str, Any]], start: date, end: date) -> list[dict[str, Any]]: """판매자배송 발주서 → 결제일이 [start, end] 인 줄. 같은 발주서가 두 번 와도(상태 사이 이동) 한 번만.""" seen: set[tuple[str, str, str, str]] = set() out: list[dict[str, Any]] = [] for o in orders: oid = str(o.get("orderId") or "") day = _kst_day(o.get("paidAt") or o.get("orderedAt")) if not oid or day is None or not (start <= day <= end): continue box = str(o.get("shipmentBoxId") or "") first = len(out) for it in o.get("orderItems") or []: if not isinstance(it, dict): continue key = (oid, box, str(it.get("vendorItemId") or ""), str(it.get("sequenceNo") or "")) if key in seen: continue seen.add(key) qty = _won(it.get("shippingCount")) price = _won(it.get("orderPrice")) or _won(it.get("salesPrice")) * qty cancel_qty = _won(it.get("cancelCount")) + _won(it.get("holdCountForCancel")) canceled = bool(it.get("canceled")) or (qty > 0 and cancel_qty >= qty) cancel_amt = price if canceled else (_won(it.get("salesPrice")) * min(cancel_qty, qty) if cancel_qty else 0) out.append({ "orderId": oid, "_day": day, "order_day": _kst_day(o.get("orderedAt")), "status": str(o.get("status") or ""), "amount": price, "discount": _won(it.get("discountPrice")), "canceled": cancel_amt, "qty": qty, "name": str(it.get("sellerProductName") or it.get("vendorItemName") or ""), "opt": str(it.get("sellerProductItemName") or ""), "ship": 0, }) # 배송비는 발주서(묶음 배송)마다 한 번 — 그 발주서의 첫 새 줄에(참고용, 매출 제외). 같은 발주서가 또 오면 새 줄이 없어 안 더함 if len(out) > first: out[first]["ship"] += _won(o.get("shippingPrice")) + _won(o.get("remotePrice")) return out def rg_lines(orders: Iterable[dict[str, Any]], start: date, end: date) -> list[dict[str, Any]]: """로켓그로스 주문 → 결제일이 [start, end] 인 줄. 금액 = 단가 × 수량.""" seen: set[tuple[str, str, int]] = set() out: list[dict[str, Any]] = [] for o in orders: oid = str(o.get("orderId") or "") day = _kst_day(o.get("paidAt")) if not oid or day is None or not (start <= day <= end): continue for i, it in enumerate(o.get("orderItems") or []): if not isinstance(it, dict): continue key = (oid, str(it.get("vendorItemId") or ""), i) if key in seen: continue seen.add(key) qty = _won(it.get("salesQuantity")) out.append({"orderId": oid, "_day": day, "order_day": day, "status": "RG", "amount": _won(it.get("unitSalesPrice")) * qty, "discount": 0, "canceled": 0, "qty": qty, "name": str(it.get("productName") or ""), "opt": "", "ship": 0}) return out def group_lines(lines: Iterable[dict[str, Any]], prefix: str) -> dict[str, dict[str, Any]]: """줄 → 주문 하나(외부 사건 ID 기준).""" orders: dict[str, dict[str, Any]] = {} for ln in lines: eid = f"{prefix}{ln['orderId']}" o = orders.setdefault(eid, {"event_id": eid, "orderId": ln["orderId"], "_day": ln["_day"], "order_day": ln.get("order_day"), "amount": 0, "discount": 0, "canceled": 0, "ship": 0, "qty": 0, "names": [], "opt": "", "statuses": []}) for k in ("amount", "discount", "canceled", "ship", "qty"): o[k] += int(ln.get(k) or 0) if ln["name"] and ln["name"] not in o["names"]: o["names"].append(ln["name"]) o["opt"] = o["opt"] or ln.get("opt") or "" if ln["status"] and ln["status"] not in o["statuses"]: o["statuses"].append(ln["status"]) return orders class CoupangAdapter(MarketplaceAdapter): code = "coupang" name = "쿠팡(윙)" auth_type = "api_key" implemented = True replace_range = True event_prefix = EVENT_PREFIX docs_url = "https://developers.coupang.com/" note = ("쿠팡 윙 → 판매자정보 → 추가판매정보 → OPEN API 키 발급에서 확인합니다. 키는 판매자당 1개이며, " "'연동업체(사방넷 등)'로 발급한 키는 이 서버에서 막힐 수 있습니다 — 그때는 '자체개발'로 바꾸고 " "이 서버 IP 를 허용 IP 에 넣어야 합니다(연결 테스트로 확인). 매출은 판매자배송 + 로켓그로스 주문을 " "결제일로 합칩니다(WING 비즈니스 인사이트 → 판매분석 '매출'과 비교).") def __init__(self) -> None: self._last_call = 0.0 self._last_rg_call = 0.0 def credential_fields(self) -> list[CredentialField]: return [ CredentialField("vendor_id", "Vendor ID(업체코드)", placeholder="A00012345"), CredentialField("access_key", "Access Key", secret=True), CredentialField("secret_key", "Secret Key", secret=True), ] # ── 호출 ────────────────────────────────────────────── def _vendor(self, ctx: AdapterContext) -> str: v = ctx.credentials.get("vendor_id").strip() if not v: raise NotConfigured("쿠팡 Vendor ID·Access Key·Secret Key 를 모두 입력하세요.") return v def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any], *, rg: bool = False) -> dict[str, Any]: """GET — 호출 간격 유지(로켓그로스는 분당 50회), 429 는 잠깐 쉬고 다시.""" import httpx # 지연 import access, secret = ctx.credentials.get("access_key").strip(), ctx.credentials.get("secret_key").strip() if not (access and secret): raise NotConfigured("쿠팡 Vendor ID·Access Key·Secret Key 를 모두 입력하세요.") query = build_query(params) what = "로켓그로스 주문" if rg else "발주서" for attempt in range(RETRY_429 + 1): ctx.progress.check() # [업데이트 취소]면 여기서 멈춤 gap = RG_CALL_INTERVAL_SEC if rg else CALL_INTERVAL_SEC last = self._last_rg_call if rg else self._last_call wait = gap - (time.monotonic() - last) if wait > 0: time.sleep(wait) headers = {"Authorization": authorization("GET", path, query, access, secret), "Content-Type": "application/json;charset=UTF-8"} try: res = httpx.get(f"{HOST}{path}?{query}", headers=headers, timeout=ctx.timeout_sec) except httpx.TimeoutException as exc: raise GatewayTimeout(f"쿠팡 {what} 응답 시간 초과: {type(exc).__name__}") from None except httpx.HTTPError as exc: raise ApiError(f"쿠팡 API 연결 실패: {type(exc).__name__}") from None finally: if rg: self._last_rg_call = time.monotonic() else: self._last_call = time.monotonic() if res.status_code == 429 and attempt < RETRY_429: time.sleep(2.0 * (2 ** attempt)) continue try: body = res.json() except ValueError: if res.status_code < 400: # HTTP 200 이어도 JSON 이 아니면(점검·프록시 안내 페이지 등) 수집 실패 — 빈 목록으로 보면 기간 교체 때 # 그 기간 매출이 지워진다(2026-10-15 검토 F01). 오류 응답(4xx·5xx)은 아래에서 글자로 안내한다. raise ApiError(f"쿠팡 {what} 응답이 JSON 이 아닙니다(HTTP {res.status_code}) — 점검 중일 수 있어 " "저장하지 않았습니다. 잠시 뒤 다시 시도하세요.") from None body = {} if not isinstance(body, dict): body = {"data": body} msg = str(body.get("message") or body.get("error") or res.text[:200] or "").strip()[:300] if res.status_code in (401, 403): raise AuthFailed( f"쿠팡 {what} 조회 거부({res.status_code}): {msg}. Vendor ID·키가 맞는지 확인하세요. 키를 '연동업체(사방넷 등)'로 " "발급했다면 이 서버에서 쓸 수 없을 수 있습니다 — WING 에서 '자체개발'로 바꾸고 이 서버 IP 를 허용 IP 에 " "넣어야 합니다(사방넷 IP 도 함께 넣어야 사방넷이 계속 동작).") if res.status_code == 429: raise ApiError(f"쿠팡 {what} 호출 제한(429)이 계속됩니다. 잠시 뒤 다시 시도하세요.") if res.status_code in (502, 503, 504): raise GatewayTimeout(f"쿠팡 {what} API 오류({res.status_code}): {msg}") if res.status_code >= 400: raise ApiError(f"쿠팡 {what} API 오류({res.status_code}): {msg}") code = body.get("code") if isinstance(code, int) and code >= 400: raise ApiError(f"쿠팡 {what} API 오류({code}): {msg}") return body raise ApiError(f"쿠팡 {what} 호출 제한(429)이 계속됩니다. 잠시 뒤 다시 시도하세요.") @staticmethod def _page_rows(body: dict[str, Any], what: str) -> list[dict[str, Any]]: """한 쪽의 주문 목록 — `data` 가 목록이어야 한다. 목록이 아니면 빈 목록(주문 0건)과 구분해 실패로(F01): `data` 가 없거나 다른 형식이면 오류, `data: null` 은 성공 표시(code 200·OK/SUCCESS)가 함께 있을 때만 빈 목록.""" data = body.get("data") if isinstance(data, list): return [r for r in data if isinstance(r, dict)] code, msg = body.get("code"), str(body.get("message") or "").strip().upper() if "data" in body and data is None and (code in (200, "200") or msg in ("OK", "SUCCESS")): return [] raise ApiError(f"쿠팡 {what} 응답 형식이 예상과 다릅니다(주문 목록 data 없음) — 저장하지 않았습니다. 잠시 뒤 다시 시도하세요.") def _pages(self, ctx: AdapterContext, path: str, params: dict[str, Any], *, rg: bool = False) -> list[dict[str, Any]]: """nextToken 으로 끝까지 받는다. 끝(다음 쪽 없음)을 확인하지 못하면 TooManyPages — 일부만 받은 목록으로 기간을 교체하지 않게(2026-10-15 검토 F05). 부르는 쪽이 기간을 나눠 다시 부른다. - MAX_PAGES 를 다 써도 다음 쪽이 남음 · 같은 nextToken 이 다시 옴(커서 반복) → TooManyPages - 빈 쪽인데 다음 쪽이 있으면 따라간다(예전엔 거기서 끝난 것으로 봤다)""" what = "로켓그로스 주문" if rg else "발주서" out: list[dict[str, Any]] = [] token: str | None = None seen: set[str] = set() for _ in range(MAX_PAGES): body = self._get(ctx, path, {**params, "nextToken": token} if token else params, rg=rg) out.extend(self._page_rows(body, what)) nxt = str(body.get("nextToken") or "").strip() if not nxt: return out # 마지막 쪽 확인 if nxt in seen: raise TooManyPages(f"쿠팡 {what} 다음 쪽 표시가 반복돼 끝까지 받았는지 확인할 수 없습니다 — 저장하지 않았습니다.") seen.add(nxt) token = nxt raise TooManyPages(f"쿠팡 {what} 한 번 조회가 {MAX_PAGES}쪽을 넘었습니다 — 일부만 받은 채 저장하지 않았습니다.") def _seller_orders(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]: """판매자배송 발주서 — 주문일 [start-1, end] 를 31일씩 × 상태 6개. 결제일 필터는 seller_lines 가. 건수가 많은 상태(배송완료 등)는 31일을 한 번에 부르면 쿠팡 서버가 504(시간 초과)를 낸다 — 그러면 그 구간을 반으로 줄여 다시 부르고(하루까지), 줄인 크기는 같은 상태의 다음 구간에도 그대로 쓴다(매번 31일로 실패하지 않게).""" path = ORDERS_PATH.format(vendor=self._vendor(ctx)) out: list[dict[str, Any]] = [] size_by_status = {st: ORDER_SPAN_DAYS for st in STATUSES} for a, b in spans(start - timedelta(days=1), end, ORDER_SPAN_DAYS): for st in STATUSES: rows: list[dict[str, Any]] = [] d, tries = a, 0 while d <= b: e = min(b, d + timedelta(days=size_by_status[st] - 1)) try: part = self._pages(ctx, path, {"createdAtFrom": f"{d.isoformat()}+09:00", "createdAtTo": f"{e.isoformat()}+09:00", "status": st, "maxPerPage": PAGE_SIZE}) except GatewayTimeout as exc: if size_by_status[st] > 1: size_by_status[st] = max(1, size_by_status[st] // 2) continue tries += 1 if tries <= RETRY_TIMEOUT_1DAY: time.sleep(3.0 * tries) continue raise ApiError(f"{exc.message} [주문일 {d.isoformat()} 하루도 시간 초과, 상태 {st}] " "— 잠시 뒤 다시 시도하세요.") from None except TooManyPages as exc: # 끝까지 못 받음 — 구간을 반으로(하루까지), 하루도 넘치면 실패 if size_by_status[st] > 1: size_by_status[st] = max(1, size_by_status[st] // 2) continue raise ApiError(f"{exc.message} [주문일 {d.isoformat()} 하루, 상태 {st}]") from None except ApiError as exc: # 긴 기간을 나눠 부를 때 어느 구간에서 막혔는지 알 수 있게 raise ApiError(f"{exc.message} [주문일 {d.isoformat()}~{e.isoformat()}, 상태 {st}]") from None rows.extend(part) d, tries = e + timedelta(days=1), 0 out.extend(rows) ctx.progress.step(items=len(rows)) return out def _rg_orders(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]: path = RG_ORDERS_PATH.format(vendor=self._vendor(ctx)) out: list[dict[str, Any]] = [] for a, b in spans(start, end, RG_SPAN_DAYS): rows: list[dict[str, Any]] = [] d, size, tries = a, RG_SPAN_DAYS, 0 while d <= b: # 시간 초과면 판매자배송과 같이 구간을 반으로(하루까지) e = min(b, d + timedelta(days=size - 1)) try: part = self._pages(ctx, path, {"paidDateFrom": d.strftime("%Y%m%d"), "paidDateTo": e.strftime("%Y%m%d")}, rg=True) except GatewayTimeout as exc: if size > 1: size = max(1, size // 2) continue tries += 1 if tries <= RETRY_TIMEOUT_1DAY: time.sleep(3.0 * tries) continue raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()} 하루도 시간 초과] " "— 잠시 뒤 다시 시도하세요.") from None except TooManyPages as exc: # 끝까지 못 받음 — 구간을 반으로(하루까지), 하루도 넘치면 실패 if size > 1: size = max(1, size // 2) continue raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()} 하루]") from None except ApiError as exc: raise ApiError(f"{exc.message} [로켓그로스 결제일 {d.isoformat()}~{e.isoformat()}]") from None rows.extend(part) d, tries = e + timedelta(days=1), 0 out.extend(rows) ctx.progress.step(items=len(rows)) return out def _plan(self, ctx: AdapterContext, start: date, end: date) -> None: ctx.progress.plan(len(spans(start - timedelta(days=1), end, ORDER_SPAN_DAYS)) * len(STATUSES) + len(spans(start, end, RG_SPAN_DAYS)), "조회") # ── 수집 ────────────────────────────────────────────── def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: self._plan(ctx, start, end) seller = seller_lines(self._seller_orders(ctx, start, end), start, end) rg = rg_lines(self._rg_orders(ctx, start, end), start, end) yield from group_lines(seller, EVENT_PREFIX).values() yield from group_lines(rg, RG_PREFIX).values() def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]: oid, day = str(o.get("orderId") or ""), o.get("_day") if not oid or day is None: return [] names = o.get("names") or [] name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else "" statuses = [STATUS_KO.get(s, s) for s in o.get("statuses") or []] if o.get("canceled"): statuses.append("취소 포함") return [SaleEvent( event_type="SALE", external_event_id=str(o["event_id"]), external_order_id=oid, order_date=o.get("order_day"), payment_date=day, event_date=day, amount=max(0, int(o.get("amount") or 0)), product_name=name[:200], option_name=str(o.get("opt") or "")[:200], quantity=int(o.get("qty") or 0), discount_amount=max(0, int(o.get("discount") or 0)), order_status="/".join(statuses)[:50], )] def test_connection(self, ctx: AdapterContext) -> str: from app.timezone import today_kst # noqa: WPS433 self.authenticate(ctx) vendor = self._vendor(ctx) today = today_kst() body = self._get(ctx, ORDERS_PATH.format(vendor=vendor), {"createdAtFrom": f"{today.isoformat()}+09:00", "createdAtTo": f"{today.isoformat()}+09:00", "status": "ACCEPT", "maxPerPage": 1}) n = len(body.get("data") or []) rg = self._get(ctx, RG_ORDERS_PATH.format(vendor=vendor), {"paidDateFrom": today.strftime("%Y%m%d"), "paidDateTo": today.strftime("%Y%m%d")}, rg=True) m = len(rg.get("data") or []) return (f"쿠팡 연결 정상(판매자배송 발주서·로켓그로스 주문 조회 권한 확인 — 오늘 결제완료 발주서 {'있음' if n else '없음'}, " f"로켓그로스 오늘 주문 {m}건{'+' if rg.get('nextToken') else ''}).") # ── 원본 데이터 확인(설정 화면 "쇼핑몰 원본 데이터 확인") ───────── def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]: """결제일 기준 기간(최대 31일)의 판매자배송 발주서·로켓그로스 주문을 실제로 불러, 날짜별 후보 금액을 나란히 — WING 판매분석 '매출(원)'과 같은 열을 찾아 규칙을 확정하는 용도. 저장하지 않고, 개인정보 항목은 빼고 보여 준다.""" self.authenticate(ctx) to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1)) self._plan(ctx, day, to) probes: list[dict[str, Any]] = [] seller_raw: list[dict[str, Any]] = [] rg_raw: list[dict[str, Any]] = [] try: seller_raw = self._seller_orders(ctx, day, to) probes.append({"key": "seller", "label": "판매자배송 발주서(주문일 하루 앞부터, 상태 6개)", "path": ORDERS_PATH.format(vendor="{vendorId}"), "ok": True, "count": len(seller_raw), "fields": field_summary([r for o in seller_raw for r in line_records(o)])}) except AdapterError as exc: probes.append({"key": "seller", "label": "판매자배송 발주서", "path": ORDERS_PATH.format(vendor="{vendorId}"), "ok": False, "error": exc.message[:300]}) try: rg_raw = self._rg_orders(ctx, day, to) probes.append({"key": "rg", "label": "로켓그로스 주문(결제일, 출고된 주문만)", "path": RG_ORDERS_PATH.format(vendor="{vendorId}"), "ok": True, "count": len(rg_raw), "fields": field_summary([{**flatten({k: v for k, v in o.items() if k != "orderItems"}), **flatten(it, "orderItems")} for o in rg_raw for it in (o.get("orderItems") or [{}])])}) except AdapterError as exc: probes.append({"key": "rg", "label": "로켓그로스 주문", "path": RG_ORDERS_PATH.format(vendor="{vendorId}"), "ok": False, "error": exc.message[:300]}) seller = seller_lines(seller_raw, day, to) rg = rg_lines(rg_raw, day, to) dates = [(day + timedelta(days=i)).isoformat() for i in range((to - day).days + 1)] def per_day(lines: list[dict[str, Any]], fn: Any) -> dict[str, int]: out = {d: 0 for d in dates} for ln in lines: out[ln["_day"].isoformat()] += int(fn(ln)) return out def count(lines: list[dict[str, Any]], d: str) -> int: return len({ln["orderId"] for ln in lines if ln["_day"].isoformat() == d}) s_amt, s_net = per_day(seller, lambda x: x["amount"]), per_day(seller, lambda x: x["amount"] - x["discount"]) s_live = per_day(seller, lambda x: x["amount"] - x["canceled"]) s_qty, r_qty = per_day(seller, lambda x: x["qty"]), per_day(rg, lambda x: x["qty"]) s_cancel, s_ship = per_day(seller, lambda x: x["canceled"]), per_day(seller, lambda x: x["ship"]) r_amt = per_day(rg, lambda x: x["amount"]) ok = {p["key"]: p["ok"] for p in probes} failed = {p["key"]: p.get("error", "") for p in probes if not p["ok"]} cands = [ {"label": "① 현재 규칙: 판매자배송 판매가 + 로켓그로스", "days": {d: s_amt[d] + r_amt[d] for d in dates}}, {"label": "② 판매자배송 판매가(쿠폰 할인 전)", "days": s_amt, "error": failed.get("seller")}, {"label": "③ 판매자배송 할인 뒤(판매가 − 쿠폰·쿠팡 할인)", "days": s_net, "error": failed.get("seller")}, {"label": "④ 판매자배송 취소분 뺀 판매가", "days": s_live, "error": failed.get("seller")}, {"label": "⑤ 로켓그로스 단가 × 수량", "days": r_amt, "error": failed.get("rg")}, {"label": "판매량: 판매자배송 + 로켓그로스(개)", "days": {d: s_qty[d] + r_qty[d] for d in dates}}, ] if not all(ok.values()): cands[0]["error"] = "일부 조회 실패 — 위 표 참고" days = [{"date": d, "orders": count(seller, d) + count(rg, d), "amount": s_amt[d] + r_amt[d], "claimed": s_cancel[d], "ship": s_ship[d]} for d in dates] return {"date": day.isoformat(), "to": to.isoformat(), "probes": probes, "days": days, "day_cols": {"amount": "매출(현재 규칙)", "claimed": "그중 판매자배송 취소분(참고)", "ship": "판매자배송 배송비(참고, 매출 제외)"}, "refund_candidates": cands, "candidates_title": "매출 후보 비교 — WING 판매분석 '매출(원)'·'판매량'과 같은 열을 알려 주세요", "rule": "결제일(한국 시간) 기준 — 판매자배송 발주서 orderPrice(판매가 × 수량, 쿠폰 할인 전, 결제 뒤 취소분 포함) + " "로켓그로스 unitSalesPrice × salesQuantity(출고된 주문만). 배송비 제외"}