From aa669553db58923e4fb67c7715fd4899aeed8275 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:07:46 +0900 Subject: [PATCH 01/30] =?UTF-8?q?feat(performance):=20=EC=8B=A4=EC=A0=81(?= =?UTF-8?q?=EC=87=BC=ED=95=91=EB=AA=B0=20=ED=86=B5=ED=95=A9=20=EB=A7=A4?= =?UTF-8?q?=EC=B6=9C)=20=EB=AA=A8=EB=93=88=201=EB=8B=A8=EA=B3=84=20?= =?UTF-8?q?=E2=80=94=20=EB=8C=80=EC=8B=9C=EB=B3=B4=EB=93=9C=C2=B7=EC=84=A4?= =?UTF-8?q?=EC=A0=95=C2=B7=EB=B3=B4=EC=95=88=C2=B7=EC=96=B4=EB=8C=91?= =?UTF-8?q?=ED=84=B0=20=EA=B5=AC=EC=A1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 네 영역 분리: ① 수집(adapters/ 쇼핑몰 10곳 + sync.py) ② 보안(security/ + credentials.py) ③ 계산·저장(calc.py + db.py) ④ 화면(dashboard.py, router.py, templates, performance.css/js) - 대시보드: 기간(오늘/이번주/이번달/올해/직접선택, 이전·다음), 쇼핑몰 필터, KPI 5개(진행 중 기간은 직전 기간 같은 경과일 대비), 일자×쇼핑몰 표(주간합계, 총매출/수수료/차감매출 전환), 일별 추이· 쇼핑몰 비중(SVG), 월 누적(비중)·연간 누적, 금액 클릭 → 주문 상세 - 설정(관리자): 사용/매출 집계, 수수료율 이력(적용 시작일), 쇼핑몰별 API 인증정보 입력·연결 테스트· 연결 상태, 마스터 키 상태·재암호화, 테스트(모의) 데이터 생성/삭제 - 인증정보: 설정 화면 입력 → AES-256-GCM(키 버전, AAD=쇼핑몰+항목) 암호화 저장, secret 원문은 화면으로 다시 보내지 않음, 오류·로그·raw 는 비밀값 가린 뒤 저장. 마스터 키는 APP_ENCRYPTION_KEY(.env) - 매출 기준일: 결제=결제일, 취소·반품=발생일. 금액 원 단위 정수, 수수료 반올림은 calc.commission 한 곳 - 동기화: 같은 쇼핑몰 동시 실행 차단(running 부분 유니크), 쇼핑몰별 실패 격리, 중복 방지 UNIQUE+UPSERT - 카페24 어댑터는 기존 app/integrations/cafe24 OAuth 토큰 재사용, 나머지는 입력칸만(수집은 다음 단계) - performance_db 초기화 스크립트, 권한키 performance(설정은 is_admin), 문서·.env.example Co-Authored-By: Claude Opus 5.5 --- .env.example | 17 + CLAUDE.md | 2 + app/main.py | 19 + app/modules/performance/__init__.py | 25 + app/modules/performance/adapters/__init__.py | 5 + app/modules/performance/adapters/base.py | 215 ++++++++ app/modules/performance/adapters/cafe24.py | 49 ++ app/modules/performance/adapters/coupang.py | 24 + app/modules/performance/adapters/elevenst.py | 21 + app/modules/performance/adapters/gmarket.py | 23 + app/modules/performance/adapters/gsshop.py | 21 + app/modules/performance/adapters/kakao.py | 21 + app/modules/performance/adapters/lotteon.py | 21 + app/modules/performance/adapters/mock.py | 63 +++ app/modules/performance/adapters/naver.py | 27 + app/modules/performance/adapters/ohouse.py | 22 + app/modules/performance/adapters/registry.py | 41 ++ app/modules/performance/adapters/toss.py | 22 + app/modules/performance/calc.py | 305 +++++++++++ app/modules/performance/common.py | 126 +++++ app/modules/performance/credentials.py | 174 ++++++ app/modules/performance/dashboard.py | 197 +++++++ app/modules/performance/db.py | 332 ++++++++++++ app/modules/performance/router.py | 283 ++++++++++ app/modules/performance/security/__init__.py | 1 + app/modules/performance/security/crypto.py | 161 ++++++ app/modules/performance/security/redact.py | 95 ++++ app/modules/performance/sync.py | 138 +++++ .../templates/performance/_tabs.html | 7 + .../templates/performance/index.html | 238 ++++++++ .../templates/performance/settings.html | 121 +++++ app/modules/performance/tests/__init__.py | 0 .../performance/tests/test_performance.py | 406 ++++++++++++++ app/static/performance.css | 209 +++++++ app/static/performance.js | 508 ++++++++++++++++++ app/store.py | 1 + docs/DATABASES.md | 39 ++ docs/DEPLOYMENT.md | 4 + docs/PERFORMANCE_MODULE.md | 117 ++++ docs/PROJECT_OVERVIEW.md | 4 +- scripts/sql/performance_db_init.sql | 223 ++++++++ 41 files changed, 4326 insertions(+), 1 deletion(-) create mode 100644 app/modules/performance/__init__.py create mode 100644 app/modules/performance/adapters/__init__.py create mode 100644 app/modules/performance/adapters/base.py create mode 100644 app/modules/performance/adapters/cafe24.py create mode 100644 app/modules/performance/adapters/coupang.py create mode 100644 app/modules/performance/adapters/elevenst.py create mode 100644 app/modules/performance/adapters/gmarket.py create mode 100644 app/modules/performance/adapters/gsshop.py create mode 100644 app/modules/performance/adapters/kakao.py create mode 100644 app/modules/performance/adapters/lotteon.py create mode 100644 app/modules/performance/adapters/mock.py create mode 100644 app/modules/performance/adapters/naver.py create mode 100644 app/modules/performance/adapters/ohouse.py create mode 100644 app/modules/performance/adapters/registry.py create mode 100644 app/modules/performance/adapters/toss.py create mode 100644 app/modules/performance/calc.py create mode 100644 app/modules/performance/common.py create mode 100644 app/modules/performance/credentials.py create mode 100644 app/modules/performance/dashboard.py create mode 100644 app/modules/performance/db.py create mode 100644 app/modules/performance/router.py create mode 100644 app/modules/performance/security/__init__.py create mode 100644 app/modules/performance/security/crypto.py create mode 100644 app/modules/performance/security/redact.py create mode 100644 app/modules/performance/sync.py create mode 100644 app/modules/performance/templates/performance/_tabs.html create mode 100644 app/modules/performance/templates/performance/index.html create mode 100644 app/modules/performance/templates/performance/settings.html create mode 100644 app/modules/performance/tests/__init__.py create mode 100644 app/modules/performance/tests/test_performance.py create mode 100644 app/static/performance.css create mode 100644 app/static/performance.js create mode 100644 docs/PERFORMANCE_MODULE.md create mode 100644 scripts/sql/performance_db_init.sql diff --git a/.env.example b/.env.example index 6e98a98..e1f2334 100644 --- a/.env.example +++ b/.env.example @@ -146,3 +146,20 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/ # 읽기 전용 역할 itemcode_ro 를 먼저 생성하고(아래 DSN), 낱개+세트 UNION 검색 SQL 사용: # ITEMCODE_DB_URL=postgresql://itemcode_ro:replace-me@postgres-db:5432/itemcode_db # ITEMCODE_SEARCH_SQL=SELECT item_code AS code, name AS name, '낱개' AS type FROM single_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s UNION ALL SELECT item_code AS code, name AS name, '세트' AS type FROM set_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s ORDER BY code ASC LIMIT %(limit)s + +# ─── 실적(쇼핑몰 통합 매출) — app/modules/performance ─── +# performance_db 전용. 미설정 시 모듈이 "설정 필요" 안내만 표시. +# 초기화: scripts/sql/performance_db_init.sql (docs/DATABASES.md 참고) +# PERFORMANCE_DB_URL=postgresql://performance_app:replace-me@postgres-db:5432/performance_db +# +# 쇼핑몰 API 인증정보(ID·Key·Secret·Token)는 여기에 넣지 않는다 — +# 실적 → 설정 화면에서 입력하면 아래 마스터 키로 AES-256-GCM 암호화해 DB 에 저장한다. +# 마스터 키는 DB 에 저장되지 않으며, 잃어버리면 저장된 인증정보를 복구할 수 없다(별도 안전 보관). +# 생성: openssl rand -hex 32 (64자 hex, 또는 32바이트 base64) +# APP_ENCRYPTION_KEY= +# APP_ENCRYPTION_KEY_VERSION=1 +# 키 교체(rotation) 시: 새 키를 APP_ENCRYPTION_KEY 에, 버전을 올리고(예: 2), +# 예전 키는 APP_ENCRYPTION_KEY_V1= 로 남긴 뒤 설정 화면 [현재 키로 다시 암호화] → 완료 후 V1 삭제. +# APP_ENCRYPTION_KEY_V1= +# [매출 업데이트] 가 가져오는 기간(오늘 포함 최근 N일, 기본 7, 최대 90) +# PERFORMANCE_SYNC_DAYS=7 diff --git a/CLAUDE.md b/CLAUDE.md index 94889b8..a1c3f74 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -38,6 +38,8 @@ Claude Code는 이 저장소에서 작업을 시작하기 전에 **반드시 아 - 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력. 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널). 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지(`POST /admin/products/{no}/images` 에 base64 data URI + `image_upload_type=A` — NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지. 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력. 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지). **카페24 관리자 API 는 PUT 뒤 한동안 GET 에서 예전 값을 돌려준다(읽기 지연)** — 우리 캐시 문제가 아니다. 그래서 "마지막 쓰기가 권위": 상세설명은 카페24 값이 최근 revision 중 하나와 같으면 지연으로 보고 마지막 MANUAL/SCHEDULED 를 표시·지문 기준으로 쓰고(`store.resolve_description`), 스칼라(상품명·가격·이미지·진열/판매)는 PUT 응답 스냅샷(`cafe24_products.last_write_snapshot`, 마이그레이션 004)과 GET 의 `updated_date` 를 비교해 덮어씌운다(`store.overlay_recent_write`). 유예시간 `CAFE24_READ_LAG_GRACE_MIN`(기본 360분). 쓰기 후 화면은 PUT 응답으로 그리고 다시 GET 하지 않는다. 예약은 DB 저장 + 별도 worker(`app/modules/cafe24/worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다. 권한키 `cafe24`(연결/해제는 admin 전용). 상세는 `docs/CAFE24_MODULE.md` - 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·프로젝트 색상(32색 — 아사나 16색 + 진한 16색)·아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011)·작업(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed, 섹션 기본 담당자 `default_assignee_email` — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정, 마이그레이션 009)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글. 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다. 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 작업(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 작업이 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/작업/단계 CRUD — URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터). 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만. 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, 관리자만 보기·복구(`/project/trash`). 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008. 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성). 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503), 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외), 댓글 `@아이디` 는 아이콘+이름 칩. 수신함 "확인"은 페이지 이동 없이 오른쪽 iframe 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`). 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남). 상세는 `docs/PROJECT_MODULE.md` +- 실적 (`app/modules/performance/`, `performance_db`) — 쇼핑몰 통합 매출. 네 영역 분리: ① 수집 `adapters/`(쇼핑몰 하나 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄) + `sync.py`(공통 동기화, 같은 쇼핑몰 동시 실행 차단, 쇼핑몰별 실패 격리) ② 보안 `security/`(AES-256-GCM, 키 버전, 비밀값 가리기) + `credentials.py` ③ 계산 `calc.py`(주=월~일, 수수료 반올림은 `commission()` 한 곳, 요율 이력) + `db.py` ④ 화면 `dashboard.py`/`router.py`/템플릿. 쇼핑몰 API 인증정보는 `.env` 가 아니라 **설정 화면에서 입력 → 마스터 키 `APP_ENCRYPTION_KEY` 로 암호화해 DB 저장**, secret 원문은 화면으로 다시 보내지 않는다. 쇼핑몰 API 는 백엔드에서만 호출, 오류·로그·raw 는 `redact` 후 저장. 매출 기준일: 결제=결제일, 취소·반품=발생일(`sync.sales_date_for`). 금액은 원 단위 정수. 권한키 `performance`, 설정 화면·API 는 `is_admin`. 카페24 어댑터는 기존 `app/integrations/cafe24` 토큰 재사용. 1단계는 모의 데이터(`is_sample`)·구조까지, 실제 수집은 쇼핑몰별로 공식 문서 확인 후 순차 구현. 상세는 `docs/PERFORMANCE_MODULE.md` + 상세는 `docs/PROJECT_OVERVIEW.md`. --- diff --git a/app/main.py b/app/main.py index 38265b7..2942522 100644 --- a/app/main.py +++ b/app/main.py @@ -24,6 +24,8 @@ from .modules.expense import CategoryStore, build_expense_store from .modules.expense import router as expense_router from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store from .modules.malaysia import router as malaysia_router +from .modules.performance import build_performance_store +from .modules.performance import router as performance_router from .modules.project import build_project_store from .modules.project import router as project_router from .modules.vacation import build_vacation_store @@ -49,6 +51,7 @@ MODULE_LABELS: dict[str, str] = { "dispatch": "말레이시아 배송", "project": "프로젝트 관리", "cafe24": "카페24 상품관리", + "performance": "실적", "expense_approver": "개인경비", "vacation_approver": "휴가", } @@ -136,6 +139,7 @@ _MODULE_TEMPLATE_DIRS = [ BASE_DIR / "modules" / "dispatch" / "templates", BASE_DIR / "modules" / "project" / "templates", BASE_DIR / "modules" / "cafe24" / "templates", + BASE_DIR / "modules" / "performance" / "templates", ] templates = Jinja2Templates(directory=str(BASE_DIR / "templates")) templates.env.loader = ChoiceLoader( @@ -195,6 +199,9 @@ app.state.project_store = build_project_store(dsn=env("PROJECT_DB_URL") or None) # 카페24 상품관리: CAFE24_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내). # 카페24 API 호출/토큰은 app/integrations/cafe24 공통 계층(CAFE24_* 환경변수). app.state.cafe24_store = build_cafe24_store(dsn=env("CAFE24_DB_URL") or None) +# 실적(쇼핑몰 통합 매출): PERFORMANCE_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내). +# 쇼핑몰 API 인증정보는 설정 화면에서 입력 → APP_ENCRYPTION_KEY 로 암호화해 performance_db 에 저장. +app.state.performance_store = build_performance_store(dsn=env("PERFORMANCE_DB_URL") or None) # 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄. app.include_router(expense_router) @@ -204,6 +211,7 @@ app.include_router(malaysia_router) app.include_router(dispatch_router) app.include_router(project_router) app.include_router(cafe24_router) +app.include_router(performance_router) def public_url_for(request: Request, route_name: str) -> str: @@ -386,6 +394,16 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]: "status": "ready", "category": "운영", }, + { + "key": "performance", + "title": "실적", + "subtitle": "Sales Performance", + "description": "여러 쇼핑몰의 매출을 일자·쇼핑몰별로 한 화면에서 보고 수수료 차감 매출을 계산합니다.", + "url": "/performance/", + "health_url": "/performance/health", + "status": "ready", + "category": "관리", + }, ] allowed = allowed_modules(user_rec) for item in items: @@ -406,6 +424,7 @@ def _icon_svg(name: str) -> str: "dispatch": '', "project": '', "cafe24": '', + "performance": '', "modules": '', } body = paths.get(name, paths["modules"]) diff --git a/app/modules/performance/__init__.py b/app/modules/performance/__init__.py new file mode 100644 index 0000000..1696368 --- /dev/null +++ b/app/modules/performance/__init__.py @@ -0,0 +1,25 @@ +"""실적(쇼핑몰 통합 매출) 모듈. + +네 영역을 분리해 둔다(쇼핑몰 하나를 추가할 때 어댑터 파일 하나만 늘어나게). + ① 쇼핑몰 API 수집 adapters/ (쇼핑몰별 어댑터) + sync.py (공통 동기화 서비스) + ② 인증정보·보안 security/ (AES-256-GCM, 비밀값 가리기) + credentials.py + ③ 매출 계산/저장 calc.py (기간·수수료·집계) + db.py (performance_db) + ④ 대시보드/UI dashboard.py (화면 데이터 조립) + router.py + templates/performance/ + +데이터 저장은 performance_db 전용이다. PERFORMANCE_DB_URL 미설정 시 +build_performance_store 는 None 을 반환하고 라우터가 "설정 필요" 안내를 보여 준다(앱은 죽지 않음). +""" + +from typing import Any + +from .router import router + +__all__ = ["router", "build_performance_store"] + + +def build_performance_store(*, dsn: str | None) -> Any: + if not dsn: + return None + from .db import PerformanceDBStore # 지연 import (개발 환경 deps 없을 수 있음) + + return PerformanceDBStore(dsn) diff --git a/app/modules/performance/adapters/__init__.py b/app/modules/performance/adapters/__init__.py new file mode 100644 index 0000000..13892b6 --- /dev/null +++ b/app/modules/performance/adapters/__init__.py @@ -0,0 +1,5 @@ +"""① 쇼핑몰 API 수집 — 쇼핑몰별 어댑터(공통 인터페이스는 base.py, 목록은 registry.py).""" + +from .registry import all_adapters, get_adapter + +__all__ = ["all_adapters", "get_adapter"] diff --git a/app/modules/performance/adapters/base.py b/app/modules/performance/adapters/base.py new file mode 100644 index 0000000..15e2396 --- /dev/null +++ b/app/modules/performance/adapters/base.py @@ -0,0 +1,215 @@ +"""① 쇼핑몰 API 수집 — 공통 인터페이스. + +쇼핑몰 하나 = 어댑터 파일 하나. 새 쇼핑몰은 `MarketplaceAdapter` 를 상속한 파일을 +만들고 `registry.py` 에 한 줄 추가하면 설정 화면·동기화·대시보드에 자동으로 붙는다. + +흐름: 쇼핑몰 원본 → 어댑터(fetch_* → normalize_*) → 공통 SaleEvent → sync 서비스가 DB 저장 + +어댑터가 지켜야 할 것: + - 인증정보는 `ctx.credentials.get(key)` 로만 꺼낸다(복호화는 서버 안에서만). + - 새 토큰은 `ctx.credentials.set(key, value)` 로 저장한다(자동 암호화). + - 오류는 아래 AdapterError 계열로 던진다. 메시지에 비밀값을 넣지 않는다 + (sync 서비스가 한 번 더 가리지만, 애초에 넣지 않는 것이 원칙). + - 금액은 원 단위 정수(int). 결제는 +, 취소/반품은 − 로 만든다. + - 날짜 기준을 섞지 않는다: order_date / payment_date / event_date 를 각각 채운다. + 집계 기준일(sales_date)은 sync 서비스가 정한다(결제=결제일, 취소·반품=발생일). +""" + +from __future__ import annotations + +from abc import ABC +from dataclasses import dataclass, field +from datetime import date +from typing import Any, Iterable, Protocol + +# 연결 상태 코드 → 화면 표시. DB CHECK 제약과 같은 목록. +STATUS_LABELS: dict[str, str] = { + "ok": "정상 연결", + "not_configured": "인증정보 미설정", + "auth_failed": "인증 실패", + "token_expired": "Token 만료", + "api_error": "API 오류", + "not_implemented": "연동 준비 중", + "unknown": "확인 전", + "disabled": "사용 중지", # DB 에는 저장하지 않는 화면 전용 상태(쇼핑몰 사용 OFF) +} + +EVENT_TYPES = ("SALE", "CANCEL", "RETURN", "ADJUST") + + +# ════════════════════════════════════════════════════════════ +# 오류 — status 가 곧 연결 상태 코드 +# ════════════════════════════════════════════════════════════ +class AdapterError(Exception): + status = "api_error" + + def __init__(self, message: str = "") -> None: + super().__init__(message or STATUS_LABELS.get(self.status, "오류")) + self.message = message or STATUS_LABELS.get(self.status, "오류") + + +class NotConfigured(AdapterError): + status = "not_configured" + + +class AuthFailed(AdapterError): + status = "auth_failed" + + +class TokenExpired(AdapterError): + status = "token_expired" + + +class ApiError(AdapterError): + status = "api_error" + + +class NotImplementedYet(AdapterError): + status = "not_implemented" + + +# ════════════════════════════════════════════════════════════ +# 설정 입력칸 · 공통 매출 사건 +# ════════════════════════════════════════════════════════════ +@dataclass(frozen=True) +class CredentialField: + """설정 화면 입력칸 하나. secret=True 면 저장 후 값을 화면으로 다시 보내지 않는다. + + internal=True 는 화면에 안 보이는 내부 값(access/refresh token 등) — 어댑터가 직접 저장. + """ + + key: str + label: str + secret: bool = False + required: bool = True + help: str = "" + placeholder: str = "" + internal: bool = False + + +@dataclass +class SaleEvent: + """쇼핑몰 원본을 공통 형식으로 바꾼 매출 사건 하나(주문 라인 단위 권장).""" + + event_type: str # SALE / CANCEL / RETURN / ADJUST + external_event_id: str # 쇼핑몰 안에서 이 사건을 유일하게 가리키는 값(중복 방지 키) + external_order_id: str + event_date: date # 사건 발생일(결제=결제일, 취소=취소일, 반품=반품완료일) + amount: int # 원 단위 정수. 결제 +, 취소/반품 − + external_line_id: str = "" + order_date: date | None = None + payment_date: date | None = None + product_name: str = "" + option_name: str = "" + quantity: int = 0 + discount_amount: int = 0 + order_status: str = "" + raw: dict[str, Any] = field(default_factory=dict) + + def validate(self) -> None: + if self.event_type not in EVENT_TYPES: + raise ValueError(f"알 수 없는 사건 종류: {self.event_type}") + if not self.external_event_id or not self.external_order_id: + raise ValueError("external_event_id / external_order_id 가 필요합니다.") + if not isinstance(self.amount, int) or isinstance(self.amount, bool): + raise ValueError("amount 는 원 단위 정수여야 합니다.") + if self.event_type == "SALE" and self.amount < 0: + raise ValueError("결제(SALE) 금액은 음수일 수 없습니다.") + if self.event_type in ("CANCEL", "RETURN") and self.amount > 0: + raise ValueError("취소/반품 금액은 음수(또는 0)여야 합니다.") + + +class CredentialAccessor(Protocol): + def get(self, key: str) -> str: ... + + def set(self, key: str, value: str) -> None: ... + + def has(self, key: str) -> bool: ... + + +@dataclass +class AdapterContext: + code: str + credentials: CredentialAccessor + app_state: Any = None # 공통 연동 계층 재사용(예: 카페24 토큰 저장소) + timeout_sec: float = 20.0 + + +# ════════════════════════════════════════════════════════════ +# 어댑터 +# ════════════════════════════════════════════════════════════ +class MarketplaceAdapter(ABC): + code: str = "" + name: str = "" + auth_type: str = "api_key" # api_key / oauth / shared(공통 연동 계층 재사용) + docs_url: str = "" + implemented: bool = False # 실제 수집(fetch)이 구현됐는가 + note: str = "" # 설정 화면 안내 문구 + + # ── 설정 ────────────────────────────────────────────── + def credential_fields(self) -> list[CredentialField]: + return [] + + def visible_fields(self) -> list[CredentialField]: + return [f for f in self.credential_fields() if not f.internal] + + @property + def uses_shared_integration(self) -> bool: + return self.auth_type == "shared" + + def validate_credentials(self, values: dict[str, str]) -> list[str]: + """저장 전 검사. 값 자체를 오류 문구에 넣지 않는다.""" + errors: list[str] = [] + for f in self.visible_fields(): + v = (values.get(f.key) or "").strip() + if f.required and not v: + errors.append(f"{f.label} 을(를) 입력하세요.") + elif v and len(v) > 2000: + errors.append(f"{f.label} 값이 너무 깁니다.") + return errors + + def is_configured(self, ctx: AdapterContext) -> bool: + return all(ctx.credentials.has(f.key) for f in self.visible_fields() if f.required) + + # ── 인증 ────────────────────────────────────────────── + def authenticate(self, ctx: AdapterContext) -> None: + """API 호출 전 준비(토큰 발급 등). 기본은 할 일 없음.""" + if not self.is_configured(ctx): + raise NotConfigured("필수 인증정보가 입력되지 않았습니다.") + + def refresh_token(self, ctx: AdapterContext) -> None: + """OAuth 쇼핑몰: refresh token 으로 access token 재발급 후 ctx.credentials.set(...).""" + return None + + def test_connection(self, ctx: AdapterContext) -> str: + """성공 시 사람이 읽을 짧은 문구 반환. 실패는 AdapterError.""" + self.authenticate(ctx) + raise NotImplementedYet(f"{self.name} API 연동은 다음 단계에서 구현됩니다.") + + # ── 수집 ────────────────────────────────────────────── + def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + raise NotImplementedYet(f"{self.name} 주문 수집은 다음 단계에서 구현됩니다.") + + def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + return [] + + def normalize_order(self, raw: dict[str, Any]) -> list[SaleEvent]: + raise NotImplementedYet(f"{self.name} 주문 변환은 다음 단계에서 구현됩니다.") + + def normalize_refund(self, raw: dict[str, Any]) -> list[SaleEvent]: + return [] + + def collect(self, ctx: AdapterContext, start: date, end: date) -> tuple[int, list[SaleEvent]]: + """기간의 주문·취소/반품을 받아 공통 사건으로 변환. (원본 건수, 사건 목록).""" + self.authenticate(ctx) + fetched = 0 + events: list[SaleEvent] = [] + for raw in self.fetch_orders(ctx, start, end): + fetched += 1 + events.extend(self.normalize_order(raw)) + for raw in self.fetch_refunds(ctx, start, end): + fetched += 1 + events.extend(self.normalize_refund(raw)) + for ev in events: + ev.validate() + return fetched, events diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py new file mode 100644 index 0000000..d931d8e --- /dev/null +++ b/app/modules/performance/adapters/cafe24.py @@ -0,0 +1,49 @@ +"""카페24 — 공통 연동 계층(app/integrations/cafe24) 재사용. + +카페24는 이미 OAuth 로 연결해 쓰고 있다(상품관리). 실적 설정에서 인증정보를 따로 +받지 않고, 같은 토큰 저장소(cafe24_db)의 연결 상태를 그대로 보여 준다. +주문 수집(다음 단계)에는 카페24 앱 권한에 mall.read_order 추가 + 재연결이 필요하다 +(app/integrations/cafe24/config.py 의 ORDER_SCOPES). +""" + +from __future__ import annotations + +from .base import AdapterContext, AuthFailed, MarketplaceAdapter, NotConfigured, TokenExpired + + +class Cafe24Adapter(MarketplaceAdapter): + code = "cafe24" + name = "카페24" + auth_type = "shared" + docs_url = "https://developers.cafe24.com/docs/api/admin/" + note = "카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음)." + + def is_configured(self, ctx: AdapterContext) -> bool: + return True + + def authenticate(self, ctx: AdapterContext) -> None: + st = self.shared_status(ctx) + if not st.get("connected"): + if st.get("missing"): + raise NotConfigured("카페24 연동 환경변수가 설정되지 않았습니다.") + if st.get("needs_reauth") and st.get("reason", "").startswith("refresh"): + raise TokenExpired("카페24 연결이 만료되었습니다. 카페24 상품관리 → 시스템에서 재연결하세요.") + raise AuthFailed("카페24에 연결되어 있지 않습니다. 카페24 상품관리 → 시스템에서 연결하세요.") + + def shared_status(self, ctx: AdapterContext) -> dict: + from app.integrations.cafe24.config import load_config # 지연 import + from app.integrations.cafe24.tokens import TokenService # 지연 import + + repo = getattr(ctx.app_state, "cafe24_store", None) if ctx.app_state is not None else None + config = load_config() + if repo is None: + return {"connected": False, "missing": config.missing or ["CAFE24_DB_URL"], "needs_reauth": False} + return TokenService(repo, config).status() + + def test_connection(self, ctx: AdapterContext) -> str: + self.authenticate(ctx) + st = self.shared_status(ctx) + scopes = st.get("scopes") or "" + if "mall.read_order" not in scopes: + return "카페24 연결 정상. 주문 수집에는 주문 읽기 권한(mall.read_order) 추가가 필요합니다." + return "카페24 연결 정상." diff --git a/app/modules/performance/adapters/coupang.py b/app/modules/performance/adapters/coupang.py new file mode 100644 index 0000000..b6725e2 --- /dev/null +++ b/app/modules/performance/adapters/coupang.py @@ -0,0 +1,24 @@ +"""쿠팡 — 쿠팡 윙(마켓플레이스) Open API. + +인증: Vendor ID + Access Key + Secret Key 로 요청마다 HMAC 서명(CEA 헤더). +로켓(공급) 매출은 기존 쿠팡 밀크런 모듈의 cupang_sales 에 있다 — 필요 시 별도 연계. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class CoupangAdapter(MarketplaceAdapter): + code = "coupang" + name = "쿠팡" + auth_type = "api_key" + docs_url = "https://developers.coupangcorp.com/" + note = "쿠팡 윙 → 판매자정보 → 추가판매정보 → OPEN API 키 발급에서 확인합니다." + + 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), + ] diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py new file mode 100644 index 0000000..2eb8b3b --- /dev/null +++ b/app/modules/performance/adapters/elevenst.py @@ -0,0 +1,21 @@ +"""11번가 — 11번가 셀러 오픈API. + +인증: 셀러오피스에서 발급한 Open API Key 를 요청 헤더(openapikey)에 넣는다. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class ElevenstAdapter(MarketplaceAdapter): + code = "elevenst" + name = "11번가" + auth_type = "api_key" + docs_url = "https://openapi.11st.co.kr/" + note = "11번가 셀러오피스 → 오픈API 에서 발급한 키를 입력합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("api_key", "Open API Key", secret=True), + ] diff --git a/app/modules/performance/adapters/gmarket.py b/app/modules/performance/adapters/gmarket.py new file mode 100644 index 0000000..8da5d05 --- /dev/null +++ b/app/modules/performance/adapters/gmarket.py @@ -0,0 +1,23 @@ +"""G마켓 — ESM(ESM Plus / ESM Trading API). + +인증: ESM 마스터 ID + 판매자 ID + 발급 Secret Key 로 JWT 서명(연동 단계에서 확정). +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class GmarketAdapter(MarketplaceAdapter): + code = "gmarket" + name = "G마켓" + auth_type = "api_key" + docs_url = "https://etapi.gmarket.com/" + note = "ESM Plus 에서 발급한 API 인증정보를 입력합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("master_id", "ESM 마스터 ID"), + CredentialField("seller_id", "G마켓 판매자 ID"), + CredentialField("secret_key", "Secret Key", secret=True), + ] diff --git a/app/modules/performance/adapters/gsshop.py b/app/modules/performance/adapters/gsshop.py new file mode 100644 index 0000000..ecf48bc --- /dev/null +++ b/app/modules/performance/adapters/gsshop.py @@ -0,0 +1,21 @@ +"""GS샵 — 협력사 API. + +인증 방식·필드는 연동 단계에서 공식 문서로 확정한다. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class GsshopAdapter(MarketplaceAdapter): + code = "gsshop" + name = "GS샵" + auth_type = "api_key" + note = "입력 항목은 연동 단계에서 GS샵 협력사 API 문서로 확정합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("vendor_code", "협력사 코드"), + CredentialField("api_key", "API Key", secret=True), + ] diff --git a/app/modules/performance/adapters/kakao.py b/app/modules/performance/adapters/kakao.py new file mode 100644 index 0000000..5a9de56 --- /dev/null +++ b/app/modules/performance/adapters/kakao.py @@ -0,0 +1,21 @@ +"""카카오 — 카카오쇼핑(톡스토어) 판매자 API. + +인증 방식·필드는 연동 단계에서 공식 문서로 확정한다. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class KakaoAdapter(MarketplaceAdapter): + code = "kakao" + name = "카카오" + auth_type = "api_key" + note = "입력 항목은 연동 단계에서 카카오쇼핑 판매자 API 문서로 확정합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("seller_id", "판매자(채널) ID"), + CredentialField("api_key", "API Key", secret=True), + ] diff --git a/app/modules/performance/adapters/lotteon.py b/app/modules/performance/adapters/lotteon.py new file mode 100644 index 0000000..90c6a62 --- /dev/null +++ b/app/modules/performance/adapters/lotteon.py @@ -0,0 +1,21 @@ +"""롯데ON — 롯데ON 판매자 API. + +인증: 거래처번호 + 발급 API Key(연동 단계에서 확정). +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class LotteonAdapter(MarketplaceAdapter): + code = "lotteon" + name = "롯데ON" + auth_type = "api_key" + note = "롯데ON 스토어센터에서 발급한 API 인증정보를 입력합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("trade_no", "거래처번호"), + CredentialField("api_key", "API Key", secret=True), + ] diff --git a/app/modules/performance/adapters/mock.py b/app/modules/performance/adapters/mock.py new file mode 100644 index 0000000..15b1472 --- /dev/null +++ b/app/modules/performance/adapters/mock.py @@ -0,0 +1,63 @@ +"""테스트(모의) 매출 데이터 — 실제 API 연동 전 화면 확인용. + +같은 (쇼핑몰, 날짜)면 항상 같은 값이 나온다(재현 가능). 결제뿐 아니라 전체 취소· +부분 반품도 섞어 넣어 음수 반영과 합계를 확인할 수 있게 한다. +DB 에는 is_sample=TRUE 로 들어가며 설정 화면에서 한 번에 지울 수 있다. +""" + +from __future__ import annotations + +import random +from datetime import date, timedelta + +from .base import SaleEvent + +# 쇼핑몰별 하루 평균 주문 건수(모의값) — 화면에 차이가 보이도록만 다르게 둔다. +_DAILY_ORDERS = { + "cafe24": 9, "naver": 14, "coupang": 18, "ohouse": 4, "gmarket": 6, + "kakao": 3, "gsshop": 2, "elevenst": 4, "lotteon": 2, "toss": 1, +} +_PRODUCTS = ( + ("스테인리스 냄비 20cm", 39_000), ("프라이팬 28cm", 45_900), ("밀폐용기 5종 세트", 29_800), + ("도마 대형", 19_900), ("칼 블록 세트", 89_000), ("주방 가위", 12_900), + ("냄비 받침", 8_900), ("전골 냄비", 59_000), +) + + +def generate(code: str, start: date, end: date) -> list[SaleEvent]: + events: list[SaleEvent] = [] + base = _DAILY_ORDERS.get(code, 3) + d = start + while d <= end: + rng = random.Random(f"perf-sample:{code}:{d.isoformat()}") + weekend = d.weekday() >= 5 + n = max(0, int(rng.gauss(base * (0.7 if weekend else 1.0), base * 0.35))) + for i in range(n): + name, price = rng.choice(_PRODUCTS) + qty = 1 if rng.random() < 0.8 else rng.randint(2, 3) + discount = rng.choice((0, 0, 0, 1000, 2000, 3000)) + amount = max(0, price * qty - discount) + order_id = f"SAMPLE-{code}-{d:%Y%m%d}-{i:03d}" + events.append(SaleEvent( + event_type="SALE", external_event_id=f"{order_id}-S", external_order_id=order_id, + external_line_id="1", order_date=d, payment_date=d, event_date=d, amount=amount, + product_name=name, quantity=qty, discount_amount=discount, order_status="결제완료", + raw={"sample": True}, + )) + roll = rng.random() + if roll < 0.05: # 전체 취소(당일~2일 뒤) + cd = min(end, d + timedelta(days=rng.randint(0, 2))) + events.append(SaleEvent( + event_type="CANCEL", external_event_id=f"{order_id}-C", external_order_id=order_id, + external_line_id="1", order_date=d, payment_date=d, event_date=cd, amount=-amount, + product_name=name, quantity=-qty, order_status="취소완료", raw={"sample": True}, + )) + elif roll < 0.08 and qty > 1: # 부분 반품(1개, 3~7일 뒤) + rd = min(end, d + timedelta(days=rng.randint(3, 7))) + events.append(SaleEvent( + event_type="RETURN", external_event_id=f"{order_id}-R", external_order_id=order_id, + external_line_id="1", order_date=d, payment_date=d, event_date=rd, amount=-price, + product_name=name, quantity=-1, order_status="반품완료", raw={"sample": True}, + )) + d += timedelta(days=1) + return events diff --git a/app/modules/performance/adapters/naver.py b/app/modules/performance/adapters/naver.py new file mode 100644 index 0000000..48ee782 --- /dev/null +++ b/app/modules/performance/adapters/naver.py @@ -0,0 +1,27 @@ +"""네이버 스마트스토어 — 네이버 커머스API. + +인증: 애플리케이션 ID + 시크릿으로 전자서명(bcrypt) → OAuth2 client_credentials 토큰. +토큰은 발급받아 암호화 저장하고 만료 시 재발급한다(다음 단계에서 구현). +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class NaverAdapter(MarketplaceAdapter): + code = "naver" + name = "네이버 스마트스토어" + auth_type = "oauth" + docs_url = "https://apicenter.commerce.naver.com/" + note = "커머스API센터에서 발급한 애플리케이션 ID/시크릿을 입력합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("client_id", "애플리케이션 ID(Client ID)"), + CredentialField("client_secret", "애플리케이션 시크릿(Client Secret)", secret=True), + CredentialField("account_id", "판매자 ID", required=False, + help="판매자 계정 지정이 필요한 경우에만 입력"), + CredentialField("access_token", "Access Token", secret=True, required=False, internal=True), + CredentialField("access_token_expires_at", "Access Token 만료", required=False, internal=True), + ] diff --git a/app/modules/performance/adapters/ohouse.py b/app/modules/performance/adapters/ohouse.py new file mode 100644 index 0000000..eeee1a4 --- /dev/null +++ b/app/modules/performance/adapters/ohouse.py @@ -0,0 +1,22 @@ +"""오늘의집 — 파트너(판매자) API. + +인증 방식·필드는 연동 단계에서 오늘의집 파트너 API 문서로 확정한다. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class OhouseAdapter(MarketplaceAdapter): + code = "ohouse" + name = "오늘의집" + auth_type = "api_key" + note = "입력 항목은 연동 단계에서 오늘의집 파트너 API 문서로 확정합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("seller_id", "판매자 ID"), + CredentialField("api_key", "API Key", secret=True), + CredentialField("api_secret", "API Secret", secret=True, required=False), + ] diff --git a/app/modules/performance/adapters/registry.py b/app/modules/performance/adapters/registry.py new file mode 100644 index 0000000..8bf78de --- /dev/null +++ b/app/modules/performance/adapters/registry.py @@ -0,0 +1,41 @@ +"""쇼핑몰 어댑터 목록 — 새 쇼핑몰은 여기 한 줄 + 어댑터 파일 하나. + +DB(perf_marketplaces)에 행이 없으면 설정 화면에서 쓸 수 없으므로, 새 쇼핑몰을 +추가할 때는 scripts/sql 의 seed(INSERT … ON CONFLICT DO NOTHING)에도 한 줄 넣는다. +""" + +from __future__ import annotations + +from .base import MarketplaceAdapter +from .cafe24 import Cafe24Adapter +from .coupang import CoupangAdapter +from .elevenst import ElevenstAdapter +from .gmarket import GmarketAdapter +from .gsshop import GsshopAdapter +from .kakao import KakaoAdapter +from .lotteon import LotteonAdapter +from .naver import NaverAdapter +from .ohouse import OhouseAdapter +from .toss import TossAdapter + +_ADAPTERS: tuple[MarketplaceAdapter, ...] = ( + Cafe24Adapter(), + NaverAdapter(), + CoupangAdapter(), + OhouseAdapter(), + GmarketAdapter(), + KakaoAdapter(), + GsshopAdapter(), + ElevenstAdapter(), + LotteonAdapter(), + TossAdapter(), +) +_BY_CODE = {a.code: a for a in _ADAPTERS} + + +def all_adapters() -> tuple[MarketplaceAdapter, ...]: + return _ADAPTERS + + +def get_adapter(code: str) -> MarketplaceAdapter | None: + return _BY_CODE.get(code) diff --git a/app/modules/performance/adapters/toss.py b/app/modules/performance/adapters/toss.py new file mode 100644 index 0000000..e525156 --- /dev/null +++ b/app/modules/performance/adapters/toss.py @@ -0,0 +1,22 @@ +"""토스쇼핑 — 판매자 API. + +인증 방식·필드는 연동 단계에서 공식 문서로 확정한다. +""" + +from __future__ import annotations + +from .base import CredentialField, MarketplaceAdapter + + +class TossAdapter(MarketplaceAdapter): + code = "toss" + name = "토스쇼핑" + auth_type = "api_key" + note = "입력 항목은 연동 단계에서 토스쇼핑 판매자 API 문서로 확정합니다." + + def credential_fields(self) -> list[CredentialField]: + return [ + CredentialField("seller_id", "판매자 ID"), + CredentialField("api_key", "API Key", secret=True), + CredentialField("api_secret", "API Secret", secret=True, required=False), + ] diff --git a/app/modules/performance/calc.py b/app/modules/performance/calc.py new file mode 100644 index 0000000..16d5617 --- /dev/null +++ b/app/modules/performance/calc.py @@ -0,0 +1,305 @@ +"""③ 매출 계산 — 기간/주 계산, 수수료·반올림, 표·KPI 집계. DB·HTTP 와 무관한 순수 함수. + +금액 규칙 + - 모든 금액은 원 단위 정수(int). 부동소수점을 쓰지 않는다(수수료율만 Decimal). + - 수수료 = round_half_up(해당 일 쇼핑몰 매출 합계 × 그날 유효한 수수료율 / 100). + 반올림은 `commission()` 한 곳에서만 한다. 취소/반품(음수)도 같은 규칙(0 에서 먼 쪽). + - 수수료 차감 매출 = 총매출 − 수수료. + - 수수료율은 이력(적용 시작일)으로 관리한다. 어떤 날의 요율 = 그날 이전(포함) 가장 최근 + 적용 시작일의 요율. 첫 요율보다 이전 날짜는 0%. + +주 = 월요일 ~ 일요일. +""" + +from __future__ import annotations + +import calendar +from dataclasses import dataclass +from datetime import date, timedelta +from decimal import ROUND_HALF_UP, Decimal +from typing import Iterable, Mapping, Sequence + +WEEKDAYS_KO = ("월", "화", "수", "목", "금", "토", "일") +PERIOD_KINDS = ("day", "week", "month", "year", "custom") +MAX_CUSTOM_DAYS = 366 + + +# ════════════════════════════════════════════════════════════ +# 금액 +# ════════════════════════════════════════════════════════════ +def commission(amount: int, rate_percent: Decimal) -> int: + """수수료(원). 반올림 기준은 이 함수 한 곳 — ROUND_HALF_UP(0.5 는 0 에서 먼 쪽).""" + if not amount or not rate_percent: + return 0 + value = Decimal(int(amount)) * Decimal(rate_percent) / Decimal(100) + return int(value.quantize(Decimal(1), rounding=ROUND_HALF_UP)) + + +@dataclass +class Money: + gross: int = 0 + commission: int = 0 + + @property + def net(self) -> int: + return self.gross - self.commission + + def add(self, other: "Money") -> "Money": + self.gross += other.gross + self.commission += other.commission + return self + + def as_dict(self) -> dict[str, int]: + return {"gross": self.gross, "commission": self.commission, "net": self.net} + + +def total(items: Iterable[Money]) -> Money: + out = Money() + for m in items: + out.add(m) + return out + + +RateTable = Mapping[str, Sequence[tuple[date, Decimal]]] # 쇼핑몰 → [(적용 시작일, 요율%)] 오름차순 + + +def rate_on(rates: RateTable, code: str, d: date) -> Decimal: + current = Decimal(0) + for eff, rate in rates.get(code, ()): + if eff <= d: + current = Decimal(rate) + else: + break + return current + + +def build_cells(daily_amounts: Mapping[tuple[date, str], int], rates: RateTable) -> dict[tuple[date, str], Money]: + """(날짜, 쇼핑몰) → 그날 매출 합계로 Money 를 만든다(수수료는 그날 요율).""" + return { + (d, code): Money(gross=int(amt), commission=commission(int(amt), rate_on(rates, code, d))) + for (d, code), amt in daily_amounts.items() + } + + +def pct_change(current: int, previous: int) -> float | None: + """증감률(%). 비교 대상이 0 이하이면 의미 없는 값 대신 None.""" + if previous <= 0: + return None + return round((current - previous) / previous * 100, 1) + + +# ════════════════════════════════════════════════════════════ +# 기간 +# ════════════════════════════════════════════════════════════ +def week_start(d: date) -> date: + return d - timedelta(days=d.weekday()) + + +def month_end(d: date) -> date: + return d.replace(day=calendar.monthrange(d.year, d.month)[1]) + + +def _add_months(d: date, n: int) -> date: + y, m = divmod(d.month - 1 + n, 12) + year, month = d.year + y, m + 1 + return date(year, month, min(d.day, calendar.monthrange(year, month)[1])) + + +def fmt_md(d: date) -> str: + return f"{d.month}/{d.day}" + + +def day_label(d: date) -> str: + return f"{WEEKDAYS_KO[d.weekday()]} {fmt_md(d)}" + + +@dataclass +class Period: + kind: str + anchor: date + start: date + end: date + label: str + prev_anchor: date + next_anchor: date + prev_label: str + next_label: str + + @property + def days(self) -> int: + return (self.end - self.start).days + 1 + + def compare_range(self, today: date) -> tuple[date, date, str]: + """직전 같은 길이 기간. 진행 중인 기간이면 같은 경과일수까지만(공정한 비교).""" + length = self.days + prev_start = self.start - timedelta(days=length) + if self.kind == "month": + prev_start = _add_months(self.start, -1) + elif self.kind == "year": + prev_start = self.start.replace(year=self.start.year - 1) + in_progress = self.start <= today < self.end + if in_progress: + elapsed = (today - self.start).days + prev_end = prev_start + timedelta(days=elapsed) + if self.kind == "month": + prev_end = min(prev_end, month_end(prev_start)) + note = "같은 기간" + else: + if self.kind == "month": + prev_end = month_end(prev_start) + elif self.kind == "year": + prev_end = prev_start.replace(month=12, day=31) + else: + prev_end = self.start - timedelta(days=1) + note = "" + unit = {"day": "전일", "week": "전주", "month": "전월", "year": "전년"}.get(self.kind, "직전 기간") + return prev_start, prev_end, f"{unit} {note}".strip() + + +def resolve_period( + kind: str, + anchor: date, + *, + custom_from: date | None = None, + custom_to: date | None = None, +) -> Period: + kind = kind if kind in PERIOD_KINDS else "week" + if kind == "day": + return Period(kind, anchor, anchor, anchor, + f"{anchor.year}년 {anchor.month}월 {anchor.day}일 ({WEEKDAYS_KO[anchor.weekday()]})", + anchor - timedelta(days=1), anchor + timedelta(days=1), "전일", "다음날") + if kind == "week": + s = week_start(anchor) + e = s + timedelta(days=6) + label = (f"{s.year}년 {s.month}월 {s.day}일 ~ " + + (f"{e.year}년 " if e.year != s.year else "") + f"{e.month}월 {e.day}일") + return Period(kind, anchor, s, e, label, s - timedelta(days=7), s + timedelta(days=7), "이전주", "다음주") + if kind == "month": + s = anchor.replace(day=1) + return Period(kind, anchor, s, month_end(s), f"{s.year}년 {s.month}월", + _add_months(s, -1), _add_months(s, 1), "이전달", "다음달") + if kind == "year": + s = date(anchor.year, 1, 1) + return Period(kind, anchor, s, date(anchor.year, 12, 31), f"{anchor.year}년", + date(anchor.year - 1, 1, 1), date(anchor.year + 1, 1, 1), "이전해", "다음해") + # custom + s = custom_from or anchor + e = custom_to or s + if e < s: + s, e = e, s + if (e - s).days + 1 > MAX_CUSTOM_DAYS: + e = s + timedelta(days=MAX_CUSTOM_DAYS - 1) + length = (e - s).days + 1 + return Period("custom", s, s, e, f"{s.isoformat()} ~ {e.isoformat()}", + s - timedelta(days=length), e + timedelta(days=1), "이전", "다음") + + +def daterange(start: date, end: date) -> Iterable[date]: + d = start + while d <= end: + yield d + d += timedelta(days=1) + + +# ════════════════════════════════════════════════════════════ +# 집계 +# ════════════════════════════════════════════════════════════ +def sum_range(cells: Mapping[tuple[date, str], Money], codes: Sequence[str], start: date, end: date) -> Money: + wanted = set(codes) + out = Money() + for (d, code), m in cells.items(): + if code in wanted and start <= d <= end: + out.add(m) + return out + + +def by_code(cells: Mapping[tuple[date, str], Money], codes: Sequence[str], start: date, end: date) -> dict[str, Money]: + out = {c: Money() for c in codes} + for (d, code), m in cells.items(): + if code in out and start <= d <= end: + out[code].add(m) + return out + + +def _row(kind: str, label: str, per_code: dict[str, Money], **extra) -> dict: + return { + "kind": kind, + "label": label, + "cells": {c: m.as_dict() for c, m in per_code.items()}, + "total": total(per_code.values()).as_dict(), + **extra, + } + + +def main_table(period: Period, codes: Sequence[str], cells: Mapping[tuple[date, str], Money], + *, today: date, holidays: Mapping[str, str] | None = None) -> list[dict]: + """일자 × 쇼핑몰 표. 일 행 + 주간합계(일요일 뒤 / 기간 끝) + 기간 합계. + + 연간 보기는 일 대신 월 행(1~12월)으로 줄인다. + """ + holidays = holidays or {} + rows: list[dict] = [] + if period.kind == "year": + for m in range(1, 13): + s = date(period.start.year, m, 1) + e = month_end(s) + rows.append(_row("month", f"{m}월", by_code(cells, codes, s, e), future=s > today, + **{"from": s.isoformat(), "to": e.isoformat()})) + rows.append(_row("total", "연간 합계", by_code(cells, codes, period.start, period.end))) + return rows + + week_codes: dict[str, Money] = {c: Money() for c in codes} + for d in daterange(period.start, period.end): + per_code = {c: cells.get((d, c), Money()) for c in codes} + iso = d.isoformat() + rows.append(_row("day", day_label(d), per_code, date=iso, weekday=d.weekday(), + holiday=holidays.get(iso, ""), future=d > today, today=d == today, + **{"from": iso, "to": iso})) + for c in codes: + week_codes[c].add(per_code[c]) + if period.days > 1 and (d.weekday() == 6 or d == period.end): + ws = max(week_start(d), period.start) + label = "주간합계" if period.kind == "week" else f"주간합계 ({fmt_md(ws)}~{fmt_md(d)})" + rows.append(_row("week", label, week_codes, **{"from": ws.isoformat(), "to": d.isoformat()})) + week_codes = {c: Money() for c in codes} + if period.kind != "week" and period.days > 1: + rows.append(_row("total", "기간 합계", by_code(cells, codes, period.start, period.end))) + return rows + + +def month_summary(year: int, month: int, codes: Sequence[str], cells: Mapping[tuple[date, str], Money]) -> dict: + s = date(year, month, 1) + per = by_code(cells, codes, s, month_end(s)) + tot = total(per.values()) + rows = [] + for c in codes: + m = per[c] + share = round(m.gross / tot.gross * 100, 1) if tot.gross > 0 else None + rows.append({"code": c, **m.as_dict(), "share": share}) + rows.sort(key=lambda r: r["gross"], reverse=True) + return {"label": f"{year}년 {month}월", "rows": rows, + "total": {**tot.as_dict(), "share": 100.0 if tot.gross > 0 else None}} + + +def year_months(year: int, codes: Sequence[str], cells: Mapping[tuple[date, str], Money], *, today: date) -> dict: + rows = [] + for m in range(1, 13): + s = date(year, m, 1) + future = s > today + money = sum_range(cells, codes, s, month_end(s)) + rows.append({"month": m, "label": f"{m}월", "future": future, + **({"gross": None, "commission": None, "net": None} if future else money.as_dict())}) + tot = sum_range(cells, codes, date(year, 1, 1), date(year, 12, 31)) + return {"year": year, "rows": rows, "total": tot.as_dict()} + + +def daily_series(period: Period, codes: Sequence[str], cells: Mapping[tuple[date, str], Money]) -> list[dict]: + """일별 추이 그래프용. 연간은 월별.""" + if period.kind == "year": + out = [] + for m in range(1, 13): + s = date(period.start.year, m, 1) + out.append({"label": f"{m}월", **sum_range(cells, codes, s, month_end(s)).as_dict()}) + return out + return [{"label": fmt_md(d), "date": d.isoformat(), **sum_range(cells, codes, d, d).as_dict()} + for d in daterange(period.start, period.end)] diff --git a/app/modules/performance/common.py b/app/modules/performance/common.py new file mode 100644 index 0000000..606b01c --- /dev/null +++ b/app/modules/performance/common.py @@ -0,0 +1,126 @@ +"""실적 모듈 공용 가드/서비스 생성 — router.py 가 쓴다(순환 import 방지로 분리). + +권한(프론트에서 메뉴를 숨기는 것과 별개로 **서버에서** 항상 검사): + - 실적 대시보드/매출 업데이트/상세 조회 : 모듈 권한 `performance` (admin 은 자동) + - 실적 설정(수수료·API 인증정보·연결 테스트·테스트 데이터) : 관리자(is_admin)만 +""" + +from __future__ import annotations + +from typing import Any + +from fastapi import HTTPException, Request +from fastapi.responses import HTMLResponse, RedirectResponse + +MODULE_KEY = "performance" +MODULE_NAME = "실적" + +CONFIG_HELP = ( + "실적 모듈이 아직 설정되지 않았습니다. " + "scripts/sql/performance_db_init.sql 로 performance_db 를 만들고 " + "PERFORMANCE_DB_URL 환경변수를 설정한 뒤 컨테이너를 재기동하세요." +) + + +def get_store(request: Request) -> Any: + return getattr(request.app.state, "performance_store", None) + + +def key_ring(): + """마스터 키 — 호출할 때마다 환경변수에서 읽는다(DB 에는 없다).""" + from .security.crypto import KeyRing # noqa: WPS433 + + return KeyRing.from_env() + + +def key_status() -> dict[str, Any]: + """설정 화면용 — 키가 설정됐는지/버전만. 키 값은 절대 넣지 않는다.""" + from .security.crypto import CryptoConfigError # noqa: WPS433 + + try: + ring = key_ring() + except CryptoConfigError as exc: + return {"ok": False, "message": str(exc), "current_version": None, "versions": []} + return {"ok": True, "message": "", "current_version": ring.current_version, "versions": ring.versions} + + +def services(request: Request, store: Any): + """(CredentialService, SyncService).""" + from .credentials import CredentialService # noqa: WPS433 + from .sync import SyncService # noqa: WPS433 + + creds = CredentialService(store, key_ring) + return creds, SyncService(store, creds, app_state=request.app.state) + + +def require_user(request: Request) -> dict[str, Any]: + from app.main import get_current_user_record # noqa: WPS433 + from app.store import has_module # noqa: WPS433 + + user = get_current_user_record(request) + if user is None: + raise HTTPException(status_code=401, detail="로그인이 필요합니다.") + if not has_module(user, MODULE_KEY): + raise HTTPException(status_code=403, detail=f"{MODULE_NAME} 모듈 권한이 없습니다.") + return user + + +def require_admin(request: Request) -> dict[str, Any]: + from app.store import is_admin # noqa: WPS433 + + user = require_user(request) + if not is_admin(user): + raise HTTPException(status_code=403, detail="실적 설정은 관리자만 변경할 수 있습니다.") + return user + + +def require_store(request: Request, *, admin: bool = False) -> tuple[Any, dict[str, Any]]: + user = require_admin(request) if admin else require_user(request) + st = get_store(request) + if st is None: + raise HTTPException(status_code=503, detail=CONFIG_HELP) + return st, user + + +def guard(request: Request, *, admin: bool = False): + """페이지 진입부. tuple(store, user) 이 아니면 그대로 응답으로 돌려준다.""" + from app.main import get_current_user_record, render_template # noqa: WPS433 + from app.store import has_module, is_admin # noqa: WPS433 + + user = get_current_user_record(request) + if user is None: + return RedirectResponse(url="/login", status_code=303) + if not has_module(user, MODULE_KEY) or (admin and not is_admin(user)): + reason = "실적 설정은 관리자만 볼 수 있습니다." if admin else f"{MODULE_NAME} 접근 권한이 없습니다." + return render_template(request, "denied.html", + {"reason": reason, "user": user, "is_admin": is_admin(user)}, status_code=403) + st = get_store(request) + if st is None: + return render_config_needed(request, user) + return st, user + + +def render_config_needed(request: Request, user: dict[str, Any]) -> HTMLResponse: + from app.main import build_erp_nav, render_template # noqa: WPS433 + from app.store import is_admin # noqa: WPS433 + + return render_template( + request, "denied.html", + {"reason": CONFIG_HELP, "user": user, "is_admin": is_admin(user), + "nav_items": build_erp_nav(user, active=MODULE_KEY)}, + status_code=503, + ) + + +def base_ctx(user: dict[str, Any], *, active_tab: str, page_title: str = "실적") -> dict[str, Any]: + from app.main import build_erp_nav # noqa: WPS433 + from app.store import is_admin # noqa: WPS433 + + return { + "user": user, + "is_admin": is_admin(user), + "nav_items": build_erp_nav(user, active=MODULE_KEY), + "active_tab": active_tab, + "page_title": page_title, + "page_subtitle": "쇼핑몰 통합 매출", + } diff --git a/app/modules/performance/credentials.py b/app/modules/performance/credentials.py new file mode 100644 index 0000000..dd3da1c --- /dev/null +++ b/app/modules/performance/credentials.py @@ -0,0 +1,174 @@ +"""② 쇼핑몰 API 인증정보 — 저장(암호화) / 화면용 요약 / 어댑터용 복호화 접근자 / 재암호화. + +흐름: 설정 화면 입력 → 이 서비스(암호화) → perf_credentials(암호문) + 어댑터 → CredentialAccessor.get() → 서버 안에서만 복호화 + +화면으로 돌려주는 값 + - secret 항목: 값 있음/없음(has_value)만. 원문·일부·길이 모두 보내지 않는다. + - 일반 항목(Vendor ID 등): 확인용으로 원문을 보여 준다(이것도 DB 에는 암호문). +""" + +from __future__ import annotations + +from typing import Any, Callable + +from .adapters.base import MarketplaceAdapter +from .security.crypto import KeyRing, decrypt, encrypt, needs_reencrypt + + +def aad_for(code: str, key: str) -> str: + """암호문을 (쇼핑몰, 항목)에 묶는 추가 인증 데이터.""" + return f"perf:{code}:{key}" + + +class CredentialAccessor: + """어댑터 전용 — 서버 안에서만 복호화. 값은 처음 꺼낼 때 한 번 복호화해 둔다.""" + + def __init__(self, store: Any, code: str, ring_loader: Callable[[], KeyRing], *, + overrides: dict[str, str] | None = None, persist: bool = True, user: str = "") -> None: + self._store = store + self._code = code + self._ring_loader = ring_loader + self._rows = store.credential_rows(code) if store is not None else {} + self._cache: dict[str, str] = {} + self._overrides = {k: v for k, v in (overrides or {}).items() if v} + self._persist = persist + self._user = user + + def has(self, key: str) -> bool: + return bool(self._overrides.get(key)) or key in self._rows + + def get(self, key: str) -> str: + if key in self._overrides: + return self._overrides[key] + if key in self._cache: + return self._cache[key] + row = self._rows.get(key) + if not row: + return "" + value = decrypt(row["encrypted_value"], aad=aad_for(self._code, key), ring=self._ring_loader()) + self._cache[key] = value + return value + + def set(self, key: str, value: str) -> None: + """어댑터가 새로 받은 토큰 등을 저장. 테스트(persist=False)면 메모리에만.""" + self._cache[key] = value + if not self._persist or self._store is None: + return + ring = self._ring_loader() + self._store.upsert_credential( + self._code, key, encrypted_value=encrypt(value, aad=aad_for(self._code, key), ring=ring), + key_version=ring.current_version, user=self._user or "system", + ) + self._rows[key] = {"encrypted_value": "", "key_version": ring.current_version} + + def known_secrets(self) -> list[str]: + """가리기(redact)용 — 지금까지 꺼낸 원문들.""" + return [v for v in list(self._cache.values()) + list(self._overrides.values()) if v] + + +class CredentialService: + def __init__(self, store: Any, ring_loader: Callable[[], KeyRing]) -> None: + self._store = store + self._ring_loader = ring_loader + + def accessor(self, code: str, *, overrides: dict[str, str] | None = None, persist: bool = True, + user: str = "") -> CredentialAccessor: + return CredentialAccessor(self._store, code, self._ring_loader, overrides=overrides, + persist=persist, user=user) + + # ── 화면용 요약(비밀 원문 없음) ───────────────────────── + def describe(self, adapter: MarketplaceAdapter) -> dict[str, Any]: + rows = self._store.credential_rows(adapter.code) + fields = [] + decrypt_error = "" + for f in adapter.visible_fields(): + row = rows.get(f.key) + item: dict[str, Any] = { + "key": f.key, "label": f.label, "secret": f.secret, "required": f.required, + "help": f.help, "placeholder": f.placeholder, "has_value": row is not None, + "updated_at": row["updated_at"].isoformat(timespec="seconds") if row and row.get("updated_at") else "", + } + if row is not None and not f.secret: + try: + item["value"] = decrypt(row["encrypted_value"], aad=aad_for(adapter.code, f.key), + ring=self._ring_loader()) + except Exception as exc: # noqa: BLE001 — 키 없음/손상: 값 없이 안내만 + item["value"] = "" + decrypt_error = str(exc) if "환경변수" in str(exc) else "저장된 값을 복호화하지 못했습니다." + fields.append(item) + return {"fields": fields, "decrypt_error": decrypt_error, + "configured": all(x["has_value"] for x in fields if x["required"])} + + def configured_codes(self, adapters: list[MarketplaceAdapter]) -> dict[str, bool]: + keys = self._store.credential_keys_by_code() + out = {} + for a in adapters: + if a.uses_shared_integration: + out[a.code] = True + continue + have = keys.get(a.code, set()) + required = [f.key for f in a.visible_fields() if f.required] + out[a.code] = bool(required) and all(k in have for k in required) + return out + + # ── 저장 ──────────────────────────────────────────────── + def merged_values(self, adapter: MarketplaceAdapter, values: dict[str, str]) -> dict[str, str]: + """검사용 — 새 입력 + (빈 칸은) 기존 값 존재 여부. 비밀 원문은 꺼내지 않고 표식만.""" + rows = self._store.credential_rows(adapter.code) + merged = {} + for f in adapter.visible_fields(): + v = (values.get(f.key) or "").strip() + merged[f.key] = v if v else ("__stored__" if f.key in rows else "") + return merged + + def save(self, adapter: MarketplaceAdapter, values: dict[str, str], *, clear: list[str] | None = None, + user: str = "") -> list[str]: + """빈 칸 = 기존 값 유지. clear 에 든 항목은 삭제. 저장한 항목 키 목록 반환.""" + allowed = {f.key for f in adapter.visible_fields()} + ring = self._ring_loader() + saved = [] + for key, raw in values.items(): + if key not in allowed: + continue + v = (raw or "").strip() + if not v: + continue + self._store.upsert_credential( + adapter.code, key, encrypted_value=encrypt(v, aad=aad_for(adapter.code, key), ring=ring), + key_version=ring.current_version, user=user, + ) + saved.append(key) + for key in clear or []: + if key in allowed and key not in saved: + self._store.delete_credential(adapter.code, key) + return saved + + # ── 마스터 키 교체 후 재암호화 ───────────────────────── + def reencrypt_all(self) -> dict[str, int]: + """예전 키 버전으로 된 암호문을 현재 키로 다시 암호화. (재암호화 수, 실패 수).""" + ring = self._ring_loader() + done = failed = 0 + for row in self._store.all_credential_rows(): + token = row["encrypted_value"] + if not needs_reencrypt(token, ring): + continue + code, key = row["marketplace_code"], row["credential_key"] + try: + plain = decrypt(token, aad=aad_for(code, key), ring=ring) + except Exception: # noqa: BLE001 + failed += 1 + continue + self._store.upsert_credential( + code, key, encrypted_value=encrypt(plain, aad=aad_for(code, key), ring=ring), + key_version=ring.current_version, user="rekey", + ) + done += 1 + return {"reencrypted": done, "failed": failed} + + def key_versions_in_use(self) -> dict[int, int]: + counts: dict[int, int] = {} + for row in self._store.all_credential_rows(): + v = int(row["key_version"]) + counts[v] = counts.get(v, 0) + 1 + return counts diff --git a/app/modules/performance/dashboard.py b/app/modules/performance/dashboard.py new file mode 100644 index 0000000..e74b313 --- /dev/null +++ b/app/modules/performance/dashboard.py @@ -0,0 +1,197 @@ +"""④ 대시보드/설정 화면 데이터 조립 — 저장소 조회 + calc 계산 결과를 템플릿 컨텍스트로. + +HTTP 와 무관하다(store 만 주입). 라우터는 파라미터 파싱·권한만 하고 여기로 넘긴다. +""" + +from __future__ import annotations + +from datetime import date, timedelta +from decimal import Decimal +from typing import Any, Mapping, Sequence + +from . import calc +from .adapters.base import STATUS_LABELS +from .adapters.registry import all_adapters, get_adapter + + +def _sales_marketplaces(store: Any) -> list[dict[str, Any]]: + """대시보드 열 = 사용 ON + 매출 집계 ON 인 쇼핑몰(설정 순서).""" + known = {a.code for a in all_adapters()} + return [m for m in store.list_marketplaces() if m["enabled"] and m["include_in_sales"] and m["code"] in known] + + +def display_status(marketplace: Mapping[str, Any], status_row: Mapping[str, Any] | None, + configured: bool) -> str: + if not marketplace.get("enabled"): + return "disabled" + adapter = get_adapter(marketplace["code"]) + if adapter is not None and not adapter.uses_shared_integration and not configured: + return "not_configured" + return (status_row or {}).get("status") or "unknown" + + +def build_dashboard(store: Any, *, kind: str, anchor: date, today: date, + custom_from: date | None = None, custom_to: date | None = None, + selected: Sequence[str] = (), holidays: Mapping[str, str] | None = None, + configured: Mapping[str, bool] | None = None) -> dict[str, Any]: + markets = _sales_marketplaces(store) + all_codes = [m["code"] for m in markets] + codes = [c for c in all_codes if c in set(selected)] or all_codes + names = {m["code"]: m["name"] for m in markets} + short = {c: _short_name(names[c]) for c in all_codes} + + period = calc.resolve_period(kind, anchor, custom_from=custom_from, custom_to=custom_to) + cmp_start, cmp_end, cmp_label = period.compare_range(today) + # 월·연 누적의 기준일 — 선택 기간이 오늘을 포함하면 오늘(이번주가 다음 달로 걸쳐도 + # "이번달"), 지난 기간이면 기간 끝, 앞으로의 기간이면 기간 시작. + if period.end < today: + ref = period.end + elif period.start <= today: + ref = today + else: + ref = period.start + month_period = calc.resolve_period("month", ref) + year_period = calc.resolve_period("year", ref) + m_cmp_start, m_cmp_end, m_cmp_label = month_period.compare_range(today) + y_cmp_start, y_cmp_end, y_cmp_label = year_period.compare_range(today) + + q_start = min(period.start, cmp_start, m_cmp_start, y_cmp_start) + q_end = max(period.end, year_period.end) + cells = calc.build_cells(store.daily_amounts(q_start, q_end, codes), store.rate_table()) + + cur = calc.sum_range(cells, codes, period.start, period.end) + prev = calc.sum_range(cells, codes, cmp_start, cmp_end) + mtd = calc.sum_range(cells, codes, month_period.start, month_period.end) + m_prev = calc.sum_range(cells, codes, m_cmp_start, m_cmp_end) + ytd = calc.sum_range(cells, codes, year_period.start, year_period.end) + y_prev = calc.sum_range(cells, codes, y_cmp_start, y_cmp_end) + has_prev = prev.gross != 0 or prev.commission != 0 + + period_word = {"day": "오늘" if period.start == today else "해당일", "week": "이번주" if period.start <= today <= period.end else "해당 주", + "month": "이번달" if period.start <= today <= period.end else "해당 월", + "year": "올해" if period.start <= today <= period.end else "해당 연도", + "custom": "선택 기간"}[period.kind] + kpis = [ + {"key": "gross", "label": f"{period_word} 총매출", "value": cur.gross, "primary": True, + "delta": calc.pct_change(cur.gross, prev.gross), "cmp": cmp_label}, + {"key": "net", "label": f"{period_word} 수수료 차감 매출", "value": cur.net, "primary": True, + "delta": calc.pct_change(cur.net, prev.net), "cmp": cmp_label}, + {"key": "commission", "label": f"{period_word} 수수료", "value": cur.commission, + "delta": calc.pct_change(cur.commission, prev.commission) if has_prev else None, "cmp": cmp_label, + "invert": True}, + {"key": "mtd", "label": f"{month_period.label} 누적 매출", "value": mtd.gross, + "delta": calc.pct_change(mtd.gross, m_prev.gross), "cmp": m_cmp_label}, + {"key": "ytd", "label": f"{year_period.label} 누적 매출", "value": ytd.gross, + "delta": calc.pct_change(ytd.gross, y_prev.gross), "cmp": y_cmp_label}, + ] + + share = calc.by_code(cells, codes, period.start, period.end) + statuses = store.statuses() + configured = configured or {} + problems = [] + for m in markets: + if m["code"] not in codes: + continue + st = display_status(m, statuses.get(m["code"]), configured.get(m["code"], False)) + if st in ("auth_failed", "token_expired", "api_error"): + problems.append({"code": m["code"], "name": m["name"], "label": STATUS_LABELS[st], + "error": (statuses.get(m["code"]) or {}).get("last_error", "")}) + + m_qs = "" if len(codes) == len(all_codes) else "".join(f"&m={c}" for c in codes) + + def url(kind: str, anchor_d: date | None = None, start: date | None = None, end: date | None = None) -> str: + if kind == "custom": + return f"?period=custom&from={start.isoformat()}&to={end.isoformat()}{m_qs}" + return f"?period={kind}&d={anchor_d.isoformat()}{m_qs}" + + if period.kind == "custom": + length = timedelta(days=period.days) + prev_url = url("custom", start=period.start - length, end=period.start - timedelta(days=1)) + next_url = url("custom", start=period.end + timedelta(days=1), end=period.end + length) + else: + prev_url = url(period.kind, period.prev_anchor) + next_url = url(period.kind, period.next_anchor) + nav = { + "prev": prev_url, "next": next_url, + "quick": [ + {"key": "day", "label": "오늘", "url": url("day", today), + "active": period.kind == "day" and period.start == today}, + {"key": "week", "label": "이번주", "url": url("week", today), + "active": period.kind == "week" and period.start <= today <= period.end}, + {"key": "month", "label": "이번달", "url": url("month", today), + "active": period.kind == "month" and period.start <= today <= period.end}, + {"key": "year", "label": "올해", "url": url("year", today), + "active": period.kind == "year" and period.start <= today <= period.end}, + ], + "m_qs": m_qs, + } + + return { + "nav": nav, + "period": period, + "period_kind": period.kind, + "today": today.isoformat(), + "codes": codes, + "all_codes": all_codes, + "names": names, + "short_names": short, + "selected_all": len(codes) == len(all_codes), + "kpis": kpis, + "table": calc.main_table(period, codes, cells, today=today, holidays=holidays), + "month": calc.month_summary(month_period.start.year, month_period.start.month, codes, cells), + "year": calc.year_months(year_period.start.year, codes, cells, today=today), + "chart_daily": calc.daily_series(period, codes, cells), + "chart_share": [{"code": c, "name": names[c], **share[c].as_dict()} for c in codes], + "problems": problems, + "last_update_at": store.last_update_at(), + "running": store.running_codes(), + "no_marketplaces": not all_codes, + } + + +def _short_name(name: str) -> str: + return {"네이버 스마트스토어": "네이버", "토스쇼핑": "토스"}.get(name, name) + + +def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapping[str, Any], + key_versions_in_use: Mapping[int, int], sample_count: int) -> dict[str, Any]: + from app.timezone import today_kst # noqa: WPS433 + + statuses = store.statuses() + rates = store.rate_table() + today = today_kst() + rows = [] + by_code = {m["code"]: m for m in store.list_marketplaces()} + for adapter in all_adapters(): + m = by_code.get(adapter.code) + if m is None: + continue + st_row = statuses.get(adapter.code) or {} + st = display_status(m, st_row, configured.get(adapter.code, False)) + cur_rate = calc.rate_on(rates, adapter.code, today) + has_rate = bool(rates.get(adapter.code)) + rows.append({ + "code": adapter.code, "name": m["name"], "enabled": m["enabled"], + "include_in_sales": m["include_in_sales"], + "rate": _fmt_rate(cur_rate) if has_rate else "", + "rate_history": len(rates.get(adapter.code, ())), + "auth_type": adapter.auth_type, "shared": adapter.uses_shared_integration, + "implemented": adapter.implemented, "note": adapter.note, "docs_url": adapter.docs_url, + "configured": configured.get(adapter.code, False), + "status": st, "status_label": STATUS_LABELS.get(st, st), + "last_test_at": st_row.get("last_test_at"), "last_test_ok": st_row.get("last_test_ok"), + "last_sync_at": st_row.get("last_sync_at"), "last_success_sync_at": st_row.get("last_success_sync_at"), + "last_error": st_row.get("last_error") or "", "last_error_at": st_row.get("last_error_at"), + }) + stale = {v: n for v, n in key_versions_in_use.items() if key_info.get("current_version") and v != key_info["current_version"]} + return {"rows": rows, "key_info": key_info, "key_versions_in_use": dict(key_versions_in_use), + "stale_key_rows": sum(stale.values()), "sample_count": sample_count, + "default_sample_from": today.replace(month=1, day=1).isoformat(), + "default_sample_to": today.isoformat()} + + +def _fmt_rate(rate: Decimal) -> str: + s = f"{Decimal(rate):f}" + if "." in s: + s = s.rstrip("0").rstrip(".") + return s diff --git a/app/modules/performance/db.py b/app/modules/performance/db.py new file mode 100644 index 0000000..4d7956a --- /dev/null +++ b/app/modules/performance/db.py @@ -0,0 +1,332 @@ +"""performance_db PostgreSQL 저장소. + +- 드라이버: psycopg 3 (`psycopg[binary,pool]`) — 다른 모듈과 동일 패턴. +- 연결 정보: 환경변수 `PERFORMANCE_DB_URL` + (예: postgresql://performance_app:@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.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) + + +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) -> dict[str, Any] | None: + sets, params = [], [] + 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) + with self._pool.connection() as conn: + row = conn.execute( + f"UPDATE perf_marketplaces SET {', '.join(sets)} WHERE code = %s RETURNING *", params + ).fetchone() + 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)는 덮어쓴다 — 여러 번 동기화해도 중복 없음.""" + 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() + """ + rows = [ + (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 + ] + if not rows: + return 0 + with self._pool.connection() as conn: + with conn.transaction(): + with conn.cursor() as cur: + cur.executemany(sql, rows) + return len(rows) + + def daily_amounts(self, start: date, end: date, codes: list[str]) -> dict[tuple[date, str], int]: + 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() + return {(r["sales_date"], r["marketplace_code"]): int(r["amount"] or 0) 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 " + "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() + return [{k: _iso(v) for k, v in r.items()} for r in rows] + + 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 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] diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py new file mode 100644 index 0000000..d5f7ae1 --- /dev/null +++ b/app/modules/performance/router.py @@ -0,0 +1,283 @@ +"""실적 모듈 라우터 (prefix=/performance). + +화면 + GET /performance/ 대시보드(모듈 권한) + GET /performance/settings 실적 설정(관리자) +JSON API — 모듈 권한 + POST /performance/api/sync 매출 업데이트(사용 중인 쇼핑몰 전부, 쇼핑몰별 실패 격리) + GET /performance/api/events 금액 클릭 상세(쇼핑몰+기간) +JSON API — 관리자 + PUT /performance/api/marketplaces/{code} 사용/매출 집계 여부 + POST /performance/api/marketplaces/{code}/rates 수수료율(적용 시작일) + DELETE /performance/api/marketplaces/{code}/rates/{id} + GET /performance/api/marketplaces/{code}/credentials 입력칸 + 저장 여부(비밀 원문 없음) + PUT /performance/api/marketplaces/{code}/credentials 저장(암호화) + POST /performance/api/marketplaces/{code}/test 연결 테스트(저장값 또는 새 입력값) + POST /performance/api/sample-data 테스트 데이터 생성/삭제 + POST /performance/api/rekey 마스터 키 교체 후 재암호화 + +핸들러는 동기 DB 라 `def` 로 둔다(FastAPI 가 스레드풀에서 실행). +""" + +from __future__ import annotations + +from datetime import date +from decimal import Decimal, InvalidOperation +from typing import Any + +from fastapi import APIRouter, Body, HTTPException, Query, Request +from fastapi.responses import HTMLResponse, JSONResponse + +from app.timezone import today_kst + +from . import common +from .adapters.registry import all_adapters, get_adapter + +router = APIRouter(prefix="/performance", tags=["performance"]) + +MAX_EVENT_DAYS = 31 + + +def _parse_date(value: Any, *, field: str = "날짜") -> date | None: + if value in (None, ""): + return None + try: + return date.fromisoformat(str(value)[:10]) + except ValueError: + raise HTTPException(status_code=400, detail=f"{field} 형식이 올바르지 않습니다(YYYY-MM-DD).") from None + + +def _holidays() -> dict[str, str]: + try: + from app.modules.project.store import KR_HOLIDAYS # noqa: WPS433 — 공휴일 표 공유(읽기 전용) + + return dict(KR_HOLIDAYS) + except Exception: # noqa: BLE001 + return {} + + +def _code_or_404(store: Any, code: str): + adapter = get_adapter(code) + if adapter is None or code not in {m["code"] for m in store.list_marketplaces()}: + raise HTTPException(status_code=404, detail="알 수 없는 쇼핑몰입니다.") + return adapter + + +@router.get("/health") +def health(request: Request) -> JSONResponse: + st = common.get_store(request) + return JSONResponse({"ok": st is not None, "module": "performance", + "encryption_key": common.key_status()["ok"]}) + + +# ════════════════════════════════════════════════════════════ +# 화면 +# ════════════════════════════════════════════════════════════ +@router.get("/", response_class=HTMLResponse) +def dashboard_page( + request: Request, + period: str = "week", + d: str | None = None, + from_: str | None = Query(None, alias="from"), + to: str | None = None, + m: list[str] = Query(default=[]), + metric: str = "gross", +): + from app.main import render_template # noqa: WPS433 + + g = common.guard(request) + if not isinstance(g, tuple): + return g + store, user = g + from .dashboard import build_dashboard # noqa: WPS433 + + today = today_kst() + anchor = _parse_date(d) or today + creds, _ = common.services(request, store) + ctx = build_dashboard( + store, kind=period, anchor=anchor, today=today, + custom_from=_parse_date(from_), custom_to=_parse_date(to), selected=m, + holidays=_holidays(), configured=creds.configured_codes(list(all_adapters())), + ) + ctx["metric"] = metric if metric in ("gross", "commission", "net") else "gross" + return render_template(request, "performance/index.html", {**common.base_ctx(user, active_tab="dashboard"), **ctx}) + + +@router.get("/settings", response_class=HTMLResponse) +def settings_page(request: Request): + from app.main import render_template # noqa: WPS433 + + g = common.guard(request, admin=True) + if not isinstance(g, tuple): + return g + store, user = g + from .dashboard import build_settings # noqa: WPS433 + + creds, _ = common.services(request, store) + ctx = build_settings( + store, configured=creds.configured_codes(list(all_adapters())), key_info=common.key_status(), + key_versions_in_use=creds.key_versions_in_use(), sample_count=store.sample_count(), + ) + return render_template(request, "performance/settings.html", + {**common.base_ctx(user, active_tab="settings", page_title="실적 설정"), **ctx}) + + +# ════════════════════════════════════════════════════════════ +# JSON API — 모듈 권한 +# ════════════════════════════════════════════════════════════ +@router.post("/api/sync") +def api_sync(request: Request, payload: dict[str, Any] = Body(default={})) -> JSONResponse: + store, user = common.require_store(request) + _, sync = common.services(request, store) + codes = [str(c) for c in (payload.get("codes") or []) if get_adapter(str(c))] + results = sync.sync_all(codes=codes or None, user=user["email"]) + return JSONResponse({"results": results, "last_update_at": store.last_update_at()}) + + +@router.get("/api/events") +def api_events(request: Request, code: str, from_: str = Query(..., alias="from"), to: str | None = None) -> JSONResponse: + store, _ = common.require_store(request) + _code_or_404(store, code) + start = _parse_date(from_) + end = _parse_date(to) or start + if end < start: + start, end = end, start + if (end - start).days + 1 > MAX_EVENT_DAYS: + raise HTTPException(status_code=400, detail=f"상세 조회는 {MAX_EVENT_DAYS}일 이내만 가능합니다.") + rows = store.list_events(code, start, end) + return JSONResponse({"rows": rows, "truncated": len(rows) >= 500}) + + +# ════════════════════════════════════════════════════════════ +# JSON API — 관리자(설정) +# ════════════════════════════════════════════════════════════ +@router.put("/api/marketplaces/{code}") +def api_update_marketplace(request: Request, code: str, payload: dict[str, Any] = Body(...)) -> JSONResponse: + store, _ = common.require_store(request, admin=True) + _code_or_404(store, code) + row = store.update_marketplace( + code, + enabled=bool(payload["enabled"]) if "enabled" in payload else None, + include_in_sales=bool(payload["include_in_sales"]) if "include_in_sales" in payload else None, + ) + return JSONResponse({"marketplace": row}) + + +@router.post("/api/marketplaces/{code}/rates") +def api_set_rate(request: Request, code: str, payload: dict[str, Any] = Body(...)) -> JSONResponse: + store, user = common.require_store(request, admin=True) + _code_or_404(store, code) + raw = str(payload.get("rate_percent", "")).strip().rstrip("%").strip() + try: + rate = Decimal(raw) + except InvalidOperation: + raise HTTPException(status_code=400, detail="수수료율은 숫자로 입력하세요(예: 5, 10.8, 15.35).") from None + if not rate.is_finite() or rate < 0 or rate > 100: + raise HTTPException(status_code=400, detail="수수료율은 0 ~ 100 사이여야 합니다.") + if rate != rate.quantize(Decimal("0.001")): + raise HTTPException(status_code=400, detail="수수료율은 소수점 셋째 자리까지 입력할 수 있습니다.") + effective_from = _parse_date(payload.get("effective_from"), field="적용 시작일") + if effective_from is None: + raise HTTPException(status_code=400, detail="적용 시작일을 입력하세요.") + store.set_rate(code, rate_percent=rate, effective_from=effective_from, + memo=str(payload.get("memo") or "")[:200], user=user["email"]) + return JSONResponse({"rates": store.list_rates(code)}) + + +@router.get("/api/marketplaces/{code}/rates") +def api_list_rates(request: Request, code: str) -> JSONResponse: + store, _ = common.require_store(request, admin=True) + _code_or_404(store, code) + return JSONResponse({"rates": store.list_rates(code)}) + + +@router.delete("/api/marketplaces/{code}/rates/{rate_id}") +def api_delete_rate(request: Request, code: str, rate_id: int) -> JSONResponse: + store, _ = common.require_store(request, admin=True) + _code_or_404(store, code) + if not store.delete_rate(code, rate_id): + raise HTTPException(status_code=404, detail="수수료 이력을 찾지 못했습니다.") + return JSONResponse({"rates": store.list_rates(code)}) + + +@router.get("/api/marketplaces/{code}/credentials") +def api_get_credentials(request: Request, code: str) -> JSONResponse: + """입력칸 정의 + 저장 여부만. secret 항목의 원문은 보내지 않는다.""" + store, _ = common.require_store(request, admin=True) + adapter = _code_or_404(store, code) + creds, _ = common.services(request, store) + info = creds.describe(adapter) + return JSONResponse({"code": code, "name": adapter.name, "shared": adapter.uses_shared_integration, + "note": adapter.note, "docs_url": adapter.docs_url, + "key": common.key_status(), **info}) + + +def _clean_values(adapter, payload: dict[str, Any]) -> dict[str, str]: + allowed = {f.key for f in adapter.visible_fields()} + values = payload.get("values") or {} + if not isinstance(values, dict): + raise HTTPException(status_code=400, detail="values 형식이 올바르지 않습니다.") + return {k: str(v) for k, v in values.items() if k in allowed and v is not None} + + +@router.put("/api/marketplaces/{code}/credentials") +def api_save_credentials(request: Request, code: str, payload: dict[str, Any] = Body(...)) -> JSONResponse: + store, user = common.require_store(request, admin=True) + adapter = _code_or_404(store, code) + if adapter.uses_shared_integration: + raise HTTPException(status_code=400, detail=f"{adapter.name}은(는) 공통 연동을 사용해 여기서 입력하지 않습니다.") + if not common.key_status()["ok"]: + raise HTTPException(status_code=503, detail=common.key_status()["message"]) + creds, _ = common.services(request, store) + values = _clean_values(adapter, payload) + clear = [str(k) for k in (payload.get("clear") or [])] + merged = creds.merged_values(adapter, values) + for k in clear: + if k in merged and not values.get(k): + merged[k] = "" + errors = adapter.validate_credentials(merged) + if errors: + raise HTTPException(status_code=400, detail=" ".join(errors)) + saved = creds.save(adapter, values, clear=clear, user=user["email"]) + return JSONResponse({"saved": saved, **creds.describe(adapter)}) + + +@router.post("/api/marketplaces/{code}/test") +def api_test_connection(request: Request, code: str, payload: dict[str, Any] = Body(default={})) -> JSONResponse: + """values 가 있으면 저장하지 않은 새 입력값으로 시험(빈 칸은 저장된 값 사용).""" + store, user = common.require_store(request, admin=True) + adapter = _code_or_404(store, code) + _, sync = common.services(request, store) + values = {k: v for k, v in _clean_values(adapter, payload).items() if v.strip()} + result = sync.test_connection(code, values=values or None, user=user["email"]) + return JSONResponse(result) + + +@router.post("/api/sample-data") +def api_sample_data(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse: + store, _ = common.require_store(request, admin=True) + action = payload.get("action") + if action == "delete": + return JSONResponse({"deleted": store.delete_sample_events(), "sample_count": store.sample_count()}) + if action != "generate": + raise HTTPException(status_code=400, detail="action 은 generate 또는 delete 입니다.") + today = today_kst() + start = _parse_date(payload.get("from")) or today.replace(month=1, day=1) + end = _parse_date(payload.get("to")) or today + if end < start: + start, end = end, start + if (end - start).days > 400: + raise HTTPException(status_code=400, detail="테스트 데이터는 한 번에 400일까지 만들 수 있습니다.") + codes = [m["code"] for m in store.list_marketplaces() if m["enabled"]] + _, sync = common.services(request, store) + n = sync.generate_samples(start, end, codes) + return JSONResponse({"generated": n, "sample_count": store.sample_count()}) + + +@router.post("/api/rekey") +def api_rekey(request: Request) -> JSONResponse: + store, _ = common.require_store(request, admin=True) + if not common.key_status()["ok"]: + raise HTTPException(status_code=503, detail=common.key_status()["message"]) + creds, _ = common.services(request, store) + return JSONResponse({**creds.reencrypt_all(), "versions_in_use": creds.key_versions_in_use()}) diff --git a/app/modules/performance/security/__init__.py b/app/modules/performance/security/__init__.py new file mode 100644 index 0000000..09e50a8 --- /dev/null +++ b/app/modules/performance/security/__init__.py @@ -0,0 +1 @@ +"""② API 인증정보 보안 — 암호화(crypto) · 비밀값 가리기(redact).""" diff --git a/app/modules/performance/security/crypto.py b/app/modules/performance/security/crypto.py new file mode 100644 index 0000000..75be8ac --- /dev/null +++ b/app/modules/performance/security/crypto.py @@ -0,0 +1,161 @@ +"""쇼핑몰 인증정보 암호화 — AES-256-GCM(인증 암호화) + 키 버전. + +- 라이브러리: `cryptography` 의 AESGCM (직접 만든 알고리즘 없음). +- 해시가 아니라 **복호화 가능한** 암호화다 — API Secret/Token 은 나중에 원문이 필요하다. +- 마스터 키는 DB 에 두지 않는다. 환경변수(.env)에서만 읽는다. + + APP_ENCRYPTION_KEY 현재 키(32바이트). `openssl rand -hex 32` 의 64자 hex + 또는 32바이트 base64/base64url 둘 다 받는다. + APP_ENCRYPTION_KEY_VERSION 현재 키의 버전 번호(기본 1). + APP_ENCRYPTION_KEY_V{n} 키 교체 중 남겨 두는 예전 키(버전 n). 재암호화가 + 끝나면 지운다. + +암호문 형식: ``v{버전}:{base64url(nonce 12바이트 + 암호문 + tag 16바이트)}`` + +AAD(추가 인증 데이터)로 "어느 쇼핑몰의 어느 항목"인지를 묶는다 +(예: ``perf:coupang:secret_key``). DB 에서 암호문을 다른 행/칸으로 옮겨 붙이면 +복호화가 실패한다. +""" + +from __future__ import annotations + +import base64 +import binascii +import os +import re +from dataclasses import dataclass, field +from typing import Mapping + +KEY_ENV = "APP_ENCRYPTION_KEY" +VERSION_ENV = "APP_ENCRYPTION_KEY_VERSION" +_OLD_KEY_RE = re.compile(r"^APP_ENCRYPTION_KEY_V(\d+)$") +_TOKEN_RE = re.compile(r"^v(\d+):([A-Za-z0-9_\-]+={0,2})$") +_NONCE_LEN = 12 + + +class CryptoConfigError(RuntimeError): + """마스터 키가 없거나 형식이 틀림 — 설정 문제.""" + + +class DecryptError(RuntimeError): + """복호화 실패(키 버전 없음/키 바뀜/손상/다른 칸의 암호문). 원문·키는 메시지에 넣지 않는다.""" + + +def _parse_key(raw: str, *, name: str) -> bytes: + value = (raw or "").strip() + if not value: + raise CryptoConfigError(f"{name} 가 비어 있습니다.") + if re.fullmatch(r"[0-9a-fA-F]{64}", value): + return bytes.fromhex(value) + try: + padded = value + "=" * (-len(value) % 4) + decoded = base64.urlsafe_b64decode(padded.replace("+", "-").replace("/", "_")) + except (binascii.Error, ValueError): + decoded = b"" + if len(decoded) == 32: + return decoded + raise CryptoConfigError( + f"{name} 형식이 올바르지 않습니다. 32바이트 키가 필요합니다 " + "(`openssl rand -hex 32` 로 만든 64자 hex 권장)." + ) + + +@dataclass(frozen=True) +class KeyRing: + """현재 키 + (교체 중이면) 예전 키들. 키 값은 repr 에 나오지 않는다.""" + + current_version: int + _keys: Mapping[int, bytes] = field(repr=False) + + @classmethod + def from_env(cls, environ: Mapping[str, str] | None = None) -> "KeyRing": + env = os.environ if environ is None else environ + raw_current = (env.get(KEY_ENV) or "").strip() + if not raw_current: + raise CryptoConfigError( + f"{KEY_ENV} 환경변수가 설정되지 않았습니다. " + "`openssl rand -hex 32` 로 값을 만들어 .env 에 넣고 컨테이너를 재기동하세요." + ) + try: + version = int((env.get(VERSION_ENV) or "1").strip()) + except ValueError: + raise CryptoConfigError(f"{VERSION_ENV} 는 1 이상의 정수여야 합니다.") from None + if version < 1: + raise CryptoConfigError(f"{VERSION_ENV} 는 1 이상의 정수여야 합니다.") + keys: dict[int, bytes] = {} + for name, raw in env.items(): + m = _OLD_KEY_RE.match(name) + if m and (raw or "").strip(): + keys[int(m.group(1))] = _parse_key(raw, name=name) + keys[version] = _parse_key(raw_current, name=KEY_ENV) + return cls(current_version=version, _keys=keys) + + @property + def versions(self) -> list[int]: + return sorted(self._keys) + + def key(self, version: int) -> bytes: + try: + return self._keys[version] + except KeyError: + raise DecryptError( + f"암호화 키 버전 v{version} 이 서버에 없습니다. " + f"{KEY_ENV}_V{version} 환경변수를 확인하세요." + ) from None + + +def _aesgcm(key: bytes): + from cryptography.hazmat.primitives.ciphers.aead import AESGCM # 지연 import + + return AESGCM(key) + + +def encrypt(plaintext: str, *, aad: str, ring: KeyRing) -> str: + """평문 → ``v{버전}:{...}``. 항상 현재 키로 암호화한다.""" + if plaintext is None: + raise ValueError("암호화할 값이 없습니다.") + nonce = os.urandom(_NONCE_LEN) + ct = _aesgcm(ring.key(ring.current_version)).encrypt( + nonce, plaintext.encode("utf-8"), aad.encode("utf-8") + ) + body = base64.urlsafe_b64encode(nonce + ct).decode("ascii") + return f"v{ring.current_version}:{body}" + + +def key_version_of(token: str) -> int: + m = _TOKEN_RE.match(token or "") + if not m: + raise DecryptError("암호문 형식이 올바르지 않습니다.") + return int(m.group(1)) + + +def decrypt(token: str, *, aad: str, ring: KeyRing) -> str: + """``v{버전}:{...}`` → 평문. 실패 원인은 알려 주되 값은 절대 담지 않는다.""" + m = _TOKEN_RE.match(token or "") + if not m: + raise DecryptError("암호문 형식이 올바르지 않습니다.") + version = int(m.group(1)) + try: + raw = base64.urlsafe_b64decode(m.group(2)) + except (binascii.Error, ValueError): + raise DecryptError("암호문이 손상되었습니다.") from None + if len(raw) <= _NONCE_LEN: + raise DecryptError("암호문이 손상되었습니다.") + from cryptography.exceptions import InvalidTag # 지연 import + + try: + pt = _aesgcm(ring.key(version)).decrypt(raw[:_NONCE_LEN], raw[_NONCE_LEN:], aad.encode("utf-8")) + except InvalidTag: + raise DecryptError( + "복호화하지 못했습니다. 마스터 키가 바뀌었거나 값이 손상되었습니다. " + "인증정보를 다시 입력해야 할 수 있습니다." + ) from None + return pt.decode("utf-8") + + +def needs_reencrypt(token: str, ring: KeyRing) -> bool: + """현재 키 버전이 아닌 암호문인가(키 교체 후 재암호화 대상).""" + try: + return key_version_of(token) != ring.current_version + except DecryptError: + return False diff --git a/app/modules/performance/security/redact.py b/app/modules/performance/security/redact.py new file mode 100644 index 0000000..c3b1f44 --- /dev/null +++ b/app/modules/performance/security/redact.py @@ -0,0 +1,95 @@ +"""비밀값 가리기 — 오류 메시지·로그·원본 데이터(raw_data)에 인증정보가 남지 않게. + +원칙은 "애초에 남기지 않는다"이고, 이 모듈은 그래도 섞여 들어올 수 있는 값을 +걸러내는 마지막 방어선이다. + +- `redact_text(text, known_secrets)`: 문자열 안의 비밀값을 가린다. + · 알고 있는 실제 비밀값(저장된 인증정보 원문)은 어디에 있든 통째로 치환 + · "Authorization: ...", "Bearer ...", "Basic ...", 쿠키 + · key=value / "key": "value" 형태에서 key 가 비밀 이름(password, secret, token …)인 값 + · 길이 제한(기본 300자) +- `redact_mapping(obj)`: dict/list 를 깊이 복사하며 비밀 이름 키의 값을 가린다. +- `mask(value)`: 꼭 보여야 할 때 앞 4자 + **** + 뒤 4자(짧으면 전부 가림). +""" + +from __future__ import annotations + +import re +from typing import Any, Iterable + +MASK = "****" + +# 이름만 보고 비밀로 판단하는 키(대소문자 무시, 부분 일치). +_SENSITIVE_NAME = re.compile( + r"(pass(word|wd)?|pwd|secret|token|api[_\-]?key|access[_\-]?key|private[_\-]?key|" + r"authorization|auth[_\-]?header|cookie|session|signature|credential|client[_\-]?secret|" + r"refresh|bearer|x[_\-]?api)", + re.IGNORECASE, +) + +# 헤더 이름 뒤의 "인증 방식 + 값" 한 덩어리(예: Bearer xxx, CEA algorithm=…, signature=…). +_AUTH_HEADER = re.compile( + r"(?i)\b(authorization|proxy-authorization)[\"']?\s*[:=]\s*[\"']?" + r"(?:(?:bearer|basic|digest|cea|hmac\S*)\s+)?[^\s\"',;}\]]+" +) +_BEARER = re.compile(r"(?i)\b(bearer|basic|cea)\s+[A-Za-z0-9._~+/=\-]{6,}") +_COOKIE = re.compile(r"(?i)\b(set-cookie|cookie)\s*[:=]\s*[^\r\n]+") +_KV = re.compile( + r"""(?ix) + (["']?) # 여는 따옴표(선택) + ([A-Za-z0-9_\-\.]*? # 키 이름 + (?:pass(?:word|wd)?|pwd|secret|token|api[_\-]?key|access[_\-]?key| + private[_\-]?key|signature|credential|client[_\-]?secret|refresh) + [A-Za-z0-9_\-\.]*) + \1\s*[:=]\s* + (["']?)([^"'&\s,;}\]]+)\3 + """ +) + +DEFAULT_MAX_LEN = 300 + + +def is_sensitive_name(name: str) -> bool: + return bool(_SENSITIVE_NAME.search(name or "")) + + +def mask(value: str | None) -> str: + v = value or "" + if len(v) < 12: + return MASK + return f"{v[:4]}{MASK}{v[-4:]}" + + +def redact_text( + text: Any, + known_secrets: Iterable[str] = (), + *, + max_len: int = DEFAULT_MAX_LEN, +) -> str: + s = "" if text is None else str(text) + for secret in sorted({x for x in known_secrets if x and len(x) >= 4}, key=len, reverse=True): + s = s.replace(secret, MASK) + s = _AUTH_HEADER.sub(lambda m: f"{m.group(1)}: {MASK}", s) + s = _COOKIE.sub(lambda m: f"{m.group(1)}: {MASK}", s) + s = _BEARER.sub(lambda m: f"{m.group(1)} {MASK}", s) + s = _KV.sub(lambda m: f"{m.group(1)}{m.group(2)}{m.group(1)}={MASK}", s) + if max_len and len(s) > max_len: + s = s[:max_len] + "…" + return s + + +def redact_mapping(obj: Any, known_secrets: Iterable[str] = ()) -> Any: + secrets = tuple(known_secrets) + if isinstance(obj, dict): + out: dict[str, Any] = {} + for k, v in obj.items(): + if is_sensitive_name(str(k)): + out[k] = MASK + else: + out[k] = redact_mapping(v, secrets) + return out + if isinstance(obj, (list, tuple)): + return [redact_mapping(v, secrets) for v in obj] + if isinstance(obj, str): + return redact_text(obj, secrets, max_len=0) if secrets else obj + return obj diff --git a/app/modules/performance/sync.py b/app/modules/performance/sync.py new file mode 100644 index 0000000..da95b1c --- /dev/null +++ b/app/modules/performance/sync.py @@ -0,0 +1,138 @@ +"""① 수집 서비스 — 쇼핑몰 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() + upserted = self._store.upsert_events(code, (event_row(ev, known) for ev in events)) + 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 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 diff --git a/app/modules/performance/templates/performance/_tabs.html b/app/modules/performance/templates/performance/_tabs.html new file mode 100644 index 0000000..ab73e5d --- /dev/null +++ b/app/modules/performance/templates/performance/_tabs.html @@ -0,0 +1,7 @@ +{# 실적 모듈 탭 — 설정 탭은 관리자에게만(서버도 관리자만 허용). #} + diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html new file mode 100644 index 0000000..c6a0b21 --- /dev/null +++ b/app/modules/performance/templates/performance/index.html @@ -0,0 +1,238 @@ +{% extends "erp_base.html" %} + +{% block head_extra %}{% endblock %} + +{%- macro won(v) -%} + {%- if v is none -%} + {%- elif v == 0 -%}– + {%- else -%}{{ "{:,}".format(v) }}{%- endif -%} +{%- endmacro -%} + +{#- 한 칸에 총매출/수수료/차감매출 세 값을 넣고, 보기 전환은 CSS(data-metric)로. -#} +{%- macro m3(m) -%} + {{ won(m.gross) }}{{ won(m.commission) }}{{ won(m.net) }} +{%- endmacro -%} + +{% block content %} +
+ {% include "performance/_tabs.html" %} + + +
+
+ {% for q in nav.quick %} + {{ q.label }} + {% endfor %} + +
+ + + +
+ + + ~ + + {% for c in codes %}{% if not selected_all %}{% endif %}{% endfor %} + +
+ +
+ 쇼핑몰: {% if selected_all %}전체{% else %}{{ codes | length }}곳{% endif %} +
+ + {% if period_kind == 'custom' %} + + + {% else %} + + {% endif %} + {% for c in all_codes %} + + {% endfor %} +
+ + +
+
+
+ +
+ 마지막 업데이트 + {{ (last_update_at or '')[:16] | replace('T', ' ') or '—' }} + +
+
+ + {% if no_marketplaces %} +
매출에 포함된 쇼핑몰이 없습니다. {% if is_admin %}실적 설정에서 쇼핑몰 사용을 켜세요.{% endif %}
+ {% endif %} + + {% if problems %} +
+ 연결 오류 + {% for p in problems %}{{ p.name }} · {{ p.label }}{% endfor %} + — 해당 쇼핑몰은 마지막 정상 수집분까지만 반영됩니다. 나머지는 정상입니다. +
+ {% endif %} + + + +
+ {% for k in kpis %} +
+
{{ k.label }}
+
₩{{ "{:,}".format(k.value) }}
+
+ {% if k.delta is none %}{{ k.cmp }} 비교 없음 + {% else %} + {% set up = k.delta > 0 %} + + {% if k.delta > 0 %}▲{% elif k.delta < 0 %}▼{% else %}–{% endif %} {{ "%.1f" | format(k.delta | abs) }}% + {{ k.cmp }} 대비 + {% endif %} +
+
+ {% endfor %} +
+ + +
+
+

{% if period_kind == 'year' %}월별 × 쇼핑몰{% else %}일자별 × 쇼핑몰{% endif %}

+
+ + + +
+
+
+ + + + + {% for c in codes %}{% endfor %} + + + + + {% for r in table %} + + + {% for c in codes %} + {% set m = r.cells[c] %} + + {% endfor %} + + + {% endfor %} + +
{% if period_kind == 'year' %}월{% else %}날짜{% endif %}{{ short_names[c] }}{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}
+ {{ r.label }}{% if r.holiday %}{{ r.holiday }}{% endif %} + {{ m3(m) }}{{ m3(r.total) }}
+
+
+ + +
+
+

{% if period_kind == 'year' %}월별{% else %}일별{% endif %} 매출 추이

+
+
+
+
+

쇼핑몰별 비중

+ {{ period.label }}
+
+
+
+ + +
+
+

{{ month.label }} 쇼핑몰별 누적 실적

+
+ + + + {% for r in month.rows %} + + + + + + + + {% endfor %} + + + + + + + + + + +
쇼핑몰총매출수수료수수료 차감 매출매출 비중
{{ names[r.code] }}{{ won(r.gross) }}{{ won(r.commission) }}{{ won(r.net) }} + {% if r.share is not none %}{{ "%.1f" | format(r.share) }}%{% else %}–{% endif %} +
합계{{ won(month.total.gross) }}{{ won(month.total.commission) }}{{ won(month.total.net) }}{% if month.total.share is not none %}100%{% else %}–{% endif %}
+
+
+ +
+

{{ year.year }}년 누적

+
+
총매출₩{{ "{:,}".format(year.total.gross) }}
+
수수료₩{{ "{:,}".format(year.total.commission) }}
+
수수료 차감 매출₩{{ "{:,}".format(year.total.net) }}
+
+
+ + + + {% for r in year.rows %} + + + + + + + {% endfor %} + + + + + + + + + +
월총매출수수료수수료 차감 매출
{{ r.label }}{{ won(r.gross) }}{{ won(r.commission) }}{{ won(r.net) }}
합계{{ won(year.total.gross) }}{{ won(year.total.commission) }}{{ won(year.total.net) }}
+
+
+
+ +

+ 매출 기준: 결제는 결제일, 취소·반품은 발생일에 반영(음수). 수수료는 그날 적용되는 쇼핑몰 수수료율로 계산하며 + 일·쇼핑몰 단위로 원 미만 반올림합니다. 금액을 누르면 주문 목록을 볼 수 있습니다. +

+
+ + +{% endblock %} + +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html new file mode 100644 index 0000000..39f2a7d --- /dev/null +++ b/app/modules/performance/templates/performance/settings.html @@ -0,0 +1,121 @@ +{% extends "erp_base.html" %} + +{% block head_extra %}{% endblock %} + +{%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} + +{% block content %} +
+ {% include "performance/_tabs.html" %} + + {% if not key_info.ok %} +
+ 암호화 마스터 키가 없습니다. {{ key_info.message }} + — 키가 없으면 API 인증정보를 저장할 수 없습니다(수수료 설정·대시보드는 사용 가능). +
+ {% endif %} + +
+
+

쇼핑몰 설정

+ 사용 · 매출 집계 · 수수료율은 바로 저장됩니다. API 인증정보는 [설정]에서 입력합니다. +
+
+ + + + + + + + + + + + + + + {% for r in rows %} + + + + + + + + + + + {% endfor %} + +
쇼핑몰사용매출 집계수수료율API 설정연결 상태마지막 동기화
{{ r.name }} + + + + + {% if r.rate %}{{ r.rate }}%{% else %}미설정{% endif %} + + + {% if r.shared %}공통 연동 + {% elif r.configured %}설정완료 + {% else %}미설정{% endif %} + + + {{ r.status_label }} + {% if r.last_error and r.status not in ('ok', 'disabled') %}
{{ r.last_error }}
{% endif %} +
{{ when(r.last_success_sync_at) }} + + +
+
+

+ 수수료율은 적용 시작일부터 반영되고, 그 전 실적은 예전 요율로 계산됩니다(과거 실적이 바뀌지 않음). + 상태에 마우스를 올리면 마지막 연결 테스트 시각과 최근 오류를 볼 수 있습니다. +

+
+ +
+
+

인증정보 암호화

+
+
마스터 키
+
{% if key_info.ok %}설정됨 · 현재 v{{ key_info.current_version }} + {% set olds = key_info.versions | reject('equalto', key_info.current_version) | list %} + {% if olds %}(예전 키 v{{ olds | join(', v') }} 보관 중){% endif %} + {% else %}미설정{% endif %}
+
저장된 항목
+
{% for v, n in key_versions_in_use.items() %}v{{ v }}: {{ n }}개{% if not loop.last %}, {% endif %}{% else %}없음{% endfor %}
+
+ {% if stale_key_rows %} +

예전 키로 암호화된 항목이 {{ stale_key_rows }}개 있습니다. +

+ {% endif %} +

+ API 인증정보는 서버에서 AES-256-GCM 으로 암호화해 DB 에 저장합니다. 마스터 키(APP_ENCRYPTION_KEY)는 DB 가 아닌 + 서버 환경변수에만 있으며, 키를 잃으면 저장된 인증정보를 복구할 수 없으니 별도로 안전하게 보관하세요. +

+
+ +
+

테스트 데이터

+ 현재 {{ "{:,}".format(sample_count) }}건
+

실제 API 연동 전 화면 확인용 모의 매출입니다(사용 중인 쇼핑몰 대상). 실제 데이터와 구분되어 한 번에 지울 수 있습니다.

+
+ + ~ + + + +
+
+
+
+{% endblock %} + +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/__init__.py b/app/modules/performance/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py new file mode 100644 index 0000000..bf78aeb --- /dev/null +++ b/app/modules/performance/tests/test_performance.py @@ -0,0 +1,406 @@ +"""실적 모듈 테스트 — 암호화·가리기·계산·인증정보·동기화. DB/네트워크 없이 가짜 저장소로. + + python -m app.modules.performance.tests.test_performance +또는 pytest 로 실행 가능. +""" + +from __future__ import annotations + +import os +from datetime import date, timedelta +from decimal import Decimal + +from app.modules.performance import calc +from app.modules.performance.adapters import mock +from app.modules.performance.adapters.base import ( + AuthFailed, + CredentialField, + MarketplaceAdapter, + SaleEvent, +) +from app.modules.performance.adapters.registry import all_adapters +from app.modules.performance.credentials import CredentialService, aad_for +from app.modules.performance.security import crypto +from app.modules.performance.security.redact import MASK, mask, redact_mapping, redact_text +from app.modules.performance.sync import SyncService, event_row, sales_date_for + +KEY1 = "11" * 32 +KEY2 = "22" * 32 + + +def ring(version: int = 1, **old: str) -> crypto.KeyRing: + env = {"APP_ENCRYPTION_KEY": KEY1 if version == 1 else KEY2, "APP_ENCRYPTION_KEY_VERSION": str(version)} + env.update(old) + return crypto.KeyRing.from_env(env) + + +# ════════════════════════════════════════════════════════════ +# 암호화 +# ════════════════════════════════════════════════════════════ +def test_crypto_roundtrip_and_format(): + r = ring() + token = crypto.encrypt("my-secret-value", aad="perf:coupang:secret_key", ring=r) + assert token.startswith("v1:") + assert "my-secret-value" not in token + assert crypto.decrypt(token, aad="perf:coupang:secret_key", ring=r) == "my-secret-value" + # 같은 평문도 매번 다른 암호문(nonce) + assert token != crypto.encrypt("my-secret-value", aad="perf:coupang:secret_key", ring=r) + + +def test_crypto_rejects_wrong_aad_tamper_and_key(): + r = ring() + token = crypto.encrypt("abc", aad="perf:coupang:secret_key", ring=r) + for bad in (lambda: crypto.decrypt(token, aad="perf:naver:client_secret", ring=r), + lambda: crypto.decrypt(token[:-2] + ("A" if token[-2] != "A" else "B") + token[-1], aad="perf:coupang:secret_key", ring=r), + lambda: crypto.decrypt(token, aad="perf:coupang:secret_key", + ring=crypto.KeyRing.from_env({"APP_ENCRYPTION_KEY": KEY2}))): + try: + bad() + except crypto.DecryptError as exc: + assert "abc" not in str(exc) + else: + raise AssertionError("복호화가 실패해야 합니다") + + +def test_crypto_missing_or_bad_key(): + for env in ({}, {"APP_ENCRYPTION_KEY": "short"}, {"APP_ENCRYPTION_KEY": KEY1, "APP_ENCRYPTION_KEY_VERSION": "0"}): + try: + crypto.KeyRing.from_env(env) + except crypto.CryptoConfigError: + pass + else: + raise AssertionError(f"설정 오류여야 합니다: {list(env)}") + # base64 32바이트 키도 받는다 + import base64 + b64 = base64.urlsafe_b64encode(bytes(range(32))).decode() + assert crypto.KeyRing.from_env({"APP_ENCRYPTION_KEY": b64}).current_version == 1 + assert "11" * 4 not in repr(ring()) # 키 값이 repr 에 나오지 않음 + + +def test_crypto_rotation(): + old = ring(1) + token = crypto.encrypt("rotate-me", aad="a", ring=old) + new = ring(2, APP_ENCRYPTION_KEY_V1=KEY1) + assert new.versions == [1, 2] + assert crypto.needs_reencrypt(token, new) + assert crypto.decrypt(token, aad="a", ring=new) == "rotate-me" + token2 = crypto.encrypt("rotate-me", aad="a", ring=new) + assert token2.startswith("v2:") and not crypto.needs_reencrypt(token2, new) + try: + crypto.decrypt(token, aad="a", ring=ring(2)) # 예전 키를 안 남기면 실패 + except crypto.DecryptError as exc: + assert "v1" in str(exc) + else: + raise AssertionError("예전 키 없이는 복호화 실패해야 합니다") + + +# ════════════════════════════════════════════════════════════ +# 가리기 +# ════════════════════════════════════════════════════════════ +def test_redact(): + secret = "SK-live-9f8e7d6c5b4a" + msg = f"401 Unauthorized secret={secret} Authorization: Bearer abcdef123456 token=zzz999 other=ok" + out = redact_text(msg, [secret]) + assert secret not in out and "abcdef123456" not in out and "zzz999" not in out + assert "other=ok" in out and MASK in out + assert "Cookie" not in redact_text("Cookie: sid=abc; x=1").replace(f"Cookie: {MASK}", "") + j = redact_text('{"access_token": "tok-123456", "vendor": "A001"}') + assert "tok-123456" not in j and "A001" in j + data = redact_mapping({"order": "1", "headers": {"Authorization": "x", "X-Api-Key": "y"}, "items": [{"password": "p"}]}) + assert data["order"] == "1" and data["headers"]["Authorization"] == MASK + assert data["headers"]["X-Api-Key"] == MASK and data["items"][0]["password"] == MASK + assert mask("ABCDEFGHIJKL1234") == "ABCD****1234" and mask("short") == MASK + assert len(redact_text("x" * 1000)) <= 301 + + +# ════════════════════════════════════════════════════════════ +# 계산 +# ════════════════════════════════════════════════════════════ +def test_commission_rounding(): + assert calc.commission(1_000_000, Decimal("10")) == 100_000 + assert calc.commission(12_345, Decimal("10.8")) == 1_333 # 1333.26 → 1333 + assert calc.commission(15, Decimal("10")) == 2 # 1.5 → 2 (half up) + assert calc.commission(-15, Decimal("10")) == -2 # 취소도 같은 규칙 + assert calc.commission(100_000, Decimal("15.35")) == 15_350 + assert calc.commission(0, Decimal("10")) == 0 and calc.commission(1000, Decimal("0")) == 0 + m = calc.Money(gross=1_000_000, commission=100_000) + assert m.net == 900_000 + + +def test_rate_history(): + rates = {"coupang": [(date(2026, 1, 1), Decimal("8")), (date(2026, 7, 1), Decimal("10"))]} + assert calc.rate_on(rates, "coupang", date(2025, 12, 31)) == 0 + assert calc.rate_on(rates, "coupang", date(2026, 6, 30)) == 8 + assert calc.rate_on(rates, "coupang", date(2026, 7, 1)) == 10 + assert calc.rate_on(rates, "naver", date(2026, 7, 1)) == 0 + cells = calc.build_cells({(date(2026, 6, 30), "coupang"): 100_000, (date(2026, 7, 1), "coupang"): 100_000}, rates) + assert cells[(date(2026, 6, 30), "coupang")].commission == 8_000 + assert cells[(date(2026, 7, 1), "coupang")].commission == 10_000 + + +def test_periods(): + wed = date(2026, 9, 30) + p = calc.resolve_period("week", wed) + assert (p.start, p.end) == (date(2026, 9, 28), date(2026, 10, 4)) # 월~일 + assert p.start.weekday() == 0 and p.end.weekday() == 6 and p.days == 7 + assert p.prev_anchor == date(2026, 9, 21) + m = calc.resolve_period("month", date(2026, 2, 15)) + assert (m.start, m.end) == (date(2026, 2, 1), date(2026, 2, 28)) + y = calc.resolve_period("year", wed) + assert (y.start, y.end) == (date(2026, 1, 1), date(2026, 12, 31)) + c = calc.resolve_period("custom", wed, custom_from=date(2026, 9, 29), custom_to=date(2026, 9, 1)) + assert (c.start, c.end) == (date(2026, 9, 1), date(2026, 9, 29)) + # 진행 중인 주 — 전주 같은 요일까지만 비교 + s, e, label = p.compare_range(today=wed) + assert (s, e) == (date(2026, 9, 21), date(2026, 9, 23)) and label.startswith("전주") + # 지난 주 — 전주 전체 + s, e, _ = calc.resolve_period("week", date(2026, 9, 20)).compare_range(today=wed) + assert (s, e) == (date(2026, 9, 7), date(2026, 9, 13)) + # 진행 중인 달 — 전월 같은 날까지(말일 넘지 않게) + s, e, _ = calc.resolve_period("month", date(2026, 3, 31)).compare_range(today=date(2026, 3, 31)) + assert (s, e) == (date(2026, 2, 1), date(2026, 2, 28)) + assert calc.pct_change(110, 100) == 10.0 and calc.pct_change(5, 0) is None and calc.pct_change(0, 0) is None + + +def _cells_for(days, codes, amount=10_000): + return calc.build_cells({(d, c): amount for d in days for c in codes}, {"a": [(date(2000, 1, 1), Decimal("10"))]}) + + +def test_main_table_week(): + p = calc.resolve_period("week", date(2026, 9, 30)) + days = list(calc.daterange(p.start, p.end)) + cells = _cells_for(days, ["a", "b"]) + rows = calc.main_table(p, ["a", "b"], cells, today=date(2026, 9, 30), holidays={"2026-10-03": "개천절"}) + assert [r["kind"] for r in rows] == ["day"] * 7 + ["week"] + assert rows[0]["label"] == "월 9/28" and rows[6]["label"] == "일 10/4" + assert rows[5]["holiday"] == "개천절" and rows[2]["today"] and rows[3]["future"] + week = rows[-1] + assert week["cells"]["a"] == {"gross": 70_000, "commission": 7_000, "net": 63_000} + assert week["cells"]["b"]["commission"] == 0 # 요율 없는 쇼핑몰 = 0% + assert week["total"]["gross"] == 140_000 + assert rows[0]["total"]["gross"] == 20_000 + + +def test_main_table_month_and_year(): + p = calc.resolve_period("month", date(2026, 9, 10)) + cells = _cells_for(list(calc.daterange(p.start, p.end)), ["a"]) + rows = calc.main_table(p, ["a"], cells, today=date(2026, 9, 30)) + weeks = [r for r in rows if r["kind"] == "week"] + assert rows[-1]["kind"] == "total" and rows[-1]["total"]["gross"] == 300_000 + assert sum(w["total"]["gross"] for w in weeks) == 300_000 + assert weeks[0]["from"] == "2026-09-01" and weeks[0]["to"] == "2026-09-06" # 첫 주는 월 시작부터 + y = calc.resolve_period("year", date(2026, 9, 10)) + yrows = calc.main_table(y, ["a"], cells, today=date(2026, 9, 30)) + assert len(yrows) == 13 and yrows[8]["total"]["gross"] == 300_000 and yrows[9]["future"] + ym = calc.year_months(2026, ["a"], cells, today=date(2026, 9, 30)) + assert ym["rows"][9]["gross"] is None and ym["rows"][8]["gross"] == 300_000 and ym["total"]["gross"] == 300_000 + ms = calc.month_summary(2026, 9, ["a"], cells) + assert ms["rows"][0]["share"] == 100.0 and ms["total"]["net"] == 270_000 + + +# ════════════════════════════════════════════════════════════ +# 가짜 저장소 + 인증정보 +# ════════════════════════════════════════════════════════════ +class FakeStore: + def __init__(self): + self.creds: dict[tuple[str, str], dict] = {} + self.events: dict[tuple[str, str, str], dict] = {} + self.status: dict[str, dict] = {} + self.running: set[str] = set() + self.markets = [{"code": a.code, "name": a.name, "enabled": True, "include_in_sales": True} for a in all_adapters()] + + def credential_rows(self, code): + return {k: {**v, "updated_at": None} for (c, k), v in self.creds.items() if c == code} + + def credential_keys_by_code(self): + out = {} + for c, k in self.creds: + out.setdefault(c, set()).add(k) + return out + + def upsert_credential(self, code, key, *, encrypted_value, key_version, user=""): + self.creds[(code, key)] = {"encrypted_value": encrypted_value, "key_version": key_version} + + def delete_credential(self, code, key): + self.creds.pop((code, key), None) + + def all_credential_rows(self): + return [{"marketplace_code": c, "credential_key": k, **v} for (c, k), v in self.creds.items()] + + def list_marketplaces(self): + return self.markets + + def start_run(self, code, **_): + if code in self.running: + return None + self.running.add(code) + return len(self.running) + + def finish_run(self, run_id, **_): + self.running.clear() + + def record_sync(self, code, *, status, ok, error=""): + self.status[code] = {"status": status, "ok": ok, "error": error} + + def record_test(self, code, *, status, ok, error=""): + self.status[code] = {"status": status, "ok": ok, "error": error, "test": True} + + def upsert_events(self, code, events, *, is_sample=False): + n = 0 + for e in events: + self.events[(code, e["event_type"], e["external_event_id"])] = {**e, "is_sample": is_sample} + n += 1 + return n + + +def _coupang(): + return next(a for a in all_adapters() if a.code == "coupang") + + +def test_credentials_encrypted_and_never_returned(): + st = FakeStore() + svc = CredentialService(st, lambda: ring()) + ad = _coupang() + saved = svc.save(ad, {"vendor_id": "A00012345", "access_key": "AK-plain-111", "secret_key": "SK-plain-222", + "unknown": "x"}, user="t@x") + assert sorted(saved) == ["access_key", "secret_key", "vendor_id"] + for (code, key), row in st.creds.items(): + assert "plain" not in row["encrypted_value"] and "A00012345" not in row["encrypted_value"] + assert row["encrypted_value"].startswith("v1:") and row["key_version"] == 1 + info = svc.describe(ad) + as_text = repr(info) + assert "AK-plain-111" not in as_text and "SK-plain-222" not in as_text + by_key = {f["key"]: f for f in info["fields"]} + assert by_key["secret_key"]["has_value"] and "value" not in by_key["secret_key"] + assert by_key["vendor_id"]["value"] == "A00012345" and info["configured"] + # 빈 칸 = 유지, 다른 쇼핑몰 칸으로 옮긴 암호문은 풀리지 않음(AAD) + svc.save(ad, {"secret_key": "", "access_key": "AK-new"}) + acc = svc.accessor("coupang") + assert acc.get("secret_key") == "SK-plain-222" and acc.get("access_key") == "AK-new" + moved = st.creds[("coupang", "secret_key")]["encrypted_value"] + try: + crypto.decrypt(moved, aad=aad_for("naver", "client_secret"), ring=ring()) + except crypto.DecryptError: + pass + else: + raise AssertionError("다른 칸의 암호문은 복호화되면 안 됩니다") + # 재암호화(키 교체) + svc2 = CredentialService(st, lambda: ring(2, APP_ENCRYPTION_KEY_V1=KEY1)) + assert svc2.reencrypt_all() == {"reencrypted": 3, "failed": 0} + assert all(r["key_version"] == 2 for r in st.creds.values()) + assert svc2.accessor("coupang").get("secret_key") == "SK-plain-222" + assert svc2.configured_codes(list(all_adapters()))["coupang"] is True + assert svc2.configured_codes(list(all_adapters()))["naver"] is False + assert svc2.configured_codes(list(all_adapters()))["cafe24"] is True # 공통 연동 + + +# ════════════════════════════════════════════════════════════ +# 동기화 +# ════════════════════════════════════════════════════════════ +class _Leaky(MarketplaceAdapter): + code, name = "coupang", "쿠팡" + + def credential_fields(self): + return [CredentialField("secret_key", "Secret", secret=True)] + + def collect(self, ctx, start, end): + secret = ctx.credentials.get("secret_key") + raise AuthFailed(f"401 invalid signature for key {secret} Authorization: CEA abcdefg123") + + +class _Good(MarketplaceAdapter): + code, name = "naver", "네이버" + + def collect(self, ctx, start, end): + d = date(2026, 9, 29) + return 1, [ + SaleEvent("SALE", "o1-S", "o1", d, 10_000, payment_date=d - timedelta(days=1), raw={"token": "t"}), + SaleEvent("CANCEL", "o1-C", "o1", d, -10_000), + ] + + +def test_sync_isolation_redaction_and_dedupe(): + import app.modules.performance.sync as syncmod + + st = FakeStore() + creds = CredentialService(st, lambda: ring()) + creds.save(_coupang(), {"vendor_id": "V", "access_key": "AK", "secret_key": "SUPER-SECRET-KEY-123"}) + leaky, good = _Leaky(), _Good() + orig = syncmod.get_adapter + syncmod.get_adapter = lambda c: {"coupang": leaky, "naver": good}.get(c) + try: + svc = SyncService(st, creds) + r1 = svc.sync_marketplace("coupang", date(2026, 9, 23), date(2026, 9, 29)) + r2 = svc.sync_marketplace("naver", date(2026, 9, 23), date(2026, 9, 29)) + svc.sync_marketplace("naver", date(2026, 9, 23), date(2026, 9, 29)) # 두 번 = 중복 없음 + finally: + syncmod.get_adapter = orig + assert not r1["ok"] and r1["status"] == "auth_failed" + assert "SUPER-SECRET-KEY-123" not in r1["message"] and "abcdefg123" not in r1["message"] + assert "SUPER-SECRET-KEY-123" not in st.status["coupang"]["error"] + assert r2["ok"] and r2["upserted"] == 2 and st.status["naver"]["status"] == "ok" + assert len([k for k in st.events if k[0] == "naver"]) == 2 + sale = st.events[("naver", "SALE", "o1-S")] + assert sale["sales_date"] == date(2026, 9, 28) # 결제일 기준 + assert st.events[("naver", "CANCEL", "o1-C")]["sales_date"] == date(2026, 9, 29) # 발생일 기준 + assert sale["raw"]["token"] == MASK + # 이미 도는 중이면 건너뜀 + st.running.add("naver") + syncmod.get_adapter = lambda c: good + try: + r3 = SyncService(st, creds).sync_marketplace("naver", date(2026, 9, 29), date(2026, 9, 29)) + finally: + syncmod.get_adapter = orig + assert r3["skipped"] + + +def test_not_implemented_and_mock(): + st = FakeStore() + creds = CredentialService(st, lambda: ring()) + svc = SyncService(st, creds) + r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29)) + assert r["status"] == "not_configured" # 키 미입력 + creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "k-123456"}) + r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29)) + assert r["status"] == "not_implemented" and "k-123456" not in r["message"] + t = svc.test_connection("elevenst", values={"api_key": "typed-only"}) + assert t["unsaved"] and "test" not in st.status.get("elevenst", {}) # 저장 안 한 값 시험은 상태 기록 안 함 + a = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30)) + b = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30)) + assert [e.amount for e in a] == [e.amount for e in b] and a + for e in a: + e.validate() + assert (e.amount < 0) == (e.event_type in ("CANCEL", "RETURN")) + assert any(e.event_type == "CANCEL" for e in a) + n = svc.generate_samples(date(2026, 9, 1), date(2026, 9, 30), ["naver"]) + assert n == len(a) and all(v["is_sample"] for v in st.events.values()) + assert sales_date_for(a[0]) == a[0].payment_date + assert event_row(a[0])["sales_date"] == a[0].payment_date + + +def test_registry_and_event_validation(): + codes = [a.code for a in all_adapters()] + assert len(codes) == len(set(codes)) == 10 + for a in all_adapters(): + keys = [f.key for f in a.credential_fields()] + assert len(keys) == len(set(keys)), a.code + assert a.uses_shared_integration or any(f.secret for f in a.visible_fields()), a.code + for bad in (SaleEvent("SALE", "x", "o", date.today(), -1), SaleEvent("CANCEL", "x", "o", date.today(), 5), + SaleEvent("SALE", "x", "o", date.today(), 1.5), SaleEvent("BOGUS", "x", "o", date.today(), 1)): + try: + bad.validate() + except ValueError: + pass + else: + raise AssertionError(f"검증 실패해야 함: {bad.event_type} {bad.amount}") + + +if __name__ == "__main__": + os.environ.pop("APP_ENCRYPTION_KEY", None) + n = 0 + for name, fn in sorted(globals().items()): + if name.startswith("test_") and callable(fn): + fn() + n += 1 + print("ok", name) + print(f"{n} tests passed") diff --git a/app/static/performance.css b/app/static/performance.css new file mode 100644 index 0000000..544e6e7 --- /dev/null +++ b/app/static/performance.css @@ -0,0 +1,209 @@ +/* ════════════════════════════════════════════════════ + 실적(쇼핑몰 통합 매출) — 정보 밀도 높은 관리자 대시보드. + 기존 ERP 토큰(erp.css :root) 위에서만 쓴다. 색은 증감·상태·주말에만. + ════════════════════════════════════════════════════ */ +.perf { + --perf-line: var(--color-subtle-ash); + --perf-soft: #fafafa; + --perf-up: #0f8a3a; + --perf-down: var(--color-callout-red); + --perf-sat: #1d4ed8; + --perf-sun: var(--color-callout-red); + display: flex; flex-direction: column; gap: 12px; + font-variant-numeric: tabular-nums; +} +/* 공통 .erp-page 는 width:100% + padding 이라 부모보다 48px 넓어져 오른쪽이 잘린다. + 전역 규칙은 다른 모듈에 영향이 있어, 실적 화면이 들어 있을 때만 border-box 로 맞춘다. */ +.erp-page:has(> .perf) { box-sizing: border-box; } +.perf, .perf > * { min-width: 0; } +.perf-muted { color: var(--color-midtone-gray); font-size: 12px; } +.perf-nowrap { white-space: nowrap; } +.perf-center { text-align: center; } + +/* 탭 */ +.perf-tabs { display: flex; gap: 4px; border-bottom: 1px solid var(--perf-line); } +.perf-tab { + padding: 8px 14px; font-size: 13px; font-weight: 500; color: var(--color-midtone-gray); + border-bottom: 2px solid transparent; margin-bottom: -1px; +} +.perf-tab:hover { color: var(--color-rich-black); } +.perf-tab.is-active { color: var(--color-rich-black); border-bottom-color: var(--color-rich-black); } + +/* 도구 막대 */ +.perf-toolbar { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; } +.perf-quick, .perf-metric { display: inline-flex; border: 1px solid var(--perf-line); border-radius: 10px; padding: 2px; background: #fff; } +.perf-seg { + border: 0; background: transparent; font: inherit; font-size: 12px; font-weight: 500; + padding: 5px 11px; border-radius: 8px; cursor: pointer; color: var(--color-rich-black); white-space: nowrap; +} +.perf-seg:hover { background: var(--color-ghost-gray); } +.perf-seg.is-active { background: var(--color-deep-black); color: #fff; } +a.perf-seg.is-active, a.perf-seg.is-active:link, a.perf-seg.is-active:visited { color: #fff; } +.perf-nav { display: inline-flex; align-items: center; gap: 6px; } +.perf-nav-btn { + font-size: 12px; padding: 5px 9px; border: 1px solid var(--perf-line); border-radius: 8px; background: #fff; + white-space: nowrap; +} +.perf-nav-btn:hover { background: var(--color-ghost-gray); } +.perf-nav-label { font-weight: 600; font-size: 14px; min-width: 200px; text-align: center; } +.perf-custom { display: inline-flex; align-items: center; gap: 6px; } +.perf-custom[hidden] { display: none; } +/* 공통 .erp-input 의 min-width:240px 를 날짜칸에서만 푼다 */ +.perf .erp-input.perf-date { width: 150px; min-width: 0; flex: 0 0 auto; padding: 5px 8px !important; font-size: 12px !important; } +.perf-modal .erp-input.perf-date { width: 150px; min-width: 0; } +.perf-filter { position: relative; } +.perf-filter > summary { list-style: none; cursor: pointer; } +.perf-filter > summary::-webkit-details-marker { display: none; } +.perf-filter-pop { + position: absolute; z-index: 20; top: calc(100% + 6px); left: 0; min-width: 220px; + background: #fff; border: 1px solid var(--perf-line); border-radius: 12px; padding: 10px; + box-shadow: 0 8px 24px rgba(0, 0, 0, .1); display: flex; flex-direction: column; gap: 4px; +} +.perf-check { display: flex; align-items: center; gap: 6px; font-size: 13px; padding: 3px 2px; cursor: pointer; } +.perf-filter-act { display: flex; justify-content: space-between; margin-top: 6px; } +.perf-update { margin-left: auto; display: inline-flex; align-items: center; gap: 10px; } +.perf-update b { color: var(--color-rich-black); font-weight: 600; } + +/* 알림 */ +.perf-notice { + font-size: 12.5px; padding: 8px 12px; border-radius: 10px; background: var(--perf-soft); + border: 1px solid var(--perf-line); display: flex; flex-wrap: wrap; gap: 6px 10px; align-items: center; +} +.perf-notice[hidden] { display: none; } +.perf-notice.is-warn { background: #fff7f5; border-color: #f3d2ca; } +.perf-notice.is-ok { background: #f3fbf5; border-color: #cdeccf; } +.perf-problem { padding: 1px 8px; border-radius: 999px; background: #fbe9e6; color: var(--perf-down); font-weight: 500; } + +/* KPI */ +.perf-kpis { display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 10px; } +.perf-kpi { border: 1px solid var(--perf-line); border-radius: 12px; padding: 12px 14px; background: #fff; min-width: 0; } +.perf-kpi.is-primary { border-color: #cfcfcf; box-shadow: inset 3px 0 0 var(--color-deep-black); } +.perf-kpi-label { font-size: 12px; color: var(--color-midtone-gray); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } +.perf-kpi-value { font-size: 22px; font-weight: 600; letter-spacing: -.5px; margin: 2px 0; white-space: nowrap; } +.perf-kpi.is-primary .perf-kpi-value { font-size: 24px; } +.perf-kpi-delta { font-size: 12px; display: flex; gap: 6px; align-items: baseline; flex-wrap: wrap; } +.perf-delta { font-weight: 600; } +.perf-delta.is-up { color: var(--perf-up); } +.perf-delta.is-down { color: var(--perf-down); } +.perf-delta.is-flat { color: var(--color-midtone-gray); } + +/* 카드 */ +.perf-card { padding: 12px 14px; } +.perf-card-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; margin-bottom: 8px; flex-wrap: wrap; } +.perf-h { margin: 0; font-size: 14px; font-weight: 600; } +.perf-grid2 { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; } +.perf-foot { margin: 8px 0 0; line-height: 1.5; } + +/* 표 */ +.perf-table-wrap { overflow-x: auto; } +.perf-table { width: 100%; border-collapse: collapse; font-size: 12.5px; } +.perf-table th, .perf-table td { padding: 6px 8px; border-bottom: 1px solid #efefef; white-space: nowrap; } +.perf-table thead th { + font-size: 12px; font-weight: 500; color: var(--color-midtone-gray); text-align: right; + background: var(--perf-soft); border-bottom: 1px solid var(--perf-line); position: sticky; top: 0; +} +.perf-table thead th.perf-th-label { text-align: left; } +.perf-td-label { text-align: left; font-weight: 500; } +.perf-num { text-align: right; } +.perf-zero { color: #c9c9c9; } +.perf-na::before { content: ""; } +.perf-th-total, .perf-td-total { background: #f6f6f6; font-weight: 600; } +.perf-main .perf-td-label { min-width: 88px; } +.perf-row-day.is-sat .perf-td-label { color: var(--perf-sat); } +.perf-row-day.is-sun .perf-td-label { color: var(--perf-sun); } +.perf-row-day.is-today .perf-td-label::after { content: "오늘"; margin-left: 6px; font-size: 10px; padding: 0 5px; border-radius: 999px; background: var(--color-deep-black); color: #fff; vertical-align: 1px; } +.perf-row-day.is-future td, .perf-row-month.is-future td, .perf-year tr.is-future td { color: #c9c9c9; } +.perf-hol { display: block; font-size: 10.5px; font-weight: 400; } +.perf-row-week th, .perf-row-week td { background: #f3f3f3; font-weight: 600; border-bottom: 1px solid var(--perf-line); } +.perf-row-week .perf-td-total { background: #e9e9e9; } +.perf-row-total th, .perf-row-total td { background: var(--color-deep-black); color: #fff; font-weight: 600; border-bottom: 0; } +.perf-row-total .perf-zero { color: #777; } +td.is-link { cursor: pointer; } +td.is-link:hover { background: #eef2ff; text-decoration: underline; } + +/* 표시 기준 전환 — 한 칸에 3값, data-metric 으로 하나만 보인다 */ +.perf .v { display: none; } +.perf[data-metric="gross"] .v-gross, +.perf[data-metric="commission"] .v-commission, +.perf[data-metric="net"] .v-net { display: inline; } + +/* 비중 막대 */ +.perf-share { position: relative; min-width: 110px; } +.perf-bar { position: absolute; left: 8px; bottom: 3px; height: 3px; width: calc((100% - 16px) * var(--w) / 100); background: #d4d4d4; border-radius: 2px; } + +/* 연간 요약 */ +.perf-year-sum { display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; margin-bottom: 8px; } +.perf-year-sum div { background: var(--perf-soft); border: 1px solid #efefef; border-radius: 10px; padding: 8px 10px; } +.perf-year-sum span { display: block; font-size: 11.5px; color: var(--color-midtone-gray); } +.perf-year-sum b { font-size: 16px; font-weight: 600; } + +/* 그래프(SVG, performance.js 가 그림) */ +.perf-chart { min-height: 220px; } +.perf-chart svg { display: block; width: 100%; height: auto; } +.perf-chart text { font-size: 10.5px; fill: var(--color-midtone-gray); font-family: var(--font-geist); } +.perf-chart .bar { fill: #1f1f1f; } +.perf-chart .bar.is-neg { fill: var(--perf-down); } +.perf-chart .bar:hover { fill: #555; } +.perf-chart .grid { stroke: #efefef; } +.perf-chart .axis { stroke: #d4d4d4; } +.perf-chart-empty { color: var(--color-midtone-gray); font-size: 12px; padding: 80px 0; text-align: center; } + +/* 상세(Drill-down) 창 */ +.perf-modal { position: fixed; inset: 0; z-index: 1000; background: rgba(0, 0, 0, .35); display: flex; align-items: center; justify-content: center; padding: 20px; } +.perf-modal-card { background: #fff; border-radius: 14px; width: min(1100px, 100%); max-height: 88vh; display: flex; flex-direction: column; box-shadow: 0 20px 60px rgba(0, 0, 0, .25); } +.perf-modal-card.is-narrow { width: min(560px, 100%); } +.perf-modal-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; padding: 14px 16px; border-bottom: 1px solid var(--perf-line); } +.perf-modal-head h3 { margin: 0; font-size: 15px; font-weight: 600; } +.perf-modal-body { padding: 12px 16px; overflow: auto; } +.perf-modal-foot { display: flex; justify-content: flex-end; gap: 8px; padding: 12px 16px; border-top: 1px solid var(--perf-line); flex-wrap: wrap; align-items: center; } +.perf-modal-x { border: 0; background: none; font-size: 20px; cursor: pointer; color: var(--color-midtone-gray); } +.perf-ev-cancel td { color: var(--perf-down); } + +/* 설정 */ +.perf-set-table td, .perf-set-table th { vertical-align: middle; } +.perf-set-table thead th { text-align: left; } +.perf-set-table thead th:nth-child(2), .perf-set-table thead th:nth-child(3) { text-align: center; } +.perf-set-table thead th:nth-child(4) { text-align: right; padding-right: 60px; } +.perf-rate-cell { white-space: nowrap; } +.perf-rate { display: inline-block; min-width: 56px; text-align: right; font-weight: 600; margin-right: 4px; } +.perf-pill { display: inline-block; font-size: 11.5px; padding: 1px 8px; border-radius: 999px; background: var(--color-ghost-gray); color: var(--color-midtone-gray); white-space: nowrap; } +.perf-pill.is-ok { background: #e6f8e9; color: #0f8a3a; } +.perf-pill.is-bad { background: #fbe9e6; color: var(--perf-down); } +.perf-status { display: inline-flex; align-items: center; gap: 6px; font-size: 12.5px; white-space: nowrap; } +.perf-status i { width: 8px; height: 8px; border-radius: 50%; background: #bdbdbd; display: inline-block; } +.perf-status.st-ok i { background: #10b33a; } +.perf-status.st-auth_failed i, .perf-status.st-token_expired i, .perf-status.st-api_error i { background: var(--perf-down); } +.perf-status.st-not_configured i { background: #e0a526; } +.perf-status.st-disabled { color: var(--color-midtone-gray); } +.perf-err { font-size: 11px; color: var(--perf-down); max-width: 260px; white-space: normal; line-height: 1.35; margin-top: 2px; } +.perf-switch { position: relative; display: inline-block; width: 34px; height: 20px; cursor: pointer; } +.perf-switch input { opacity: 0; width: 0; height: 0; position: absolute; } +.perf-switch span { position: absolute; inset: 0; background: #d4d4d4; border-radius: 999px; transition: background .15s; } +.perf-switch span::after { content: ""; position: absolute; left: 3px; top: 3px; width: 14px; height: 14px; background: #fff; border-radius: 50%; transition: transform .15s; } +.perf-switch input:checked + span { background: var(--color-deep-black); } +.perf-switch input:checked + span::after { transform: translateX(14px); } +.perf-switch input:focus-visible + span { outline: 2px solid #93c5fd; outline-offset: 2px; } +.perf-dl { display: grid; grid-template-columns: 90px 1fr; gap: 6px 10px; margin: 0; font-size: 13px; } +.perf-dl dt { color: var(--color-midtone-gray); } +.perf-dl dd { margin: 0; } +.perf-sample-form { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; margin-top: 8px; } +.perf-form { display: flex; flex-direction: column; gap: 12px; } +.perf-form-row { display: flex; flex-direction: column; gap: 4px; } +.perf-form-row > label { font-size: 12px; font-weight: 500; } +.perf-form-row .erp-input { width: 100%; box-sizing: border-box; } +.perf-form-help { font-size: 11.5px; color: var(--color-midtone-gray); } +.perf-secret-state { font-size: 11.5px; color: #0f8a3a; } +.perf-secret-state.is-empty { color: var(--color-midtone-gray); } +.perf-inline { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; } +.perf-test-result { font-size: 12.5px; margin-right: auto; } +.perf-test-result.is-ok { color: #0f8a3a; } +.perf-test-result.is-bad { color: var(--perf-down); } + +@media (max-width: 1280px) { + .perf-kpis { grid-template-columns: repeat(3, minmax(0, 1fr)); } +} +@media (max-width: 980px) { + .perf-grid2 { grid-template-columns: 1fr; } + .perf-kpis { grid-template-columns: repeat(2, minmax(0, 1fr)); } + .perf-update { margin-left: 0; } +} diff --git a/app/static/performance.js b/app/static/performance.js new file mode 100644 index 0000000..aea815b --- /dev/null +++ b/app/static/performance.js @@ -0,0 +1,508 @@ +/* 실적(쇼핑몰 통합 매출) — 대시보드 / 설정 화면 동작. + * + * 쇼핑몰 API 는 브라우저에서 직접 부르지 않는다. 모든 요청은 우리 서버(/performance/api/…)로만. + * 인증정보 창은 저장된 비밀값을 받지 않는다(서버가 "저장됨" 여부만 준다). + */ +(function () { + "use strict"; + + // ── 공통 ───────────────────────────────────────────── + function el(tag, attrs, html) { + const n = document.createElement(tag); + Object.keys(attrs || {}).forEach(function (k) { + if (k === "class") n.className = attrs[k]; + else if (k === "text") n.textContent = attrs[k]; + else n.setAttribute(k, attrs[k]); + }); + if (html != null) n.innerHTML = html; + return n; + } + function esc(s) { + return String(s == null ? "" : s).replace(/[&<>"']/g, function (c) { + return { "&": "&", "<": "<", ">": ">", '"': """, "'": "'" }[c]; + }); + } + function fmt(n) { return Number(n || 0).toLocaleString("ko-KR"); } + function won(n) { return n ? fmt(n) : '–'; } + // 축 눈금용 짧은 금액(1.2억 / 350만) + function short(n) { + const a = Math.abs(n), s = n < 0 ? "-" : ""; + if (a >= 100000000) return s + (a / 100000000).toFixed(a >= 1000000000 ? 0 : 1).replace(/\.0$/, "") + "억"; + if (a >= 10000) return s + Math.round(a / 10000).toLocaleString("ko-KR") + "만"; + return s + fmt(a); + } + function alertMsg(msg) { return window.erpAlert ? window.erpAlert(msg) : Promise.resolve(window.alert(msg)); } + function confirmMsg(msg) { return window.erpConfirm ? window.erpConfirm(msg) : Promise.resolve(window.confirm(msg)); } + + async function api(method, url, body) { + const res = await fetch(url, { + method: method, + credentials: "same-origin", + headers: body ? { "Content-Type": "application/json" } : {}, + body: body ? JSON.stringify(body) : undefined, + }); + let data = null; + try { data = await res.json(); } catch (_) { data = null; } + if (!res.ok) { + const detail = data && data.detail; + throw new Error(typeof detail === "string" ? detail : "요청 실패 (" + res.status + ")"); + } + return data || {}; + } + + // 간단한 창. 반환: { card, body, foot, close } + function openModal(title, opts) { + opts = opts || {}; + const back = el("div", { class: "perf-modal" }); + const card = el("div", { class: "perf-modal-card" + (opts.narrow ? " is-narrow" : ""), role: "dialog", "aria-modal": "true" }); + const head = el("div", { class: "perf-modal-head" }); + head.appendChild(el("h3", { text: title })); + const x = el("button", { type: "button", class: "perf-modal-x", "aria-label": "닫기" }, "×"); + head.appendChild(x); + const body = el("div", { class: "perf-modal-body" }); + const foot = el("div", { class: "perf-modal-foot" }); + card.appendChild(head); card.appendChild(body); card.appendChild(foot); + back.appendChild(card); + document.body.appendChild(back); + function onKey(e) { if (e.key === "Escape") close(); } + function close() { + document.removeEventListener("keydown", onKey, true); + back.remove(); + if (opts.onClose) opts.onClose(); + } + x.addEventListener("click", close); + back.addEventListener("mousedown", function (e) { if (e.target === back) close(); }); + document.addEventListener("keydown", onKey, true); + return { card: card, body: body, foot: foot, close: close }; + } + + // ════════════════════════════════════════════════════ + // 대시보드 + // ════════════════════════════════════════════════════ + function initDashboard(root) { + const data = JSON.parse((document.getElementById("perf-data") || {}).textContent || "{}"); + const METRIC_NAMES = { gross: "총매출", commission: "수수료", net: "수수료 차감 매출" }; + const KEY = "perf_metric"; + + // 표시 기준 전환 — 서버가 세 값을 다 그려 두었고 CSS 가 하나만 보인다. + function setMetric(m) { + if (!METRIC_NAMES[m]) m = "gross"; + root.dataset.metric = m; + root.querySelectorAll(".perf-metric .perf-seg").forEach(function (b) { + b.classList.toggle("is-active", b.dataset.metric === m); + }); + try { localStorage.setItem(KEY, m); } catch (_) {} + drawDaily(m); + drawShare(m); + root.querySelectorAll(".perf-metric-name").forEach(function (n) { n.textContent = METRIC_NAMES[m]; }); + } + root.querySelectorAll(".perf-metric .perf-seg").forEach(function (b) { + b.addEventListener("click", function () { setMetric(b.dataset.metric); }); + }); + + // 직접선택 / 쇼핑몰 필터 + const customBtn = document.getElementById("perf-custom-btn"); + const customForm = document.getElementById("perf-custom"); + if (customBtn && customForm) customBtn.addEventListener("click", function () { + customForm.hidden = !customForm.hidden; + if (!customForm.hidden) customForm.querySelector("input[type=date]").focus(); + }); + const checkAll = root.querySelector("[data-perf-check-all]"); + if (checkAll) checkAll.addEventListener("click", function () { + const boxes = root.querySelectorAll(".perf-filter-pop input[type=checkbox]"); + const allOn = Array.prototype.every.call(boxes, function (b) { return b.checked; }); + boxes.forEach(function (b) { b.checked = !allOn; }); + }); + document.addEventListener("click", function (e) { + const f = document.getElementById("perf-filter"); + if (f && f.open && !f.contains(e.target)) f.open = false; + }); + + // 매출 업데이트 — 서버가 쇼핑몰별로 따로 수집(한 곳 실패해도 나머지 반영) + const syncBtn = document.getElementById("perf-sync-btn"); + const resultBox = document.getElementById("perf-sync-result"); + if (syncBtn) syncBtn.addEventListener("click", async function () { + syncBtn.disabled = true; + const label = syncBtn.textContent; + syncBtn.textContent = "업데이트 중…"; + try { + const res = await api("POST", "/performance/api/sync", {}); + const ok = [], bad = [], pending = [], busy = []; + let changed = 0; + (res.results || []).forEach(function (r) { + const name = (data.names || {})[r.code] || r.code; + if (r.skipped) busy.push(name); + else if (r.ok) { ok.push(name + " " + fmt(r.upserted) + "건"); changed += r.upserted; } + else if (r.status === "not_implemented") pending.push(name); + else bad.push(name + "(" + (r.label || r.status) + (r.message ? ": " + r.message : "") + ")"); + }); + const parts = []; + if (ok.length) parts.push("반영 " + esc(ok.join(", "))); + if (bad.length) parts.push("실패 " + esc(bad.join(", "))); + if (busy.length) parts.push("이미 진행 중 " + esc(busy.join(", "))); + if (pending.length) parts.push('연동 준비 중: ' + esc(pending.join(", ")) + ""); + resultBox.innerHTML = parts.join(" · ") || "업데이트할 쇼핑몰이 없습니다."; + resultBox.className = "perf-notice" + (bad.length ? " is-warn" : " is-ok"); + resultBox.hidden = false; + if (res.last_update_at) { + const lu = document.querySelector("#perf-last-update b"); + if (lu) lu.textContent = res.last_update_at.slice(0, 16).replace("T", " "); + } + if (changed > 0) setTimeout(function () { location.reload(); }, 1200); + } catch (err) { + resultBox.textContent = "업데이트 실패: " + err.message; + resultBox.className = "perf-notice is-warn"; + resultBox.hidden = false; + } finally { + syncBtn.disabled = false; + syncBtn.textContent = label === "업데이트 중…" ? "매출 업데이트" : label; + } + }); + + // 금액 클릭 → 주문 상세 + root.addEventListener("click", function (e) { + const td = e.target.closest("td.is-link"); + if (!td) return; + openEvents(td.dataset.code, td.dataset.from, td.dataset.to); + }); + async function openEvents(code, from, to) { + const name = (data.names || {})[code] || code; + const title = name + " · " + (from === to ? from : from + " ~ " + to) + " 주문 내역"; + const m = openModal(title); + m.body.innerHTML = '

불러오는 중…

'; + try { + const res = await api("GET", "/performance/api/events?code=" + encodeURIComponent(code) + + "&from=" + encodeURIComponent(from) + "&to=" + encodeURIComponent(to)); + const rows = res.rows || []; + if (!rows.length) { m.body.innerHTML = '

내역이 없습니다.

'; return; } + const KIND = { SALE: "결제", CANCEL: "취소", RETURN: "반품", ADJUST: "조정" }; + let sum = 0, sales = 0, minus = 0; + const body = rows.map(function (r) { + sum += r.amount; + if (r.amount >= 0) sales += r.amount; else minus += r.amount; + return '' + + "" + esc(r.sales_date) + "" + esc(KIND[r.event_type] || r.event_type) + + (r.is_sample ? ' 테스트' : "") + "" + + "" + esc(r.external_order_id) + "" + + "" + esc(r.product_name) + (r.option_name ? " " + esc(r.option_name) + "" : "") + "" + + '' + esc(r.quantity) + "" + + '' + fmt(r.amount) + "" + + "" + esc(r.order_date || "") + "" + esc(r.payment_date || "") + "" + + "" + esc(r.order_status) + ""; + }).join(""); + m.body.innerHTML = + '
' + + '' + + '' + + '' + body + + '
매출일구분주문번호상품명수량금액주문일결제일상태
결제 ' + fmt(sales) + + " / 취소·반품 " + fmt(minus) + '' + fmt(sum) + '
' + + (res.truncated ? '

처음 500건만 표시합니다.

' : "") + + '

수수료는 일·쇼핑몰 단위로 계산되어 주문별로는 표시하지 않습니다.

'; + } catch (err) { + m.body.innerHTML = '

' + esc(err.message) + "

"; + } + } + + // ── 그래프(SVG) ── + function svg(w, h, inner) { + return '' + inner + ""; + } + function niceMax(v) { + if (v <= 0) return 1; + const p = Math.pow(10, Math.floor(Math.log10(v))); + const n = v / p; + return (n <= 1 ? 1 : n <= 2 ? 2 : n <= 5 ? 5 : 10) * p; + } + function drawDaily(metric) { + const box = document.getElementById("perf-chart-daily"); + if (!box) return; + const pts = data.daily || []; + const vals = pts.map(function (p) { return p[metric] || 0; }); + if (!pts.length || vals.every(function (v) { return !v; })) { + box.innerHTML = '
기간 내 매출이 없습니다.
'; + return; + } + const W = 640, H = 230, L = 48, R = 8, T = 10, B = 26; + const maxV = niceMax(Math.max.apply(null, vals.concat([0]))); + const minV = Math.min.apply(null, vals.concat([0])) < 0 ? -niceMax(-Math.min.apply(null, vals)) : 0; + const y = function (v) { return T + (H - T - B) * (maxV - v) / (maxV - minV); }; + const bw = (W - L - R) / pts.length; + let g = ""; + for (let i = 0; i <= 4; i++) { + const v = minV + (maxV - minV) * i / 4; + g += '' + + '' + short(Math.round(v)) + ""; + } + const every = Math.ceil(pts.length / 16); + pts.forEach(function (p, i) { + const v = vals[i]; + const x = L + i * bw + bw * 0.15, w = Math.max(1, bw * 0.7); + const y0 = y(0), y1 = y(v); + g += '' + esc(p.label) + " " + fmt(v) + "원"; + if (i % every === 0) g += '' + esc(p.label) + ""; + }); + g += ''; + box.innerHTML = svg(W, H, g); + } + function drawShare(metric) { + const box = document.getElementById("perf-chart-share"); + if (!box) return; + const rows = (data.share || []).slice().sort(function (a, b) { return (b[metric] || 0) - (a[metric] || 0); }); + const total = rows.reduce(function (s, r) { return s + Math.max(0, r[metric] || 0); }, 0); + if (!rows.length || total <= 0) { box.innerHTML = '
기간 내 매출이 없습니다.
'; return; } + const W = 640, rowH = 22, L = 120, R = 150, H = rows.length * rowH + 6; + const maxV = Math.max.apply(null, rows.map(function (r) { return Math.max(0, r[metric] || 0); })) || 1; + let g = ""; + rows.forEach(function (r, i) { + const v = r[metric] || 0, y = 4 + i * rowH; + const w = Math.max(0, (W - L - R) * Math.max(0, v) / maxV); + const pct = total > 0 ? (Math.max(0, v) / total * 100).toFixed(1) : "0.0"; + g += '' + esc(r.name) + "" + + '' + esc(r.name) + " " + fmt(v) + "원" + + '' + fmt(v) + " (" + pct + "%)"; + }); + box.innerHTML = svg(W, H, g); + } + + let saved = null; + try { saved = localStorage.getItem(KEY); } catch (_) {} + setMetric(saved || root.dataset.metric || "gross"); + } + + // ════════════════════════════════════════════════════ + // 설정 + // ════════════════════════════════════════════════════ + function initSettings(root) { + // 사용 / 매출 집계 토글 — 바로 저장, 실패하면 되돌림 + root.querySelectorAll(".perf-switch input").forEach(function (box) { + box.addEventListener("change", async function () { + const tr = box.closest("tr"); + const payload = {}; + payload[box.dataset.field] = box.checked; + box.disabled = true; + try { + await api("PUT", "/performance/api/marketplaces/" + tr.dataset.code, payload); + } catch (err) { + box.checked = !box.checked; + alertMsg("저장 실패: " + err.message); + } finally { box.disabled = false; } + }); + }); + + root.addEventListener("click", function (e) { + const btn = e.target.closest("button[data-act]"); + if (!btn) return; + const tr = btn.closest("tr"); + const code = tr.dataset.code, name = tr.dataset.name; + if (btn.dataset.act === "rate") openRate(code, name, btn.dataset.hasHistory === "1"); + else if (btn.dataset.act === "creds") openCreds(code, name); + else if (btn.dataset.act === "test") runTest(code, name, btn); + }); + + function today() { + const d = new Date(); + return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0"); + } + + // ── 수수료율 ── + async function openRate(code, name, hasHistory) { + const m = openModal(name + " 수수료율", { narrow: true, onClose: function () { if (m.changed) location.reload(); } }); + m.body.innerHTML = + '
' + + '
' + + '
' + + '
' + + '
' + + '
" + + '
이 날짜부터 새 요율로 계산하고, 그 전 실적은 예전 요율을 유지합니다.
' + + '
' + + "
" + + '

변경 이력

불러오는 중…
'; + const save = el("button", { type: "button", class: "erp-btn erp-btn-primary" }, "저장"); + m.foot.appendChild(save); + const from = m.body.querySelector("#perf-rate-from"), all = m.body.querySelector("#perf-rate-all"); + function syncAll() { from.disabled = all.checked; } + all.addEventListener("change", syncAll); syncAll(); + + function renderHist(rates) { + const box = m.body.querySelector("#perf-rate-hist"); + if (!rates.length) { box.textContent = "이력이 없습니다(현재 0%)."; return; } + box.innerHTML = '' + + '' + + rates.map(function (r) { + const eff = r.effective_from === "2000-01-01" ? "처음부터" : r.effective_from; + return "'; + }).join("") + "
적용 시작일요율메모변경자
" + esc(eff) + '' + esc(String(r.rate_percent).replace(/\.?0+$/, "")) + + "%" + esc(r.memo) + "" + esc((r.created_by || "").split("@")[0]) + + '
"; + } + try { renderHist((await api("GET", "/performance/api/marketplaces/" + code + "/rates")).rates || []); } + catch (err) { m.body.querySelector("#perf-rate-hist").textContent = err.message; } + + m.body.addEventListener("click", async function (e) { + const b = e.target.closest("button[data-del]"); + if (!b) return; + if (!(await confirmMsg("이 수수료 이력을 삭제할까요? 해당 기간 실적의 수수료가 다시 계산됩니다."))) return; + try { + renderHist((await api("DELETE", "/performance/api/marketplaces/" + code + "/rates/" + b.dataset.del)).rates || []); + m.changed = true; + } catch (err) { alertMsg(err.message); } + }); + async function submit() { + const rate = m.body.querySelector("#perf-rate-in").value.trim(); + if (!rate) { m.body.querySelector("#perf-rate-in").focus(); return; } + try { + const res = await api("POST", "/performance/api/marketplaces/" + code + "/rates", { + rate_percent: rate, effective_from: all.checked ? "2000-01-01" : from.value, + memo: m.body.querySelector("#perf-rate-memo").value, + }); + renderHist(res.rates || []); + m.changed = true; + m.body.querySelector("#perf-rate-in").value = ""; + } catch (err) { alertMsg(err.message); } + } + save.addEventListener("click", submit); + m.body.querySelector("#perf-rate-form").addEventListener("submit", function (e) { e.preventDefault(); submit(); }); + m.body.querySelector("#perf-rate-in").focus(); + } + + // ── API 인증정보 ── + async function openCreds(code, name) { + const m = openModal(name + " API 설정", { narrow: true, onClose: function () { if (m.changed) location.reload(); } }); + m.body.innerHTML = '

불러오는 중…

'; + let info; + try { info = await api("GET", "/performance/api/marketplaces/" + code + "/credentials"); } + catch (err) { m.body.innerHTML = '

' + esc(err.message) + "

"; return; } + + const result = el("span", { class: "perf-test-result" }); + m.foot.appendChild(result); + const testBtn = el("button", { type: "button", class: "erp-btn erp-btn-outline" }, "연결 테스트"); + m.foot.appendChild(testBtn); + + let html = ""; + if (info.note) html += '

' + esc(info.note) + "

"; + if (info.docs_url) html += '

API 문서: ' + esc(info.docs_url) + "

"; + if (info.shared) { + m.body.innerHTML = html + '

이 쇼핑몰은 기존 공통 연동을 사용합니다. 연결 테스트로 상태만 확인할 수 있습니다.

'; + } else { + if (!info.key || !info.key.ok) html += '

' + esc((info.key && info.key.message) || "암호화 키가 없습니다.") + "

"; + if (info.decrypt_error) html += '

' + esc(info.decrypt_error) + "

"; + html += '
' + info.fields.map(function (f) { + const id = "perf-cred-" + f.key; + let state = ""; + if (f.secret) { + state = f.has_value + ? '현재 값: •••••••• (저장됨' + (f.updated_at ? ", " + esc(f.updated_at.slice(0, 16).replace("T", " ")) : "") + ")" + : '저장된 값 없음'; + } + return '
" + state + + '" + + (f.help ? '
' + esc(f.help) + "
" : "") + + (f.secret && f.has_value && !f.required ? '' : "") + + "
"; + }).join("") + "
" + + '

[연결 테스트]는 입력한 새 값으로 시험하며 저장하지 않습니다(빈 칸은 저장된 값 사용). ' + + "[저장]은 연결 테스트 결과와 관계없이 저장합니다 — 쇼핑몰의 일시 장애로 테스트가 실패할 수 있기 때문입니다. " + + "저장 후 자동으로 한 번 더 연결 테스트를 합니다.

"; + m.body.innerHTML = html; + const saveBtn = el("button", { type: "button", class: "erp-btn erp-btn-primary" }, "저장"); + m.foot.appendChild(saveBtn); + saveBtn.addEventListener("click", async function () { + saveBtn.disabled = true; + try { + await api("PUT", "/performance/api/marketplaces/" + code + "/credentials", { values: typed(), clear: cleared() }); + m.changed = true; + m.body.querySelectorAll("input[type=password]").forEach(function (i) { i.value = ""; }); + result.className = "perf-test-result"; + result.textContent = "저장했습니다. 연결 확인 중…"; + await test(false); + } catch (err) { + result.className = "perf-test-result is-bad"; + result.textContent = "저장 실패: " + err.message; + } finally { saveBtn.disabled = false; } + }); + } + + function typed() { + const out = {}; + m.body.querySelectorAll("input[data-key]").forEach(function (i) { if (i.value.trim()) out[i.dataset.key] = i.value.trim(); }); + return out; + } + function cleared() { + return Array.prototype.filter.call(m.body.querySelectorAll("input[data-clear]"), function (c) { return c.checked; }) + .map(function (c) { return c.dataset.clear; }); + } + async function test(withTyped) { + testBtn.disabled = true; + result.className = "perf-test-result"; + result.textContent = "연결 확인 중…"; + try { + const res = await api("POST", "/performance/api/marketplaces/" + code + "/test", withTyped ? { values: typed() } : {}); + result.className = "perf-test-result " + (res.ok ? "is-ok" : "is-bad"); + result.textContent = (res.ok ? "● " : "● " + res.label + " — ") + res.message + (res.unsaved ? " (저장 안 한 값으로 시험)" : ""); + if (!res.unsaved) m.changed = true; + } catch (err) { + result.className = "perf-test-result is-bad"; + result.textContent = err.message; + } finally { testBtn.disabled = false; } + } + testBtn.addEventListener("click", function () { test(true); }); + } + + async function runTest(code, name, btn) { + btn.disabled = true; + const label = btn.textContent; + btn.textContent = "확인 중…"; + try { + const res = await api("POST", "/performance/api/marketplaces/" + code + "/test", {}); + await alertMsg(name + " — " + (res.ok ? "정상 연결\n" : res.label + "\n") + res.message); + location.reload(); + } catch (err) { + alertMsg(err.message); + } finally { btn.disabled = false; btn.textContent = label; } + } + + // ── 테스트 데이터 / 재암호화 ── + const gen = document.getElementById("perf-sample-gen"); + if (gen) gen.addEventListener("click", async function () { + gen.disabled = true; + try { + const res = await api("POST", "/performance/api/sample-data", { + action: "generate", from: document.getElementById("perf-sample-from").value, + to: document.getElementById("perf-sample-to").value, + }); + await alertMsg("테스트 데이터 " + fmt(res.generated) + "건을 만들었습니다(같은 기간을 다시 만들면 덮어씀)."); + location.reload(); + } catch (err) { alertMsg(err.message); } finally { gen.disabled = false; } + }); + const del = document.getElementById("perf-sample-del"); + if (del) del.addEventListener("click", async function () { + if (!(await confirmMsg("테스트 데이터만 모두 삭제합니다. 실제 수집한 매출은 지우지 않습니다. 계속할까요?"))) return; + try { + const res = await api("POST", "/performance/api/sample-data", { action: "delete" }); + await alertMsg("테스트 데이터 " + fmt(res.deleted) + "건을 삭제했습니다."); + location.reload(); + } catch (err) { alertMsg(err.message); } + }); + const rekey = document.getElementById("perf-rekey"); + if (rekey) rekey.addEventListener("click", async function () { + if (!(await confirmMsg("예전 키로 암호화된 인증정보를 현재 키로 다시 암호화합니다. 계속할까요?"))) return; + try { + const res = await api("POST", "/performance/api/rekey"); + await alertMsg("다시 암호화 " + res.reencrypted + "건" + (res.failed ? ", 실패 " + res.failed + "건(다시 입력 필요)" : "")); + location.reload(); + } catch (err) { alertMsg(err.message); } + }); + } + + document.addEventListener("DOMContentLoaded", function () { + const dash = document.getElementById("perf-dash"); + if (dash) initDashboard(dash); + const set = document.getElementById("perf-settings"); + if (set) initSettings(set); + }); +})(); diff --git a/app/store.py b/app/store.py index 6c29fbf..d635831 100644 --- a/app/store.py +++ b/app/store.py @@ -32,6 +32,7 @@ MODULE_KEYS: tuple[str, ...] = ( "dispatch", "project", "cafe24", + "performance", "expense_approver", "vacation_approver", ) diff --git a/docs/DATABASES.md b/docs/DATABASES.md index 097368c..c827909 100644 --- a/docs/DATABASES.md +++ b/docs/DATABASES.md @@ -11,6 +11,7 @@ | `cupang_db` | 쿠팡 밀크런 출고 묶음 / 출고 라인 / 입고센터 / 박스 입수량 규칙 | | `malaysia_stock_db` | 말레이시아 창고 재고관리 — 창고/아이템/세트 BOM/입출고 이력/일일 재고조사 | | `cafe24_db` | 카페24 연동 — OAuth 토큰/상품 캐시/상세페이지 버전/예약/감사·API 로그 | +| `performance_db` | 실적(쇼핑몰 통합 매출) — 쇼핑몰 설정/수수료율 이력/API 인증정보(암호문)/연결 상태/매출 사건/동기화 기록 | --- @@ -336,6 +337,44 @@ cd /opt/www/main && docker compose up -d --build web --- +## performance_db 스키마 / 초기화 + +DDL: `scripts/sql/performance_db_init.sql` (멱등). DB·역할(`performance_app`)·테이블·인덱스·트리거·쇼핑몰 10곳 seed 를 +한 번에 생성. **JSON 폴백 없음** — `PERFORMANCE_DB_URL` 미설정 시 모듈이 "설정 필요" 안내만 표시. 상세는 `docs/PERFORMANCE_MODULE.md`. + +| 테이블 | 용도 | +| --- | --- | +| `perf_marketplaces` | 쇼핑몰 코드·이름·사용 여부·매출 집계 여부·순서 | +| `perf_commission_rates` | 수수료율 이력(`rate_percent NUMERIC(7,3)`, `effective_from`). 그날 유효한 요율로 과거 실적 계산 | +| `perf_credentials` | API 인증정보. (쇼핑몰, 항목) 한 행 = **AES-256-GCM 암호문** + `key_version`. 토큰도 여기 | +| `perf_connection_status` | 연결 상태·마지막 테스트/동기화·최근 오류(비밀값 가린 문구) | +| `perf_sales_events` | 매출 사건(결제 +, 취소·반품 −, BIGINT 원). `UNIQUE(marketplace_code, event_type, external_event_id)`. `is_sample`=테스트 데이터 | +| `perf_sync_runs` | 동기화 기록. `status='running'` 부분 유니크 인덱스로 같은 쇼핑몰 동시 실행 차단 | + +핵심 규칙: + +- 인증정보는 **암호문만** 저장. 마스터 키 `APP_ENCRYPTION_KEY` 는 DB 가 아닌 `.env` 에만 있다 — + DB 백업만으로는 복호화할 수 없고, **키를 잃으면 인증정보를 다시 입력해야 한다**(키는 별도 안전 보관). +- 테스트 데이터 삭제는 `is_sample = TRUE` 조건 삭제만 한다(설정 화면 버튼). + +### 운영 서버 초기화 (1회, 사용자 승인 후) + +```bash +read -s -p "performance_app password: " APP_PWD; echo +docker exec -i postgres-db psql -U postgres \ + -v app_password="$APP_PWD" \ + < scripts/sql/performance_db_init.sql +# main-app .env 에 추가: +# PERFORMANCE_DB_URL=postgresql://performance_app:@postgres-db:5432/performance_db +# APP_ENCRYPTION_KEY=$(openssl rand -hex 32) # 별도 안전한 곳에도 백업 +# APP_ENCRYPTION_KEY_VERSION=1 +cd /opt/www/main && docker compose up -d --build +``` + +> 멱등 스크립트. 기존 DB 가 있으면 DROP 하지 않음. + +--- + ## 백업 / 복구 (안전 절차) ### 백업 diff --git a/docs/DEPLOYMENT.md b/docs/DEPLOYMENT.md index 0c45297..a66fd98 100644 --- a/docs/DEPLOYMENT.md +++ b/docs/DEPLOYMENT.md @@ -120,6 +120,10 @@ docker compose down # 컨테이너 제거 (볼륨 유지) | `VACATION_DB_URL` | 휴가 관리 DB DSN (예: `postgresql://vacation_app:@postgres-db:5432/vacation_db`). **필수** — 미설정 시 모듈 비활성(설정 필요 안내). 권한키 `vacation`/`vacation_approver` | | `ITEMCODE_DB_URL` | 상품 검색용 itemcode_db 읽기 전용 DSN. 미설정 시 검색 비활성(수동 입력). 테이블/컬럼은 `ITEMCODE_TABLE`/`ITEMCODE_CODE_COL`/`ITEMCODE_NAME_COL`/`ITEMCODE_TYPE_COL` 또는 `ITEMCODE_SEARCH_SQL` 로 지정 | | `DATA_DIR` | 영구 데이터 경로 (Docker 볼륨 마운트). 첨부파일은 `$DATA_DIR/uploads/expense/{item_id}/` 에 저장 | +| `PERFORMANCE_DB_URL` | 실적 DB DSN (예: `postgresql://performance_app:@postgres-db:5432/performance_db`). **필수** — 미설정 시 실적 모듈 비활성(설정 필요 안내). 권한키 `performance` | +| `APP_ENCRYPTION_KEY` | 쇼핑몰 API 인증정보 암호화 마스터 키(32바이트, `openssl rand -hex 32`). DB 에 저장하지 않음. **분실 시 저장된 인증정보 복구 불가 — 별도 안전 보관**. 쇼핑몰별 ID/Key/Secret 은 `.env` 에 넣지 않고 실적 → 설정 화면에서 입력 | +| `APP_ENCRYPTION_KEY_VERSION` | 현재 마스터 키 버전(기본 1). 교체 시 올리고 예전 키는 `APP_ENCRYPTION_KEY_V{n}` 로 남긴 뒤 설정 화면에서 재암호화(`docs/PERFORMANCE_MODULE.md`) | +| `PERFORMANCE_SYNC_DAYS` | [매출 업데이트] 수집 기간(오늘 포함 최근 N일, 기본 7, 최대 90) | --- diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md new file mode 100644 index 0000000..e1421cc --- /dev/null +++ b/docs/PERFORMANCE_MODULE.md @@ -0,0 +1,117 @@ +# 실적(쇼핑몰 통합 매출) 모듈 + +> `app/modules/performance/` · DB `performance_db` · URL `/performance/` · 권한키 `performance` +> 여러 쇼핑몰의 주문/매출을 **수집 → DB 저장 → 화면 조회** 구조로 한 화면에서 본다. +> API 장애·호출 제한이 있어도 이미 저장된 실적은 그대로 보인다. + +## 1. 구조 — 네 영역 분리 + +| 영역 | 파일 | 역할 | +|---|---|---| +| ① 쇼핑몰 API 수집 | `adapters/base.py`, `adapters/<쇼핑몰>.py`, `adapters/registry.py`, `sync.py` | 어댑터 = 쇼핑몰 하나. `sync.py` 가 어댑터 결과를 공통 사건으로 DB 저장 | +| ② 인증정보·보안 | `security/crypto.py`, `security/redact.py`, `credentials.py` | AES-256-GCM 암·복호화, 비밀값 가리기, 저장/화면 요약/재암호화 | +| ③ 계산·저장 | `calc.py`, `db.py` | 기간·주(월~일)·수수료·반올림·집계(순수 함수) / performance_db | +| ④ 화면 | `dashboard.py`, `router.py`, `common.py`, `templates/performance/`, `static/performance.{css,js}` | 화면 데이터 조립, 라우트·권한, UI | + +**쇼핑몰 추가 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄**(`perf_marketplaces`). 대시보드·설정·동기화는 자동으로 붙는다. + +## 2. 어댑터 공통 인터페이스 (`MarketplaceAdapter`) + +| 메서드 | 설명 | +|---|---| +| `credential_fields()` | 설정 화면 입력칸 정의(`CredentialField`: key/label/secret/required/help, `internal`=토큰 등 화면 비표시) | +| `validate_credentials(values)` | 저장 전 검사(값을 오류 문구에 넣지 않음) | +| `authenticate(ctx)` / `refresh_token(ctx)` | 토큰 발급·갱신. 새 토큰은 `ctx.credentials.set(key, value)` → 자동 암호화 저장 | +| `test_connection(ctx)` | 성공 문구 반환, 실패는 `AdapterError` 계열 | +| `fetch_orders` / `fetch_refunds(ctx, start, end)` | 원본 수집 | +| `normalize_order` / `normalize_refund(raw)` | 원본 → `SaleEvent` 목록 | +| `collect(ctx, start, end)` | 위를 묶어 (원본 건수, 사건 목록) — sync 서비스가 부른다 | + +오류 클래스 = 연결 상태: `NotConfigured`(인증정보 미설정) · `AuthFailed`(인증 실패) · `TokenExpired` · `ApiError` · `NotImplementedYet`(연동 준비 중). + +**현재(1단계)**: 10개 어댑터 모두 입력칸만 정의, 수집은 `NotImplementedYet`. 카페24는 `auth_type="shared"` — 기존 +`app/integrations/cafe24` OAuth 토큰(cafe24_db)을 재사용해 연결 상태만 확인한다(주문 수집 시 앱 권한에 +`mall.read_order` 추가 + 재연결 필요). 쇼핑몰별 입력칸은 **연동 단계에서 공식 API 문서로 확정**한다. + +### 연동 단계 체크리스트(쇼핑몰마다) + +- 공식 문서로 인증 방식·호출 제한·페이지네이션·주문 상태 코드·취소/반품 API·날짜 필드 확인 +- `SaleEvent` 규칙: 금액은 원 단위 **정수**, 결제 `+` / 취소·반품 `−`, `external_event_id` 는 쇼핑몰 안에서 사건을 + 유일하게 가리키는 값(중복 방지 키), `order_date`/`payment_date`/`event_date` 를 섞지 말고 각각 채운다 +- 오류 메시지·`raw` 에 비밀값을 넣지 않는다(sync 가 한 번 더 가리지만 원칙은 넣지 않는 것) +- `implemented = True`, 단위 테스트(원본 샘플 → 사건 변환) 추가 + +## 3. 매출 기준·계산 (`calc.py`, `sync.sales_date_for`) + +- **집계 기준일(`sales_date`)**: 결제 = 결제일(`payment_date`, 없으면 `event_date`), 취소·반품 = **발생일**. + 지난주 실적이 나중에 바뀌지 않게 하려는 선택. `order_date`/`payment_date` 를 따로 보관하므로 기준을 바꿀 수 있다 + (바꿀 곳은 `sales_date_for` 한 곳 + 기존 행 재계산). +- **수수료** = `round_half_up(일·쇼핑몰 매출 합 × 그날 요율 / 100)` — `calc.commission()` 한 곳. 음수(취소)도 같은 규칙. + 주문별이 아니라 일·쇼핑몰 합계 단위 반올림이다. +- **수수료율 이력**: `perf_commission_rates(effective_from)`. 어떤 날의 요율 = 그날 이전 가장 최근 시작일의 요율, + 첫 요율 이전은 0%. "처음부터(과거 전체)"는 `2000-01-01` 로 저장. +- **주** = 월요일~일요일. **증감률**: 진행 중인 기간은 직전 기간의 **같은 경과일수**까지와 비교(전주 같은 기간), + 비교 대상이 0 이하면 표시하지 않음. +- **월·연 누적 기준일**: 선택 기간이 오늘을 포함하면 오늘(이번주가 다음 달에 걸쳐도 "이번달"), 지난 기간이면 기간 끝. + +## 4. 인증정보 보안 + +- 저장: 설정 화면 입력 → 서버에서 **AES-256-GCM**(`cryptography` AESGCM) → `perf_credentials` + (항목 하나 = 행 하나, `encrypted_value = "v{키버전}:{base64url(nonce+암호문+tag)}"`, `key_version`). +- AAD = `perf:{쇼핑몰}:{항목}` — 암호문을 다른 칸으로 옮기면 복호화 실패. +- 화면으로는 secret 항목의 **저장 여부만** 보낸다(원문·일부·길이 X). 일반 항목(Vendor ID 등)만 원문 표시. +- 빈 칸 저장 = 기존 값 유지. 선택 항목은 "저장된 값 지우기". +- 저장 정책: [연결 테스트]는 **입력한 새 값으로 시험하고 저장하지 않음**(상태도 기록 안 함). [저장]은 테스트 결과와 무관하게 + 저장(쇼핑몰 일시 장애 대비) 후 자동으로 저장값 연결 테스트. +- 오류 메시지·로그·`raw_data` 는 `security/redact.py` 로 key/secret/token/password/Authorization/Cookie 를 가린 뒤 저장. +- 쇼핑몰 API 는 **백엔드에서만** 호출. 브라우저는 `/performance/api/*` 만 부른다. + +### 마스터 키 + +| 변수 | 설명 | +|---|---| +| `APP_ENCRYPTION_KEY` | 현재 키(32바이트: `openssl rand -hex 32` 64자 hex 또는 base64). **DB·Git 에 넣지 않는다** | +| `APP_ENCRYPTION_KEY_VERSION` | 현재 키 버전(기본 1) | +| `APP_ENCRYPTION_KEY_V{n}` | 교체 중 남겨 두는 예전 키 | + +교체 절차: 새 키를 `APP_ENCRYPTION_KEY`, 버전 +1, 예전 키를 `APP_ENCRYPTION_KEY_V{예전}` 에 → 재기동 → +설정 화면 [현재 키로 다시 암호화](`POST /performance/api/rekey`) → 예전 버전 0개 확인 후 `_V{n}` 삭제. +**키를 잃으면 저장된 인증정보는 복구할 수 없다** — 키는 서버 `.env` 와 별도 안전한 곳에 백업한다 +(DB 백업만으로는 복호화 불가 — 의도된 설계). + +## 5. 권한 (서버에서 검사) + +| 기능 | 권한 | +|---|---| +| 대시보드 · 매출 업데이트 · 금액 상세 | `performance` (admin 자동) | +| 설정 화면 · 수수료 · 인증정보 · 연결 테스트 · 테스트 데이터 · 재암호화 | `is_admin` | + +화면에서 설정 탭을 숨기는 것과 별개로 모든 설정 API 가 `common.require_store(admin=True)` 로 403 을 낸다. + +## 6. 동기화 (`sync.py`) + +- `SyncService.sync_all()` / `sync_marketplace()` — 버튼·향후 cron/worker 공용. 기본 기간: 오늘 포함 최근 + `PERFORMANCE_SYNC_DAYS`(기본 7)일. +- 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리). +- 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고 + 상단에 오류 쇼핑몰만 표시. +- 중복 방지: `UNIQUE(marketplace_code, event_type, external_event_id)` + `ON CONFLICT DO UPDATE`. + +## 7. 화면 + +- **대시보드** `/performance/?period=day|week|month|year|custom&d=&from=&to=&m=<쇼핑몰>…` + 기간 버튼(오늘/이번주/이번달/올해/직접선택) + 이전/다음, 쇼핑몰 필터, KPI 5개, 일자×쇼핑몰 표(주간합계·기간합계, 연간은 월 행), + [총매출|수수료|수수료 차감 매출] 전환(서버가 세 값을 다 그리고 CSS 로 전환, 선택은 localStorage), 일별 추이·쇼핑몰 비중(SVG), + 월 누적(비중), 연간 누적(월별, 지나지 않은 달 빈칸). 금액 클릭 → 주문 상세(`GET /api/events`, 31일 이내). +- **설정** `/performance/settings` — 사용/매출 집계 토글, 수수료율(적용 시작일·이력), API 설정 창, 연결 상태 + (정상/미설정/인증 실패/Token 만료/API 오류/연동 준비 중/사용 중지, 마지막 테스트·동기화, 최근 오류), 마스터 키 상태·재암호화, + 테스트 데이터 생성/삭제(`is_sample`). + +## 8. 테스트 + +```bash +python -m app.modules.performance.tests.test_performance # 또는 pytest +``` + +암호화(왕복·AAD·변조·키 교체), 가리기, 수수료 반올림·요율 이력, 기간/주 계산, 표·누적 합계, 인증정보 비노출·재암호화, +동기화 격리·가리기·중복 방지·매출 기준일, 모의 데이터를 DB/네트워크 없이 검증한다. diff --git a/docs/PROJECT_OVERVIEW.md b/docs/PROJECT_OVERVIEW.md index 47dbd06..58e040c 100644 --- a/docs/PROJECT_OVERVIEW.md +++ b/docs/PROJECT_OVERVIEW.md @@ -21,13 +21,14 @@ | 쿠팡 밀크런 | 쿠팡 출고 일정 관리 (`app/modules/cupang/`) — 월간 달력 / 출고 묶음(헤더+라인) / 상자 입수량 자동계산 / 로켓 매출 관리 / 엑셀 내보내기. 상품은 `itemcode_db` 읽기 전용 참조 | | 휴가 (준비중) | 연차/반차/특별휴가 신청·잔여일수 관리 | | 말레이시아 재고 | 말레이시아 창고 재고관리 (`app/modules/malaysia/`) — 낱개 입출고/조정, 세트 BOM, 일일 재고조사(세트 분해 자동 반영), 현재고 현황. 상품명은 `itemcode_db` 읽기 전용 참조 | +| 실적 | 쇼핑몰 통합 매출 (`app/modules/performance/`) — 쇼핑몰별 어댑터로 수집 → `performance_db` 저장 → 일자×쇼핑몰 표·KPI·월/연 누적·그래프. 수수료율 이력, API 인증정보는 설정 화면 입력 + AES-256-GCM 암호화 저장. 1단계는 모의 데이터·구조까지(실제 API 는 쇼핑몰별로 순차 연동). `docs/PERFORMANCE_MODULE.md` | ### 권한 키 (`MODULE_KEYS`) | 키 | 종류 | 설명 | | --- | --- | --- | | `corm` / `order` | 접근 | 외부 모듈 진입 | -| `expense` / `vacation` / `cupang` / `malaysia` | 접근 | 내부 모듈 진입 | +| `expense` / `vacation` / `cupang` / `malaysia` / `performance` | 접근 | 내부 모듈 진입 (`performance` 설정 화면·API 는 추가로 `admin` 필요) | | `expense_approver` | 결재 | 개인경비 승인/반려/정산 | | `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) | @@ -91,6 +92,7 @@ app/modules// | `cupang_db` | 쿠팡 밀크런 출고/입고센터/박스규칙 (`CUPANG_DB_URL` 필수, JSON 폴백 없음) | | `vacation_db` | 휴가 신청/공휴일/연차잔여 (`VACATION_DB_URL` 필수, JSON 폴백 없음) | | `malaysia_stock_db` | 말레이시아 창고 재고/세트BOM/재고조사 (`MALAYSIA_STOCK_DB_URL` 필수, JSON 폴백 없음) | +| `performance_db` | 실적 — 쇼핑몰 설정/수수료 이력/인증정보(암호문)/매출 사건 (`PERFORMANCE_DB_URL` 필수, JSON 폴백 없음) | > 신규 DB가 필요하면 **승인 요청 후** 생성하며, 이름은 `_db`로 끝낸다. 상세는 `DATABASES.md`. diff --git a/scripts/sql/performance_db_init.sql b/scripts/sql/performance_db_init.sql new file mode 100644 index 0000000..175ad01 --- /dev/null +++ b/scripts/sql/performance_db_init.sql @@ -0,0 +1,223 @@ +-- ===================================================================== +-- performance_db 초기화 스크립트 (PostgreSQL) — 실적(쇼핑몰 통합 매출) 모듈 +-- ===================================================================== +-- 멱등(idempotent): 여러 번 실행해도 안전. 기존 데이터를 삭제하지 않는다. +-- +-- ⚠️ 실행 전 사용자 승인 + 백업 확인 필수. DROP/TRUNCATE 없음. +-- +-- 실행 방법 (운영 PostgreSQL 컨테이너명: postgres-db): +-- +-- 1) DB / 역할 / 스키마 생성 (superuser 로 1회) +-- read -s -p "performance_app password: " APP_PWD; echo +-- docker exec -i postgres-db psql -U postgres \ +-- -v app_password="$APP_PWD" \ +-- < scripts/sql/performance_db_init.sql +-- +-- 2) main-app .env 에 추가 +-- PERFORMANCE_DB_URL=postgresql://performance_app:@postgres-db:5432/performance_db +-- APP_ENCRYPTION_KEY=$(openssl rand -hex 32) # 쇼핑몰 인증정보 암호화 마스터 키 +-- APP_ENCRYPTION_KEY_VERSION=1 +-- +-- 3) main-app 재기동 +-- cd /opt/www/main && docker compose up -d --build +-- +-- 주의: +-- - 기존 DB 가 있으면 DROP 하지 않는다(CREATE DATABASE 는 미존재 시에만). +-- - 비밀번호는 절대 Git 에 커밋하지 않는다. psql -v 로만 전달. +-- - 쇼핑몰 API 인증정보는 이 DB 에 **암호문**으로만 들어간다(perf_credentials). +-- 암호화 마스터 키(APP_ENCRYPTION_KEY)는 DB 에 저장하지 않는다. +-- ===================================================================== + +\set ON_ERROR_STOP on + +SELECT 'CREATE DATABASE performance_db ENCODING ''UTF8'' TEMPLATE template0' +WHERE NOT EXISTS (SELECT 1 FROM pg_database WHERE datname = 'performance_db') +\gexec + +SELECT 'CREATE ROLE performance_app LOGIN PASSWORD ' || quote_literal(:'app_password') +WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'performance_app') +\gexec + +SELECT 'ALTER ROLE performance_app WITH LOGIN PASSWORD ' || quote_literal(:'app_password') +\gexec + +GRANT CONNECT ON DATABASE performance_db TO performance_app; + +\connect performance_db + +CREATE OR REPLACE FUNCTION perf_set_updated_at() RETURNS trigger AS $$ +BEGIN + NEW.updated_at := now(); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +-- ════════════════════════════════════════════════════════════ +-- 1) 쇼핑몰 기본 설정 — 사용 여부 / 매출 집계 여부 / 표시 순서 +-- 어댑터(코드)가 쇼핑몰의 "종류"를 정의하고, 이 표는 운영 설정만 담는다. +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_marketplaces ( + code TEXT PRIMARY KEY, + name TEXT NOT NULL, + enabled BOOLEAN NOT NULL DEFAULT TRUE, + include_in_sales BOOLEAN NOT NULL DEFAULT TRUE, + sort_order INTEGER NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +DROP TRIGGER IF EXISTS trg_perf_marketplaces_updated ON perf_marketplaces; +CREATE TRIGGER trg_perf_marketplaces_updated + BEFORE UPDATE ON perf_marketplaces + FOR EACH ROW EXECUTE FUNCTION perf_set_updated_at(); + +INSERT INTO perf_marketplaces (code, name, sort_order) VALUES + ('cafe24', '카페24', 10), + ('naver', '네이버 스마트스토어', 20), + ('coupang', '쿠팡', 30), + ('ohouse', '오늘의집', 40), + ('gmarket', 'G마켓', 50), + ('kakao', '카카오', 60), + ('gsshop', 'GS샵', 70), + ('elevenst', '11번가', 80), + ('lotteon', '롯데ON', 90), + ('toss', '토스쇼핑', 100) +ON CONFLICT (code) DO NOTHING; + +-- ════════════════════════════════════════════════════════════ +-- 2) 수수료율 이력 — 적용 시작일(effective_from)부터 다음 변경 전까지 그 요율. +-- 과거 실적은 그 날짜에 유효했던 요율로 계산한다(요율을 바꿔도 과거가 안 바뀜). +-- rule_type 은 향후 상품별/카테고리별/정액 수수료 확장용(현재 'marketplace' 만). +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_commission_rates ( + id BIGSERIAL PRIMARY KEY, + marketplace_code TEXT NOT NULL REFERENCES perf_marketplaces(code), + rule_type TEXT NOT NULL DEFAULT 'marketplace' + CHECK (rule_type IN ('marketplace')), + rate_percent NUMERIC(7,3) NOT NULL CHECK (rate_percent >= 0 AND rate_percent <= 100), + effective_from DATE NOT NULL, + memo TEXT NOT NULL DEFAULT '', + created_by TEXT NOT NULL DEFAULT '', + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + UNIQUE (marketplace_code, rule_type, effective_from) +); +CREATE INDEX IF NOT EXISTS idx_perf_rates_code_from + ON perf_commission_rates (marketplace_code, effective_from DESC); + +-- ════════════════════════════════════════════════════════════ +-- 3) 쇼핑몰 API 인증정보 — 항목 하나 = 행 하나, 값은 AES-256-GCM 암호문. +-- encrypted_value 형식: "v{키버전}:{base64url(nonce + 암호문 + tag)}" +-- key_version 은 마스터 키 교체(rotation) 때 재암호화 대상을 찾는 데 쓴다. +-- access/refresh token 도 여기에 같은 방식으로 저장한다. +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_credentials ( + marketplace_code TEXT NOT NULL REFERENCES perf_marketplaces(code), + credential_key TEXT NOT NULL, + encrypted_value TEXT NOT NULL, + key_version INTEGER NOT NULL, + updated_by TEXT NOT NULL DEFAULT '', + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (marketplace_code, credential_key) +); +DROP TRIGGER IF EXISTS trg_perf_credentials_updated ON perf_credentials; +CREATE TRIGGER trg_perf_credentials_updated + BEFORE UPDATE ON perf_credentials + FOR EACH ROW EXECUTE FUNCTION perf_set_updated_at(); + +-- ════════════════════════════════════════════════════════════ +-- 4) 연결 상태 — 연결 테스트/동기화 결과. last_error 는 비밀값을 가린 문구만. +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_connection_status ( + marketplace_code TEXT PRIMARY KEY REFERENCES perf_marketplaces(code), + status TEXT NOT NULL DEFAULT 'unknown' + CHECK (status IN ('ok', 'not_configured', 'auth_failed', 'token_expired', + 'api_error', 'not_implemented', 'unknown')), + last_test_at TIMESTAMPTZ, + last_test_ok BOOLEAN, + last_sync_at TIMESTAMPTZ, + last_success_sync_at TIMESTAMPTZ, + last_error TEXT NOT NULL DEFAULT '', + last_error_at TIMESTAMPTZ, + updated_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +DROP TRIGGER IF EXISTS trg_perf_status_updated ON perf_connection_status; +CREATE TRIGGER trg_perf_status_updated + BEFORE UPDATE ON perf_connection_status + FOR EACH ROW EXECUTE FUNCTION perf_set_updated_at(); + +-- ════════════════════════════════════════════════════════════ +-- 5) 매출 사건 — 결제(+), 취소(-), 반품(-). 금액은 원 단위 정수(BIGINT). +-- sales_date = 집계 기준일. 결제는 결제일, 취소·반품은 발생일 +-- (지난 실적이 나중에 바뀌지 않게). order_date/payment_date 는 원래 날짜를 +-- 따로 보관해 기준을 바꿀 수 있게 한다. +-- 중복 방지: UNIQUE(쇼핑몰, 사건 종류, 외부 사건 ID) — 같은 사건은 덮어쓴다. +-- raw_data 는 비밀값을 가린 원본. is_sample = 테스트(모의) 데이터. +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_sales_events ( + id BIGSERIAL PRIMARY KEY, + marketplace_code TEXT NOT NULL REFERENCES perf_marketplaces(code), + event_type TEXT NOT NULL CHECK (event_type IN ('SALE', 'CANCEL', 'RETURN', 'ADJUST')), + external_event_id TEXT NOT NULL, + external_order_id TEXT NOT NULL, + external_line_id TEXT NOT NULL DEFAULT '', + order_date DATE, + payment_date DATE, + event_date DATE NOT NULL, + sales_date DATE NOT NULL, + product_name TEXT NOT NULL DEFAULT '', + option_name TEXT NOT NULL DEFAULT '', + quantity INTEGER NOT NULL DEFAULT 0, + amount BIGINT NOT NULL, + discount_amount BIGINT NOT NULL DEFAULT 0, + order_status TEXT NOT NULL DEFAULT '', + raw_data JSONB, + is_sample BOOLEAN NOT NULL DEFAULT FALSE, + synced_at TIMESTAMPTZ NOT NULL DEFAULT now(), + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + UNIQUE (marketplace_code, event_type, external_event_id) +); +CREATE INDEX IF NOT EXISTS idx_perf_events_date_code ON perf_sales_events (sales_date, marketplace_code); +CREATE INDEX IF NOT EXISTS idx_perf_events_order ON perf_sales_events (marketplace_code, external_order_id); +CREATE INDEX IF NOT EXISTS idx_perf_events_sample ON perf_sales_events (is_sample) WHERE is_sample; +DROP TRIGGER IF EXISTS trg_perf_events_updated ON perf_sales_events; +CREATE TRIGGER trg_perf_events_updated + BEFORE UPDATE ON perf_sales_events + FOR EACH ROW EXECUTE FUNCTION perf_set_updated_at(); + +-- ════════════════════════════════════════════════════════════ +-- 6) 동기화 실행 기록 — 같은 쇼핑몰은 동시에 하나만(running 부분 유니크 인덱스). +-- 웹/스케줄러 어디서 돌려도 중복 실행이 막힌다. +-- ════════════════════════════════════════════════════════════ +CREATE TABLE IF NOT EXISTS perf_sync_runs ( + id BIGSERIAL PRIMARY KEY, + marketplace_code TEXT NOT NULL REFERENCES perf_marketplaces(code), + trigger TEXT NOT NULL DEFAULT 'manual' CHECK (trigger IN ('manual', 'schedule')), + range_from DATE, + range_to DATE, + status TEXT NOT NULL DEFAULT 'running' + CHECK (status IN ('running', 'success', 'failed')), + fetched_count INTEGER NOT NULL DEFAULT 0, + upserted_count INTEGER NOT NULL DEFAULT 0, + error TEXT NOT NULL DEFAULT '', + started_by TEXT NOT NULL DEFAULT '', + started_at TIMESTAMPTZ NOT NULL DEFAULT now(), + finished_at TIMESTAMPTZ +); +CREATE UNIQUE INDEX IF NOT EXISTS uq_perf_sync_running + ON perf_sync_runs (marketplace_code) WHERE status = 'running'; +CREATE INDEX IF NOT EXISTS idx_perf_sync_runs_code ON perf_sync_runs (marketplace_code, started_at DESC); + +-- ════════════════════════════════════════════════════════════ +-- 권한 — 앱 계정은 DML 만 +-- ════════════════════════════════════════════════════════════ +GRANT USAGE ON SCHEMA public TO performance_app; +GRANT SELECT, INSERT, UPDATE, DELETE ON + perf_marketplaces, perf_commission_rates, perf_credentials, + perf_connection_status, perf_sales_events, perf_sync_runs + TO performance_app; +GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO performance_app; +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO performance_app; +ALTER DEFAULT PRIVILEGES IN SCHEMA public + GRANT USAGE, SELECT ON SEQUENCES TO performance_app; From 6e175d0bac3f9e30a87409d42803c05da1a6869c Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:16:07 +0900 Subject: [PATCH 02/30] =?UTF-8?q?fix(performance):=20=EB=A7=A4=EC=B6=9C=20?= =?UTF-8?q?=EC=97=85=EB=8D=B0=EC=9D=B4=ED=8A=B8=20=EA=B2=B0=EA=B3=BC=20?= =?UTF-8?q?=E2=80=94=20=EC=9D=B8=EC=A6=9D=EC=A0=95=EB=B3=B4=20=EB=AF=B8?= =?UTF-8?q?=EC=84=A4=EC=A0=95=20=EC=87=BC=ED=95=91=EB=AA=B0=EC=9D=80=20?= =?UTF-8?q?=EC=8B=A4=ED=8C=A8(=EB=B9=A8=EA=B0=95)=EA=B0=80=20=EC=95=84?= =?UTF-8?q?=EB=8B=8C=20=ED=9A=8C=EC=83=89=20=ED=95=9C=20=EC=A4=84=EB=A1=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 실패는 인증 실패·API 오류처럼 손봐야 하는 것만 표시. 미설정/연동 준비 중은 이름만 모아 표시. Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/templates/performance/index.html | 2 +- app/modules/performance/templates/performance/settings.html | 2 +- app/static/performance.js | 6 +++++- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index c6a0b21..ef87ca1 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 39f2a7d..2cdec23 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -118,4 +118,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/static/performance.js b/app/static/performance.js index aea815b..e61f20d 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -127,13 +127,16 @@ syncBtn.textContent = "업데이트 중…"; try { const res = await api("POST", "/performance/api/sync", {}); - const ok = [], bad = [], pending = [], busy = []; + // 실패(빨강)는 인증 실패·API 오류처럼 손봐야 하는 것만. 인증정보를 아직 안 넣은 쇼핑몰(미설정)과 + // 수집을 아직 만들지 않은 쇼핑몰(연동 준비 중)은 회색 한 줄로 이름만. + const ok = [], bad = [], pending = [], unset = [], busy = []; let changed = 0; (res.results || []).forEach(function (r) { const name = (data.names || {})[r.code] || r.code; if (r.skipped) busy.push(name); else if (r.ok) { ok.push(name + " " + fmt(r.upserted) + "건"); changed += r.upserted; } else if (r.status === "not_implemented") pending.push(name); + else if (r.status === "not_configured") unset.push(name); else bad.push(name + "(" + (r.label || r.status) + (r.message ? ": " + r.message : "") + ")"); }); const parts = []; @@ -141,6 +144,7 @@ if (bad.length) parts.push("실패 " + esc(bad.join(", "))); if (busy.length) parts.push("이미 진행 중 " + esc(busy.join(", "))); if (pending.length) parts.push('연동 준비 중: ' + esc(pending.join(", ")) + ""); + if (unset.length) parts.push('인증정보 미설정: ' + esc(unset.join(", ")) + ""); resultBox.innerHTML = parts.join(" · ") || "업데이트할 쇼핑몰이 없습니다."; resultBox.className = "perf-notice" + (bad.length ? " is-warn" : " is-ok"); resultBox.hidden = false; From 04a1fddd95664acb51169bb22018e1d4991dd88d Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:25:25 +0900 Subject: [PATCH 03/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EC=A3=BC=EB=AC=B8=20=EB=A7=A4=EC=B6=9C=20=EC=88=98=EC=A7=91?= =?UTF-8?q?=20=EC=97=B0=EB=8F=99=20+=20=EA=B3=BC=EA=B1=B0=20=EB=A7=A4?= =?UTF-8?q?=EC=B6=9C=20=EA=B0=80=EC=A0=B8=EC=98=A4=EA=B8=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 카페24 (Admin API GET /admin/orders, 문서 2026-09-01 기준) - 결제(SALE): date_type=pay_date, embed=items — 결제된 주문의 품목 결제금액(할인 반영·배송비 제외), 결제일 - 취소(CANCEL): cancel_complete_date, 품목 C40~C43 만 음수(입금전취소 C47~C49 제외) - 반품(RETURN): return_complete_date, 품목 R40~R43 음수, 부분 반품은 claim_quantity 비율 - 자체몰 주문만(market_id=self) — 카페24로 연동된 다른 마켓 주문은 이중 집계 방지로 제외 - 60일 단위 분할(한 호출 3개월 미만), limit 1000 페이지 넘김, 개인정보 미저장(raw 는 금액·상태만) - 기존 app/integrations/cafe24 토큰·클라이언트 재사용, 연결 테스트는 주문 권한까지 확인 - DEFAULT_SCOPES 에 mall.read_order 추가(읽기만) — 카페24 상품관리 → 시스템에서 재연결 필요 과거 매출 가져오기(설정, 관리자): 기간 지정 수집(최대 366일), 일반 사용자는 403 Co-Authored-By: Claude Opus 5.5 --- app/integrations/cafe24/config.py | 5 +- app/modules/performance/adapters/cafe24.py | 243 ++++++++++++++++-- app/modules/performance/router.py | 19 +- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 15 +- .../performance/tests/test_performance.py | 85 ++++++ app/static/performance.js | 40 +++ docs/CAFE24_MODULE.md | 11 +- docs/PERFORMANCE_MODULE.md | 26 +- 9 files changed, 414 insertions(+), 32 deletions(-) diff --git a/app/integrations/cafe24/config.py b/app/integrations/cafe24/config.py index efa98fb..ad80757 100644 --- a/app/integrations/cafe24/config.py +++ b/app/integrations/cafe24/config.py @@ -33,7 +33,10 @@ STORE_SCOPES: tuple[str, ...] = ("mall.read_store", "mall.write_store") # 실제로 요청하는 scope 묶음. 개발자센터 앱에 등록된 권한과 어긋나면 인증이 # 거부되므로, 여기에 추가할 때는 앱 권한도 함께 확인해야 한다. # 쓰지 않는 권한은 요청하지 않는다 — 토큰이 유출돼도 피해 범위를 좁히기 위함. -DEFAULT_SCOPES: tuple[str, ...] = PRODUCT_SCOPES +# 주문은 읽기만(실적 모듈의 매출 수집) — 앱에 쓰기 권한이 있어도 요청하지 않는다. +# 이 목록을 바꾸면 카페24 상품관리 → 시스템에서 한 번 다시 연결해야 새 권한이 토큰에 붙는다 +# (기존 토큰은 예전 권한 그대로 계속 동작). +DEFAULT_SCOPES: tuple[str, ...] = PRODUCT_SCOPES + ("mall.read_order",) DEFAULT_API_VERSION = "2026-03-01" diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index d931d8e..85cc105 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -1,49 +1,252 @@ """카페24 — 공통 연동 계층(app/integrations/cafe24) 재사용. 카페24는 이미 OAuth 로 연결해 쓰고 있다(상품관리). 실적 설정에서 인증정보를 따로 -받지 않고, 같은 토큰 저장소(cafe24_db)의 연결 상태를 그대로 보여 준다. -주문 수집(다음 단계)에는 카페24 앱 권한에 mall.read_order 추가 + 재연결이 필요하다 -(app/integrations/cafe24/config.py 의 ORDER_SCOPES). +받지 않고, 같은 토큰 저장소(cafe24_db)와 클라이언트(재시도·429·토큰 자동 갱신)를 쓴다. +주문 읽기 권한(mall.read_order)이 필요하다 — config.DEFAULT_SCOPES 에 포함, 권한 추가 후 +카페24 상품관리 → 시스템에서 한 번 다시 연결해야 한다. + +수집 규칙 (Admin API GET /admin/orders, 문서 버전 2026-09-01 확인) + - 결제(SALE): date_type=pay_date(결제일), embed=items. 결제된(paid=T) 주문의 품목마다 + 품목 결제금액(payment_amount — 할인 반영, 배송비 제외)을 매출로. 사건 날짜 = 결제일. + - 취소(CANCEL): date_type=cancel_complete_date. 품목 상태 C40~C43(취소완료)만, + 결제 때와 같은 품목 금액을 음수로. 입금전취소(C47~C49)는 매출이 아니었으므로 제외. + - 반품(RETURN): date_type=return_complete_date. 품목 상태 R40~R43(반품완료)만 음수로. + 부분 반품(0 < claim_quantity < quantity)은 수량 비율로 나눈다. + - 교환(E**)은 매출 변화 없음으로 보고 1단계에서는 반영하지 않는다. + - 자체몰 주문만(market_id 가 self/빈값). 카페24 로 들어온 다른 마켓(스마트스토어·쿠팡 등) + 주문은 해당 쇼핑몰 어댑터와 이중 집계되지 않게 제외한다. 네이버페이 결제는 자체몰 주문이라 포함. + - 한 호출 검색기간 3개월 미만 → 60일씩 나눠 요청. limit 최대 1000, offset 최대 15000. + - 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않는다 — raw 에는 금액·상태 필드만. """ from __future__ import annotations -from .base import AdapterContext, AuthFailed, MarketplaceAdapter, NotConfigured, TokenExpired +from datetime import date, timedelta +from decimal import ROUND_HALF_UP, Decimal, InvalidOperation +from typing import Any, Iterable + +from .base import ( + AdapterContext, + ApiError, + AuthFailed, + MarketplaceAdapter, + NotConfigured, + SaleEvent, + TokenExpired, +) + +ORDER_SCOPE = "mall.read_order" +PAGE_LIMIT = 1000 +MAX_OFFSET = 15000 +CHUNK_DAYS = 60 +CANCEL_DONE = {"C40", "C41", "C42", "C43"} +RETURN_DONE = {"R40", "R41", "R42", "R43"} +SELF_MARKETS = {"", "self", None} + + +def _won(value: Any) -> int: + """카페24 금액 문자열("29000.00") → 원 단위 정수.""" + try: + return int(Decimal(str(value or "0")).quantize(Decimal(1), rounding=ROUND_HALF_UP)) + except (InvalidOperation, ValueError): + return 0 + + +def _day(value: Any) -> date | None: + """"2018-07-04T11:21:35+09:00" / "2017-07-10 15:55:51" → date (카페24 는 KST 로 준다).""" + s = str(value or "").strip() + if len(s) < 10: + return None + try: + return date.fromisoformat(s[:10]) + except ValueError: + return None + + +def item_amount(item: dict[str, Any]) -> int: + """품목 결제금액. payment_amount 가 없으면 (판매가+옵션가)×수량 − 품목 할인으로 계산.""" + if item.get("payment_amount") not in (None, ""): + return _won(item["payment_amount"]) + qty = int(item.get("quantity") or 0) + gross = (_won(item.get("product_price")) + _won(item.get("option_price"))) * qty + discounts = (_won(item.get("additional_discount_price")) + _won(item.get("coupon_discount_price")) + + _won(item.get("app_item_discount_amount"))) + return max(0, gross - discounts) + + +def _raw(order: dict[str, Any], item: dict[str, Any]) -> dict[str, Any]: + """저장용 원본 — 금액·상태만(개인정보 제외).""" + keys = ("order_item_code", "order_status", "status_code", "product_no", "product_code", "variant_code", + "product_price", "option_price", "quantity", "claim_quantity", "additional_discount_price", + "coupon_discount_price", "app_item_discount_amount", "payment_amount", "claim_code") + return { + "order_id": order.get("order_id"), "market_id": order.get("market_id"), + "order_place_id": order.get("order_place_id"), "paid": order.get("paid"), + **{k: item.get(k) for k in keys}, + } class Cafe24Adapter(MarketplaceAdapter): code = "cafe24" name = "카페24" auth_type = "shared" - docs_url = "https://developers.cafe24.com/docs/api/admin/" - note = "카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음)." + implemented = True + docs_url = "https://apidocs.cafe24.com/docs/admin/get-orders" + note = ("카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음). " + "주문 읽기 권한이 필요해 권한 추가 후 한 번 다시 연결해야 합니다.") + # ── 연결 ────────────────────────────────────────────── def is_configured(self, ctx: AdapterContext) -> bool: return True + def _repo(self, ctx: AdapterContext): + return getattr(ctx.app_state, "cafe24_store", None) if ctx.app_state is not None else None + + def shared_status(self, ctx: AdapterContext) -> dict: + from app.integrations.cafe24.config import load_config # 지연 import + from app.integrations.cafe24.tokens import TokenService # 지연 import + + repo = self._repo(ctx) + config = load_config() + if repo is None: + return {"connected": False, "missing": config.missing or ["CAFE24_DB_URL"], "needs_reauth": False} + return TokenService(repo, config).status() + def authenticate(self, ctx: AdapterContext) -> None: st = self.shared_status(ctx) if not st.get("connected"): if st.get("missing"): raise NotConfigured("카페24 연동 환경변수가 설정되지 않았습니다.") - if st.get("needs_reauth") and st.get("reason", "").startswith("refresh"): + if st.get("needs_reauth") and str(st.get("reason", "")).startswith("refresh"): raise TokenExpired("카페24 연결이 만료되었습니다. 카페24 상품관리 → 시스템에서 재연결하세요.") raise AuthFailed("카페24에 연결되어 있지 않습니다. 카페24 상품관리 → 시스템에서 연결하세요.") + if ORDER_SCOPE not in str(st.get("scopes") or ""): + raise AuthFailed("카페24 토큰에 주문 읽기 권한(mall.read_order)이 없습니다. " + "카페24 상품관리 → 시스템에서 다시 연결하세요.") - def shared_status(self, ctx: AdapterContext) -> dict: - from app.integrations.cafe24.config import load_config # 지연 import - from app.integrations.cafe24.tokens import TokenService # 지연 import + def _client(self, ctx: AdapterContext): + from app.integrations.cafe24 import build_cafe24_api # 지연 import - repo = getattr(ctx.app_state, "cafe24_store", None) if ctx.app_state is not None else None - config = load_config() - if repo is None: - return {"connected": False, "missing": config.missing or ["CAFE24_DB_URL"], "needs_reauth": False} - return TokenService(repo, config).status() + return build_cafe24_api(self._repo(ctx)).client + + def _get(self, ctx: AdapterContext, params: dict[str, Any]) -> dict[str, Any]: + from app.integrations.cafe24.errors import ( # 지연 import + Cafe24ApiError, + Cafe24AuthError, + Cafe24ConfigError, + Cafe24RateLimitError, + ) + + try: + return self._client(ctx).get("/admin/orders", params=params) + except Cafe24ConfigError as exc: + raise NotConfigured(str(exc)) from None + except Cafe24AuthError as exc: + raise AuthFailed(str(exc)) from None + except Cafe24RateLimitError as exc: + raise ApiError(f"카페24 호출 제한(429): {exc}") from None + except Cafe24ApiError as exc: + status = getattr(exc, "status", None) + if status == 403: + raise AuthFailed(f"카페24 권한 오류(403): {exc}. 주문 권한 추가 후 재연결하세요.") from None + raise ApiError(f"카페24 API 오류({status}): {exc}") from None def test_connection(self, ctx: AdapterContext) -> str: + from app.timezone import today_kst # noqa: WPS433 + self.authenticate(ctx) - st = self.shared_status(ctx) - scopes = st.get("scopes") or "" - if "mall.read_order" not in scopes: - return "카페24 연결 정상. 주문 수집에는 주문 읽기 권한(mall.read_order) 추가가 필요합니다." - return "카페24 연결 정상." + today = today_kst() + self._get(ctx, {"start_date": today.isoformat(), "end_date": today.isoformat(), + "date_type": "pay_date", "limit": 1}) + return "카페24 연결 정상(주문 조회 권한 확인)." + + # ── 수집 ────────────────────────────────────────────── + def _orders(self, ctx: AdapterContext, start: date, end: date, date_type: str) -> Iterable[dict[str, Any]]: + """기간을 60일씩 나눠 페이지를 넘기며 주문(+items)을 모두 가져온다.""" + s = start + while s <= end: + e = min(end, s + timedelta(days=CHUNK_DAYS - 1)) + offset = 0 + while True: + if offset > MAX_OFFSET: + raise ApiError(f"카페24 조회 건수가 너무 많습니다({s}~{e}). 기간을 줄여 다시 시도하세요.") + data = self._get(ctx, {"start_date": s.isoformat(), "end_date": e.isoformat(), + "date_type": date_type, "embed": "items", + "limit": PAGE_LIMIT, "offset": offset}) + orders = data.get("orders") or [] + yield from orders + if len(orders) < PAGE_LIMIT: + break + offset += PAGE_LIMIT + s = e + timedelta(days=1) + + def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + for o in self._orders(ctx, start, end, "pay_date"): + yield {"kind": "paid", "order": o} + + def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + for o in self._orders(ctx, start, end, "cancel_complete_date"): + yield {"kind": "cancel", "order": o} + for o in self._orders(ctx, start, end, "return_complete_date"): + yield {"kind": "return", "order": o} + + @staticmethod + def _is_self_order(order: dict[str, Any]) -> bool: + return order.get("market_id") in SELF_MARKETS + + def normalize_order(self, raw: dict[str, Any]) -> list[SaleEvent]: + order = raw.get("order") or {} + if not self._is_self_order(order) or order.get("paid") != "T": + return [] + pay_day = _day(order.get("payment_date")) + if pay_day is None: + return [] + order_id = str(order.get("order_id") or "") + events = [] + for item in order.get("items") or []: + code = str(item.get("order_item_code") or "") + if not code: + continue + events.append(SaleEvent( + event_type="SALE", external_event_id=f"{code}-S", external_order_id=order_id, + external_line_id=code, order_date=_day(order.get("order_date")), payment_date=pay_day, + event_date=pay_day, amount=item_amount(item), product_name=str(item.get("product_name") or ""), + option_name=str(item.get("option_value") or "") if isinstance(item.get("option_value"), str) else "", + quantity=int(item.get("quantity") or 0), order_status=str(item.get("order_status") or ""), + raw=_raw(order, item), + )) + return events + + def normalize_refund(self, raw: dict[str, Any]) -> list[SaleEvent]: + order = raw.get("order") or {} + if not self._is_self_order(order): + return [] + kind = raw.get("kind") + done, ev_type, suffix = (CANCEL_DONE, "CANCEL", "C") if kind == "cancel" else (RETURN_DONE, "RETURN", "R") + order_id = str(order.get("order_id") or "") + events = [] + for item in order.get("items") or []: + code = str(item.get("order_item_code") or "") + status = str(item.get("order_status") or "") + if not code or status not in done: + continue + if kind == "cancel": + day = _day(item.get("cancel_date")) or _day(order.get("cancel_date")) + else: + day = _day(item.get("return_confirmed_date")) or _day(item.get("refund_date")) + if day is None: + continue + amount = item_amount(item) + qty = int(item.get("quantity") or 0) + claim = int(item.get("claim_quantity") or 0) + if kind == "return" and 0 < claim < qty: + amount = int((Decimal(amount) * claim / qty).quantize(Decimal(1), rounding=ROUND_HALF_UP)) + qty = claim + events.append(SaleEvent( + event_type=ev_type, external_event_id=f"{code}-{suffix}", external_order_id=order_id, + external_line_id=code, order_date=_day(order.get("order_date")), + payment_date=_day(order.get("payment_date")), event_date=day, amount=-amount, + product_name=str(item.get("product_name") or ""), quantity=-qty, order_status=status, + raw=_raw(order, item), + )) + return events diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py index d5f7ae1..479905d 100644 --- a/app/modules/performance/router.py +++ b/app/modules/performance/router.py @@ -36,6 +36,7 @@ from .adapters.registry import all_adapters, get_adapter router = APIRouter(prefix="/performance", tags=["performance"]) MAX_EVENT_DAYS = 31 +MAX_BACKFILL_DAYS = 366 def _parse_date(value: Any, *, field: str = "날짜") -> date | None: @@ -127,10 +128,26 @@ def settings_page(request: Request): # ════════════════════════════════════════════════════════════ @router.post("/api/sync") def api_sync(request: Request, payload: dict[str, Any] = Body(default={})) -> JSONResponse: + """기본은 최근 N일(PERFORMANCE_SYNC_DAYS). from/to 로 기간을 지정한 수집(과거 매출 가져오기)은 관리자만.""" store, user = common.require_store(request) _, sync = common.services(request, store) codes = [str(c) for c in (payload.get("codes") or []) if get_adapter(str(c))] - results = sync.sync_all(codes=codes or None, user=user["email"]) + start = _parse_date(payload.get("from"), field="시작일") + end = _parse_date(payload.get("to"), field="종료일") + if start or end: + from app.store import is_admin # noqa: WPS433 + + if not is_admin(user): + raise HTTPException(status_code=403, detail="기간을 지정한 수집은 관리자만 할 수 있습니다.") + end = end or today_kst() + start = start or end + if end < start: + start, end = end, start + if end > today_kst(): + end = today_kst() + if (end - start).days + 1 > MAX_BACKFILL_DAYS: + raise HTTPException(status_code=400, detail=f"한 번에 {MAX_BACKFILL_DAYS}일까지 가져올 수 있습니다.") + results = sync.sync_all(start=start, end=end, codes=codes or None, user=user["email"]) return JSONResponse({"results": results, "last_update_at": store.last_update_at()}) diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index ef87ca1..1ba74ca 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 2cdec23..3dc985b 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -102,6 +102,19 @@

+
+

과거 매출 가져오기

+

[매출 업데이트]는 최근 며칠만 가져옵니다. 처음 연동했거나 빠진 기간이 있으면 기간을 지정해 한 번에 + 가져오세요(연동된 쇼핑몰만, 최대 366일). 같은 주문은 덮어써서 여러 번 해도 중복되지 않습니다.

+
+ + ~ + + +
+ +
+

테스트 데이터

현재 {{ "{:,}".format(sample_count) }}건
@@ -118,4 +131,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index bf78aeb..21d494b 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -378,6 +378,91 @@ def test_not_implemented_and_mock(): assert event_row(a[0])["sales_date"] == a[0].payment_date +# ════════════════════════════════════════════════════════════ +# 카페24 어댑터(가짜 API 응답) +# ════════════════════════════════════════════════════════════ +def _c24_item(code, status="N40", price="30000.00", qty=1, pay="29000.00", **kw): + return {"order_item_code": code, "order_status": status, "product_name": "냄비", "option_value": "", + "product_price": price, "option_price": "0.00", "quantity": qty, "payment_amount": pay, + "coupon_discount_price": "1000.00", "claim_quantity": 0, **kw} + + +def _c24_order(oid, items, market="self", paid="T", **kw): + return {"order_id": oid, "market_id": market, "paid": paid, "order_date": "2026-09-27T10:00:00+09:00", + "payment_date": "2026-09-28T11:21:35+09:00", "buyer_name": "홍길동", "receiver_address": "서울시", + "bank_account_no": "1234567890", "items": items, **kw} + + +class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist=["Cafe24Adapter"]).Cafe24Adapter): + def __init__(self, pages): + self.pages = pages # date_type → [응답 orders 목록(페이지별)] + self.calls = [] + + def authenticate(self, ctx): + return None + + def _get(self, ctx, params): + self.calls.append(params) + pages = self.pages.get(params["date_type"], []) + idx = params.get("offset", 0) // 1000 + return {"orders": pages[idx] if idx < len(pages) else []} + + +def test_cafe24_normalize(): + from app.modules.performance.adapters.cafe24 import Cafe24Adapter, item_amount + + paid = _c24_order("20260928-01", [_c24_item("20260928-01-01"), _c24_item("20260928-01-02", pay="10000.00")]) + market = _c24_order("20260928-02", [_c24_item("20260928-02-01")], market="shopn") # 스마트스토어 연동 주문 + unpaid = _c24_order("20260928-03", [_c24_item("20260928-03-01", status="N00")], paid="F") + canceled = _c24_order("20260928-01", [ + _c24_item("20260928-01-01", status="C40", cancel_date="2026-09-29 09:00:00"), + _c24_item("20260928-01-02", status="N40")]) + precancel = _c24_order("20260928-04", [_c24_item("20260928-04-01", status="C48", cancel_date="2026-09-29 09:00:00")]) + returned = _c24_order("20260928-05", [_c24_item("20260928-05-01", status="R40", qty=3, pay="90000.00", + claim_quantity=1, return_confirmed_date="2026-09-30 10:00:00")]) + fake = _FakeCafe24({"pay_date": [[paid, market, unpaid]], + "cancel_complete_date": [[canceled, precancel]], + "return_complete_date": [[returned]]}) + ctx = __import__("app.modules.performance.adapters.base", fromlist=["AdapterContext"]).AdapterContext( + code="cafe24", credentials=None) + fetched, events = fake.collect(ctx, date(2026, 9, 23), date(2026, 9, 30)) + by = {(e.event_type, e.external_line_id): e for e in events} + assert fetched == 6 + assert by[("SALE", "20260928-01-01")].amount == 29_000 and by[("SALE", "20260928-01-02")].amount == 10_000 + assert by[("SALE", "20260928-01-01")].event_date == date(2026, 9, 28) # 결제일 + assert ("SALE", "20260928-02-01") not in by and ("SALE", "20260928-03-01") not in by # 마켓 주문·미결제 제외 + c = by[("CANCEL", "20260928-01-01")] + assert c.amount == -29_000 and c.event_date == date(2026, 9, 29) and c.external_event_id == "20260928-01-01-C" + assert ("CANCEL", "20260928-01-02") not in by and ("CANCEL", "20260928-04-01") not in by # 미취소·입금전취소 제외 + r = by[("RETURN", "20260928-05-01")] + assert r.amount == -30_000 and r.quantity == -1 and r.event_date == date(2026, 9, 30) # 3개 중 1개 반품 + for e in events: + assert "buyer_name" not in e.raw and "receiver_address" not in e.raw and "bank_account_no" not in e.raw + # 금액: payment_amount 없으면 (판매가+옵션)×수량 − 할인 + assert item_amount({"product_price": "10000.00", "option_price": "500.00", "quantity": 2, + "coupon_discount_price": "1000.00"}) == 20_000 + # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) + page1 = [_c24_order(f"x-{i}", []) for i in range(1000)] + fake2 = _FakeCafe24({"pay_date": [page1, [paid]]}) + got = list(fake2.fetch_orders(ctx, date(2026, 7, 1), date(2026, 9, 30))) + pay_calls = [c for c in fake2.calls if c["date_type"] == "pay_date"] + assert len(got) == 2002 # 60일 구간 2개 × (1000건 페이지 + 다음 페이지 1건) + assert pay_calls[0]["start_date"] == "2026-07-01" and pay_calls[0]["end_date"] == "2026-08-29" + assert pay_calls[1]["offset"] == 1000 and all(c["limit"] == 1000 and c["embed"] == "items" for c in pay_calls) + assert any(c["start_date"] == "2026-08-30" for c in pay_calls) + # 주문 권한 없는 토큰 → 인증 실패(재연결 안내) + real = Cafe24Adapter() + real.shared_status = lambda ctx: {"connected": True, "scopes": "mall.read_product,mall.write_product"} + try: + real.authenticate(ctx) + except AuthFailed as exc: + assert "mall.read_order" in exc.message + else: + raise AssertionError("주문 권한 없으면 인증 실패여야 합니다") + real.shared_status = lambda ctx: {"connected": True, "scopes": "mall.read_product,mall.read_order"} + real.authenticate(ctx) + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 diff --git a/app/static/performance.js b/app/static/performance.js index e61f20d..2be3082 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -470,6 +470,46 @@ } finally { btn.disabled = false; btn.textContent = label; } } + // ── 과거 매출 가져오기(기간 지정 수집, 관리자) ── + const backfill = document.getElementById("perf-backfill"); + if (backfill) backfill.addEventListener("click", async function () { + const from = document.getElementById("perf-backfill-from").value; + const to = document.getElementById("perf-backfill-to").value; + const box = document.getElementById("perf-backfill-result"); + if (!from || !to) return; + if (!(await confirmMsg(from + " ~ " + to + " 매출을 연동된 쇼핑몰에서 가져옵니다. 기간이 길면 몇 분 걸릴 수 있습니다."))) return; + const names = {}; + root.querySelectorAll("tr[data-code]").forEach(function (tr) { names[tr.dataset.code] = tr.dataset.name; }); + backfill.disabled = true; + backfill.textContent = "가져오는 중…"; + box.hidden = true; + try { + const res = await api("POST", "/performance/api/sync", { from: from, to: to }); + const ok = [], bad = [], rest = []; + (res.results || []).forEach(function (r) { + const name = names[r.code] || r.code; + if (r.ok) ok.push(name + " " + fmt(r.upserted) + "건"); + else if (r.skipped) rest.push(name + "(이미 진행 중)"); + else if (r.status === "not_implemented" || r.status === "not_configured") rest.push(name); + else bad.push(name + "(" + (r.label || r.status) + ": " + (r.message || "") + ")"); + }); + box.innerHTML = [ + ok.length ? "반영 " + esc(ok.join(", ")) : "", + bad.length ? "실패 " + esc(bad.join(", ")) : "", + rest.length ? '건너뜀(미연동·미설정): ' + esc(rest.join(", ")) + "" : "", + ].filter(Boolean).join(" · ") || "가져올 쇼핑몰이 없습니다."; + box.className = "perf-notice" + (bad.length ? " is-warn" : " is-ok"); + box.hidden = false; + } catch (err) { + box.textContent = "가져오기 실패: " + err.message; + box.className = "perf-notice is-warn"; + box.hidden = false; + } finally { + backfill.disabled = false; + backfill.textContent = "가져오기"; + } + }); + // ── 테스트 데이터 / 재암호화 ── const gen = document.getElementById("perf-sample-gen"); if (gen) gen.addEventListener("click", async function () { diff --git a/docs/CAFE24_MODULE.md b/docs/CAFE24_MODULE.md index ce739d1..80731d3 100644 --- a/docs/CAFE24_MODULE.md +++ b/docs/CAFE24_MODULE.md @@ -306,10 +306,10 @@ code → access/refresh token 교환 cafe24_oauth_tokens 저장 ``` -- scope 는 `app/integrations/cafe24/config.py` 의 `PRODUCT_SCOPES` = - `mall.read_product`, `mall.write_product`. - 주문관리 추가 시 `ORDER_SCOPES` 를 합쳐 넘기고, 카페24 개발자센터 앱에서도 - 권한을 추가한 뒤 **재인증**하면 된다. +- scope 는 `app/integrations/cafe24/config.py` 의 `DEFAULT_SCOPES` = + `mall.read_product`, `mall.write_product`, `mall.read_order`(실적 모듈 매출 수집, 읽기만). + 목록을 바꾸면 카페24 개발자센터 앱에도 그 권한이 있어야 하고(없으면 인증 거부), + **재인증**해야 새 권한이 토큰에 붙는다. 재인증 전 기존 토큰은 예전 권한 그대로 계속 동작한다. - access token 은 만료 2분 전부터 자동 갱신된다. 갱신은 토큰 행을 `SELECT ... FOR UPDATE` 로 잠근 채 수행 — web 컨테이너와 worker 컨테이너가 동시에 refresh 해서 한쪽 토큰이 무효화되는 것을 막는다(카페24는 refresh @@ -535,7 +535,8 @@ cafe24_oauth_tokens 저장 1. 로그인 → 앱 생성 2. Redirect URI 를 `.env` 의 `CAFE24_REDIRECT_URI` 와 **정확히 동일하게** 등록 (운영: `https://dbx.no1king.freeddns.org/cafe24/oauth/callback`) -3. 권한(Scope)에 `mall.read_product`, `mall.write_product` 체크 +3. 권한(Scope)에 상품(Product) 읽기+쓰기, 주문(Order) 읽기 이상 체크 + (`mall.read_product`, `mall.write_product`, `mall.read_order` — 주문은 실적 모듈이 매출 수집에 사용) 4. 발급된 Client ID / Client Secret 을 `.env` 에 기입 ### 5-2. DB 초기화 (superuser 로 1회) diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index e1421cc..9758bd2 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -29,9 +29,27 @@ 오류 클래스 = 연결 상태: `NotConfigured`(인증정보 미설정) · `AuthFailed`(인증 실패) · `TokenExpired` · `ApiError` · `NotImplementedYet`(연동 준비 중). -**현재(1단계)**: 10개 어댑터 모두 입력칸만 정의, 수집은 `NotImplementedYet`. 카페24는 `auth_type="shared"` — 기존 -`app/integrations/cafe24` OAuth 토큰(cafe24_db)을 재사용해 연결 상태만 확인한다(주문 수집 시 앱 권한에 -`mall.read_order` 추가 + 재연결 필요). 쇼핑몰별 입력칸은 **연동 단계에서 공식 API 문서로 확정**한다. +**연동 현황**: 카페24 = **구현됨**, 나머지 9개는 입력칸만 정의(수집은 `NotImplementedYet`). 쇼핑몰별 입력칸은 +**연동 단계에서 공식 API 문서로 확정**한다. + +### 카페24 (`adapters/cafe24.py`, 구현됨) + +`auth_type="shared"` — 기존 `app/integrations/cafe24` OAuth 토큰(cafe24_db)과 클라이언트(재시도·429·토큰 자동 갱신)를 +재사용한다. 토큰에 `mall.read_order` 가 있어야 한다(`DEFAULT_SCOPES` 포함, 권한 추가 후 카페24 상품관리 → 시스템에서 재연결). +Admin API `GET /admin/orders`(문서 버전 2026-09-01 확인: 검색기간 한 호출 3개월 미만, limit ≤ 1000, offset ≤ 15000). + +| 사건 | 조회 | 대상 | 금액·날짜 | +|---|---|---|---| +| SALE | `date_type=pay_date`, `embed=items` | `paid=T` 주문의 모든 품목 | +품목 결제금액(`payment_amount`, 할인 반영·배송비 제외), 결제일 | +| CANCEL | `date_type=cancel_complete_date` | 품목 상태 C40~C43(취소완료). 입금전취소 C47~C49 제외 | −같은 품목 금액, 품목 `cancel_date` | +| RETURN | `date_type=return_complete_date` | 품목 상태 R40~R43(반품완료) | −품목 금액(부분 반품은 `claim_quantity/quantity` 비율), `return_confirmed_date` | + +- 사건 ID = `{order_item_code}-S|C|R` (중복 방지). 교환(E**)은 1단계에서 반영 안 함. +- **자체몰 주문만**(`market_id` = self/빈값). 카페24 로 연동돼 들어온 다른 마켓 주문(스마트스토어·쿠팡 등)은 해당 쇼핑몰 + 어댑터와 이중 집계되지 않게 제외. 네이버페이 결제(`order_place_id=NCHECKOUT`)는 자체몰 주문이라 포함. +- 기간은 60일씩 나눠 요청, 1000건 단위 페이지. 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않고 raw 에는 금액·상태만. +- **실데이터로 확인할 것**: 품목 `payment_amount` 가 적립금·예치금 사용분을 어떻게 반영하는지, 부분 취소/반품 시 품목이 + 분리되는지(`claim_quantity` 해석). 카페24 관리자 화면 매출과 한 주 정도 대조 후 필요하면 규칙 조정. ### 연동 단계 체크리스트(쇼핑몰마다) @@ -92,6 +110,8 @@ - `SyncService.sync_all()` / `sync_marketplace()` — 버튼·향후 cron/worker 공용. 기본 기간: 오늘 포함 최근 `PERFORMANCE_SYNC_DAYS`(기본 7)일. +- **과거 매출 가져오기**(설정 화면, 관리자): `POST /api/sync {from, to}` — 기간 지정 수집(최대 366일, 미래는 오늘까지). + 처음 연동했거나 빠진 기간을 채울 때. 같은 사건은 덮어써서 여러 번 해도 중복 없음. 일반 사용자가 기간을 주면 403. - 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리). - 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고 상단에 오류 쇼핑몰만 표시. From 27ee92c0a69c084ee209ae478a19673c607345d1 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:38:44 +0900 Subject: [PATCH 04/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=EC=9D=84=20=EC=B9=B4=ED=8E=9824=20"?= =?UTF-8?q?=EC=9D=BC=EB=B3=84=20=EB=A7=A4=EC=B6=9C=EB=82=B4=EC=97=AD"=20?= =?UTF-8?q?=EA=B8=B0=EC=A4=80=EC=9C=BC=EB=A1=9C(=EA=B2=B0=EC=A0=9C?= =?UTF-8?q?=ED=95=A9=EA=B3=84=C2=B7=ED=99=98=EB=B6=88=ED=95=A9=EA=B3=84)?= =?UTF-8?q?=20+=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=EB=8F=84?= =?UTF-8?q?=EA=B5=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 원인: 품목 결제금액(배송비 제외)을 매출로, 취소·반품 완료일의 품목 금액을 환불로 잡아 카페24 화면(결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰, 환불합계 = 환불완료일 실제 환불액)과 달랐다. - SALE: 결제일 기준 주문 단위 결제합계(initial_order_amount — 결제 당시 금액) - CANCEL/RETURN: GET /admin/refunds 환불완료일, 실제 환불액(환불코드 R=반품) - 환불도 원 주문 market_id 로 자체몰만(다른 마켓 연동 주문 제외) - 기간 교체(replace_range): 동기화한 기간의 카페24 실데이터를 지우고 새로 넣음(한 트랜잭션, 테스트 데이터 제외) — 예전 품목 단위 행이 남아 이중 집계되지 않게 - 설정 화면 "카페24 매출 대조": 날짜별로 카페24 화면 열 순서대로 원천 금액 합산(자체몰/마켓 구분, 저장 안 함) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/base.py | 4 + app/modules/performance/adapters/cafe24.py | 284 +++++++++++------- app/modules/performance/db.py | 55 ++-- app/modules/performance/router.py | 10 + app/modules/performance/sync.py | 22 +- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 13 +- .../performance/tests/test_performance.py | 154 ++++++---- app/static/performance.js | 54 ++++ docs/PERFORMANCE_MODULE.md | 28 +- 10 files changed, 421 insertions(+), 205 deletions(-) diff --git a/app/modules/performance/adapters/base.py b/app/modules/performance/adapters/base.py index 15e2396..a7e6328 100644 --- a/app/modules/performance/adapters/base.py +++ b/app/modules/performance/adapters/base.py @@ -144,6 +144,10 @@ class MarketplaceAdapter(ABC): auth_type: str = "api_key" # api_key / oauth / shared(공통 연동 계층 재사용) docs_url: str = "" implemented: bool = False # 실제 수집(fetch)이 구현됐는가 + # True 면 동기화 때 그 기간(sales_date)의 이 쇼핑몰 실데이터를 지우고 새로 넣는다(한 트랜잭션). + # 쇼핑몰 API 가 "기간 안 결제·환불"을 빠짐없이 돌려줄 때만 켠다 — 규칙이 바뀌거나 + # 주문이 사라져도 예전 행이 남지 않는다. False 면 같은 사건 ID 만 덮어쓴다(upsert). + replace_range: bool = False note: str = "" # 설정 화면 안내 문구 # ── 설정 ────────────────────────────────────────────── diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 85cc105..7db0708 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -5,18 +5,21 @@ 주문 읽기 권한(mall.read_order)이 필요하다 — config.DEFAULT_SCOPES 에 포함, 권한 추가 후 카페24 상품관리 → 시스템에서 한 번 다시 연결해야 한다. -수집 규칙 (Admin API GET /admin/orders, 문서 버전 2026-09-01 확인) - - 결제(SALE): date_type=pay_date(결제일), embed=items. 결제된(paid=T) 주문의 품목마다 - 품목 결제금액(payment_amount — 할인 반영, 배송비 제외)을 매출로. 사건 날짜 = 결제일. - - 취소(CANCEL): date_type=cancel_complete_date. 품목 상태 C40~C43(취소완료)만, - 결제 때와 같은 품목 금액을 음수로. 입금전취소(C47~C49)는 매출이 아니었으므로 제외. - - 반품(RETURN): date_type=return_complete_date. 품목 상태 R40~R43(반품완료)만 음수로. - 부분 반품(0 < claim_quantity < quantity)은 수량 비율로 나눈다. - - 교환(E**)은 매출 변화 없음으로 보고 1단계에서는 반영하지 않는다. - - 자체몰 주문만(market_id 가 self/빈값). 카페24 로 들어온 다른 마켓(스마트스토어·쿠팡 등) - 주문은 해당 쇼핑몰 어댑터와 이중 집계되지 않게 제외한다. 네이버페이 결제는 자체몰 주문이라 포함. - - 한 호출 검색기간 3개월 미만 → 60일씩 나눠 요청. limit 최대 1000, offset 최대 15000. +카페24 관리자 "일별 매출내역"과 같은 기준으로 센다(Admin API 문서 2026-09-01 확인). + - 결제합계(SALE, +): GET /admin/orders date_type=pay_date(결제일), 결제된(paid=T) 주문마다 + 상품구매금액 + 배송비 − 할인 − 쿠폰 (주문의 initial_order_amount — 결제 당시 금액) + 환불은 따로 빼므로 취소 후 금액(actual_order_amount)이 아니라 결제 당시 금액을 쓴다. + - 환불합계(CANCEL/RETURN, −): GET /admin/refunds date_type=refund_date(환불완료일), + 실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소. + - 수집 기간을 통째로 다시 받는다(replace_range) — 결제·환불 모두 기간 안 날짜로 조회되므로 + 그 기간의 카페24 실데이터를 지우고 새로 넣는다. 규칙이 바뀌거나 주문이 사라져도 이중 집계 없음. + - 자체몰 주문만(market_id 가 self/빈값). 카페24 로 연동돼 들어온 다른 마켓(스마트스토어·쿠팡 등) + 주문은 해당 쇼핑몰 어댑터와 이중 집계되지 않게 제외(환불도 원 주문의 market_id 로 판단). + 네이버페이 결제(order_place_id=NCHECKOUT)는 자체몰 주문이라 포함. + - 한 호출 검색기간 3개월 미만 → 60일씩 나눠 요청. orders limit ≤ 1000, refunds limit ≤ 500, offset ≤ 15000. - 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않는다 — raw 에는 금액·상태 필드만. + - 할인 항목 구성·마켓 주문 포함 여부는 `reconcile()`(설정 화면 "카페24 매출 대조")로 카페24 화면과 + 대조해 확정한다. """ from __future__ import annotations @@ -36,13 +39,20 @@ from .base import ( ) ORDER_SCOPE = "mall.read_order" -PAGE_LIMIT = 1000 +ORDER_LIMIT = 1000 +REFUND_LIMIT = 500 +LOOKUP_BATCH = 100 MAX_OFFSET = 15000 CHUNK_DAYS = 60 -CANCEL_DONE = {"C40", "C41", "C42", "C43"} -RETURN_DONE = {"R40", "R41", "R42", "R43"} SELF_MARKETS = {"", "self", None} +# 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (initial_order_amount 의 필드) +DISCOUNT_FIELDS = ("membership_discount_amount", "set_product_discount_amount", "app_discount_amount", + "market_other_discount_amount", "shipping_fee_discount_amount") +COUPON_FIELDS = ("coupon_discount_price", "coupon_shipping_fee_amount") +AMOUNT_FIELDS = ("order_price_amount", "shipping_fee", *DISCOUNT_FIELDS, *COUPON_FIELDS, + "points_spent_amount", "credits_spent_amount", "payment_amount") + def _won(value: Any) -> int: """카페24 금액 문자열("29000.00") → 원 단위 정수.""" @@ -63,27 +73,29 @@ def _day(value: Any) -> date | None: return None -def item_amount(item: dict[str, Any]) -> int: - """품목 결제금액. payment_amount 가 없으면 (판매가+옵션가)×수량 − 품목 할인으로 계산.""" - if item.get("payment_amount") not in (None, ""): - return _won(item["payment_amount"]) - qty = int(item.get("quantity") or 0) - gross = (_won(item.get("product_price")) + _won(item.get("option_price"))) * qty - discounts = (_won(item.get("additional_discount_price")) + _won(item.get("coupon_discount_price")) - + _won(item.get("app_item_discount_amount"))) - return max(0, gross - discounts) +def order_amounts(order: dict[str, Any]) -> dict[str, int]: + """결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위.""" + a = order.get("initial_order_amount") or order.get("actual_order_amount") or {} + return {k: _won(a.get(k)) for k in AMOUNT_FIELDS} -def _raw(order: dict[str, Any], item: dict[str, Any]) -> dict[str, Any]: - """저장용 원본 — 금액·상태만(개인정보 제외).""" - keys = ("order_item_code", "order_status", "status_code", "product_no", "product_code", "variant_code", - "product_price", "option_price", "quantity", "claim_quantity", "additional_discount_price", - "coupon_discount_price", "app_item_discount_amount", "payment_amount", "claim_code") - return { - "order_id": order.get("order_id"), "market_id": order.get("market_id"), - "order_place_id": order.get("order_place_id"), "paid": order.get("paid"), - **{k: item.get(k) for k in keys}, - } +def order_total(order: dict[str, Any]) -> int: + """결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰.""" + a = order_amounts(order) + return (a["order_price_amount"] + a["shipping_fee"] + - sum(a[k] for k in DISCOUNT_FIELDS) - sum(a[k] for k in COUPON_FIELDS)) + + +def is_self_market(market_id: Any) -> bool: + return market_id in SELF_MARKETS + + +def _chunks(start: date, end: date) -> Iterable[tuple[date, date]]: + s = start + while s <= end: + e = min(end, s + timedelta(days=CHUNK_DAYS - 1)) + yield s, e + s = e + timedelta(days=1) class Cafe24Adapter(MarketplaceAdapter): @@ -91,6 +103,7 @@ class Cafe24Adapter(MarketplaceAdapter): name = "카페24" auth_type = "shared" implemented = True + replace_range = True docs_url = "https://apidocs.cafe24.com/docs/admin/get-orders" note = ("카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음). " "주문 읽기 권한이 필요해 권한 추가 후 한 번 다시 연결해야 합니다.") @@ -129,7 +142,7 @@ class Cafe24Adapter(MarketplaceAdapter): return build_cafe24_api(self._repo(ctx)).client - def _get(self, ctx: AdapterContext, params: dict[str, Any]) -> dict[str, Any]: + def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]: from app.integrations.cafe24.errors import ( # 지연 import Cafe24ApiError, Cafe24AuthError, @@ -138,7 +151,7 @@ class Cafe24Adapter(MarketplaceAdapter): ) try: - return self._client(ctx).get("/admin/orders", params=params) + return self._client(ctx).get(path, params=params) except Cafe24ConfigError as exc: raise NotConfigured(str(exc)) from None except Cafe24AuthError as exc: @@ -155,98 +168,137 @@ class Cafe24Adapter(MarketplaceAdapter): from app.timezone import today_kst # noqa: WPS433 self.authenticate(ctx) - today = today_kst() - self._get(ctx, {"start_date": today.isoformat(), "end_date": today.isoformat(), - "date_type": "pay_date", "limit": 1}) + today = today_kst().isoformat() + self._get(ctx, "/admin/orders", {"start_date": today, "end_date": today, "date_type": "pay_date", "limit": 1}) return "카페24 연결 정상(주문 조회 권한 확인)." - # ── 수집 ────────────────────────────────────────────── - def _orders(self, ctx: AdapterContext, start: date, end: date, date_type: str) -> Iterable[dict[str, Any]]: - """기간을 60일씩 나눠 페이지를 넘기며 주문(+items)을 모두 가져온다.""" - s = start - while s <= end: - e = min(end, s + timedelta(days=CHUNK_DAYS - 1)) - offset = 0 - while True: - if offset > MAX_OFFSET: - raise ApiError(f"카페24 조회 건수가 너무 많습니다({s}~{e}). 기간을 줄여 다시 시도하세요.") - data = self._get(ctx, {"start_date": s.isoformat(), "end_date": e.isoformat(), - "date_type": date_type, "embed": "items", - "limit": PAGE_LIMIT, "offset": offset}) - orders = data.get("orders") or [] - yield from orders - if len(orders) < PAGE_LIMIT: - break - offset += PAGE_LIMIT - s = e + timedelta(days=1) + # ── 조회 ────────────────────────────────────────────── + def _paged(self, ctx: AdapterContext, path: str, key: str, params: dict[str, Any], + limit: int) -> Iterable[dict[str, Any]]: + offset = 0 + while True: + if offset > MAX_OFFSET: + raise ApiError(f"카페24 조회 건수가 너무 많습니다({params.get('start_date')}~{params.get('end_date')}). " + "기간을 줄여 다시 시도하세요.") + rows = self._get(ctx, path, {**params, "limit": limit, "offset": offset}).get(key) or [] + yield from rows + if len(rows) < limit: + return + offset += limit + def paid_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + for s, e in _chunks(start, end): + yield from self._paged(ctx, "/admin/orders", "orders", + {"start_date": s.isoformat(), "end_date": e.isoformat(), + "date_type": "pay_date", "embed": "items"}, ORDER_LIMIT) + + def refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + for s, e in _chunks(start, end): + yield from self._paged(ctx, "/admin/refunds", "refunds", + {"start_date": s.isoformat(), "end_date": e.isoformat(), + "date_type": "refund_date"}, REFUND_LIMIT) + + def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, Any]: + """환불의 원 주문 market_id — 주문일 60일 구간·100건씩 묶어 조회.""" + pairs = sorted({(_day(r.get("order_date")) or date.min, str(r.get("order_id") or "")) + for r in refunds if r.get("order_id")}) + out: dict[str, Any] = {} + i = 0 + while i < len(pairs): + first = pairs[i][0] + group = [p for p in pairs[i:i + LOOKUP_BATCH] if (p[0] - first).days < CHUNK_DAYS] + ids = [oid for _, oid in group] + if first != date.min: + params = {"order_id": ",".join(ids), "start_date": first.isoformat(), + "end_date": group[-1][0].isoformat(), "date_type": "order_date", "limit": LOOKUP_BATCH} + for o in self._get(ctx, "/admin/orders", params).get("orders") or []: + out[str(o.get("order_id"))] = o.get("market_id") + i += len(group) + return out + + # ── 수집(어댑터 공통 흐름) ────────────────────────────── def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: - for o in self._orders(ctx, start, end, "pay_date"): - yield {"kind": "paid", "order": o} + yield from self.paid_orders(ctx, start, end) def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: - for o in self._orders(ctx, start, end, "cancel_complete_date"): - yield {"kind": "cancel", "order": o} - for o in self._orders(ctx, start, end, "return_complete_date"): - yield {"kind": "return", "order": o} + rows = [r for r in self.refunds(ctx, start, end) if str(r.get("status") or "T") == "T"] + markets = self.market_ids(ctx, rows) + for r in rows: + yield {**r, "_market_id": markets.get(str(r.get("order_id")), "self")} - @staticmethod - def _is_self_order(order: dict[str, Any]) -> bool: - return order.get("market_id") in SELF_MARKETS - - def normalize_order(self, raw: dict[str, Any]) -> list[SaleEvent]: - order = raw.get("order") or {} - if not self._is_self_order(order) or order.get("paid") != "T": + def normalize_order(self, order: dict[str, Any]) -> list[SaleEvent]: + if not is_self_market(order.get("market_id")) or order.get("paid") != "T": return [] pay_day = _day(order.get("payment_date")) if pay_day is None: return [] - order_id = str(order.get("order_id") or "") - events = [] - for item in order.get("items") or []: - code = str(item.get("order_item_code") or "") - if not code: - continue - events.append(SaleEvent( - event_type="SALE", external_event_id=f"{code}-S", external_order_id=order_id, - external_line_id=code, order_date=_day(order.get("order_date")), payment_date=pay_day, - event_date=pay_day, amount=item_amount(item), product_name=str(item.get("product_name") or ""), - option_name=str(item.get("option_value") or "") if isinstance(item.get("option_value"), str) else "", - quantity=int(item.get("quantity") or 0), order_status=str(item.get("order_status") or ""), - raw=_raw(order, item), - )) - return events + items = order.get("items") or [] + names = [str(i.get("product_name") or "") for i in items if i.get("product_name")] + name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else "" + oid = str(order.get("order_id") or "") + return [SaleEvent( + event_type="SALE", external_event_id=f"{oid}-PAY", external_order_id=oid, + order_date=_day(order.get("order_date")), payment_date=pay_day, event_date=pay_day, + amount=max(0, order_total(order)), product_name=name, + quantity=sum(int(i.get("quantity") or 0) for i in items), order_status="결제완료", + discount_amount=sum(order_amounts(order)[k] for k in DISCOUNT_FIELDS + COUPON_FIELDS), + raw={"order_id": oid, "market_id": order.get("market_id"), "order_place_id": order.get("order_place_id"), + "items": len(items), **{f"initial_{k}": v for k, v in order_amounts(order).items()}}, + )] - def normalize_refund(self, raw: dict[str, Any]) -> list[SaleEvent]: - order = raw.get("order") or {} - if not self._is_self_order(order): + def normalize_refund(self, refund: dict[str, Any]) -> list[SaleEvent]: + if not is_self_market(refund.get("_market_id")): return [] - kind = raw.get("kind") - done, ev_type, suffix = (CANCEL_DONE, "CANCEL", "C") if kind == "cancel" else (RETURN_DONE, "RETURN", "R") - order_id = str(order.get("order_id") or "") - events = [] - for item in order.get("items") or []: - code = str(item.get("order_item_code") or "") - status = str(item.get("order_status") or "") - if not code or status not in done: + day = _day(refund.get("refund_date")) + code = str(refund.get("refund_code") or "") + if day is None or not code: + return [] + amount = _won(refund.get("actual_refund_amount")) + return [SaleEvent( + event_type="RETURN" if code.upper().startswith("R") else "CANCEL", + external_event_id=code, external_order_id=str(refund.get("order_id") or ""), + external_line_id=",".join(refund.get("order_item_code") or []), + order_date=_day(refund.get("order_date")), event_date=day, amount=-amount, + quantity=-int(refund.get("quantity") or 0), order_status="환불완료", + raw={"refund_code": code, "order_id": refund.get("order_id"), "status": refund.get("status"), + "actual_refund_amount": refund.get("actual_refund_amount"), + "used_points": refund.get("used_points"), "used_credits": refund.get("used_credits"), + "quantity": refund.get("quantity"), "order_item_code": refund.get("order_item_code")}, + )] + + # ── 대조(설정 화면 "카페24 매출 대조") ───────────────── + def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]: + """그날 결제 주문·환불을 항목별로 합산 — 카페24 일별 매출내역과 비교해 규칙을 확정하는 용도. + + 자체몰/다른 마켓을 나눠 합산한다. 개인정보는 담지 않는다. + """ + self.authenticate(ctx) + + def empty() -> dict[str, int]: + return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, "total": 0} + + groups = {"self": empty(), "market": empty()} + unpaid = 0 + for o in self.paid_orders(ctx, day, day): + if o.get("paid") != "T": + unpaid += 1 continue - if kind == "cancel": - day = _day(item.get("cancel_date")) or _day(order.get("cancel_date")) - else: - day = _day(item.get("return_confirmed_date")) or _day(item.get("refund_date")) - if day is None: - continue - amount = item_amount(item) - qty = int(item.get("quantity") or 0) - claim = int(item.get("claim_quantity") or 0) - if kind == "return" and 0 < claim < qty: - amount = int((Decimal(amount) * claim / qty).quantize(Decimal(1), rounding=ROUND_HALF_UP)) - qty = claim - events.append(SaleEvent( - event_type=ev_type, external_event_id=f"{code}-{suffix}", external_order_id=order_id, - external_line_id=code, order_date=_day(order.get("order_date")), - payment_date=_day(order.get("payment_date")), event_date=day, amount=-amount, - product_name=str(item.get("product_name") or ""), quantity=-qty, order_status=status, - raw=_raw(order, item), - )) - return events + g = groups["self" if is_self_market(o.get("market_id")) else "market"] + g["orders"] += 1 + g["items"] += sum(int(i.get("quantity") or 0) for i in o.get("items") or []) + g["lines"] += len(o.get("items") or []) + for k, v in order_amounts(o).items(): + g[k] += v + g["total"] += order_total(o) + rows = [r for r in self.refunds(ctx, day, day) if str(r.get("status") or "T") == "T"] + markets = self.market_ids(ctx, rows) + refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, + "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} + for r in rows: + g = refunds["self" if is_self_market(markets.get(str(r.get("order_id")), "self")) else "market"] + g["count"] += 1 + for k in ("actual_refund_amount", "used_points", "used_credits"): + g[k] += _won(r.get(k)) + return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, + "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/db.py b/app/modules/performance/db.py index 4d7956a..5c00b60 100644 --- a/app/modules/performance/db.py +++ b/app/modules/performance/db.py @@ -215,7 +215,43 @@ class PerformanceDBStore: # ════════════════════════════════════════════════════════════ def upsert_events(self, code: str, events: Iterable[dict[str, Any]], *, is_sample: bool = False) -> int: """같은 (쇼핑몰, 사건 종류, 외부 사건 ID)는 덮어쓴다 — 여러 번 동기화해도 중복 없음.""" - sql = """ + 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]]) -> int: + """기간(sales_date) 안 이 쇼핑몰 실데이터(is_sample 아님)를 지우고 새로 넣는다 — 한 트랜잭션. + 테스트 데이터는 건드리지 않는다. 실패하면 롤백되어 예전 데이터가 그대로 남는다.""" + rows = self._event_rows(code, events, False) + with self._pool.connection() as conn: + with conn.transaction(): + 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]: + return [ + (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, @@ -229,22 +265,7 @@ class PerformanceDBStore: 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() - """ - rows = [ - (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 - ] - if not rows: - return 0 - with self._pool.connection() as conn: - with conn.transaction(): - with conn.cursor() as cur: - cur.executemany(sql, rows) - return len(rows) + """ def daily_amounts(self, start: date, end: date, codes: list[str]) -> dict[tuple[date, str], int]: if not codes: diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py index 479905d..bfdf077 100644 --- a/app/modules/performance/router.py +++ b/app/modules/performance/router.py @@ -270,6 +270,16 @@ def api_test_connection(request: Request, code: str, payload: dict[str, Any] = B return JSONResponse(result) +@router.get("/api/marketplaces/{code}/reconcile") +def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="date")) -> JSONResponse: + """쇼핑몰 화면(예: 카페24 일별 매출내역)과 비교용 — 그날 원천 금액 항목별 합계. DB 는 바꾸지 않는다.""" + store, user = common.require_store(request, admin=True) + _code_or_404(store, code) + day = _parse_date(date_) + _, sync = common.services(request, store) + return JSONResponse(sync.reconcile(code, day, user=user["email"])) + + @router.post("/api/sample-data") def api_sample_data(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse: store, _ = common.require_store(request, admin=True) diff --git a/app/modules/performance/sync.py b/app/modules/performance/sync.py index da95b1c..0551445 100644 --- a/app/modules/performance/sync.py +++ b/app/modules/performance/sync.py @@ -107,7 +107,13 @@ class SyncService: ctx = self._ctx(adapter, user=user) fetched, events = adapter.collect(ctx, start, end) known = ctx.credentials.known_secrets() - upserted = self._store.upsert_events(code, (event_row(ev, known) for ev in events)) + rows = [event_row(ev, known) for ev in events] + 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) + 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, @@ -127,6 +133,20 @@ class SyncService: 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 generate_samples(self, start: date, end: date, codes: list[str]) -> int: from .adapters import mock # noqa: WPS433 diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 1ba74ca..c1f3341 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 3dc985b..572675e 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -115,6 +115,17 @@
+
+

카페24 매출 대조

+

카페24 관리자 → 통계 → 일별 매출내역과 같은 날짜를 비교합니다. 그날 결제 주문과 환불을 카페24 API 에서 + 바로 합산하며(저장하지 않음), 자체몰과 다른 마켓 연동 주문을 나눠 보여 줍니다.

+
+ + +
+
+
+

테스트 데이터

현재 {{ "{:,}".format(sample_count) }}건
@@ -131,4 +142,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 21d494b..1365cae 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -245,6 +245,11 @@ class FakeStore: def record_test(self, code, *, status, ok, error=""): self.status[code] = {"status": status, "ok": ok, "error": error, "test": True} + def replace_events(self, code, start, end, events): + self.events = {k: v for k, v in self.events.items() + if not (k[0] == code and not v["is_sample"] and start <= v["sales_date"] <= end)} + return self.upsert_events(code, events) + def upsert_events(self, code, events, *, is_sample=False): n = 0 for e in events: @@ -379,88 +384,123 @@ def test_not_implemented_and_mock(): # ════════════════════════════════════════════════════════════ -# 카페24 어댑터(가짜 API 응답) +# 카페24 어댑터(가짜 API 응답) — 카페24 "일별 매출내역" 기준 # ════════════════════════════════════════════════════════════ -def _c24_item(code, status="N40", price="30000.00", qty=1, pay="29000.00", **kw): - return {"order_item_code": code, "order_status": status, "product_name": "냄비", "option_value": "", - "product_price": price, "option_price": "0.00", "quantity": qty, "payment_amount": pay, - "coupon_discount_price": "1000.00", "claim_quantity": 0, **kw} +def _c24_order(oid, market="self", paid="T", price=50_000, ship=3_000, coupon=5_000, member=1_000, items=2, **kw): + amt = {"order_price_amount": f"{price}.00", "shipping_fee": f"{ship}.00", "coupon_discount_price": f"{coupon}.00", + "membership_discount_amount": f"{member}.00", "points_spent_amount": "0.00", "payment_amount": "0.00"} + return {"order_id": oid, "market_id": market, "paid": paid, "order_date": "2026-09-28T10:00:00+09:00", + "payment_date": "2026-09-29T11:21:35+09:00", "buyer_name": "홍길동", "receiver_address": "서울시", + "bank_account_no": "1234567890", "initial_order_amount": amt, + "actual_order_amount": {**amt, "order_price_amount": "0.00"}, # 취소 후 금액은 쓰지 않는다 + "items": [{"order_item_code": f"{oid}-{i:02d}", "product_name": f"상품{i}", "quantity": 1} + for i in range(1, items + 1)], **kw} -def _c24_order(oid, items, market="self", paid="T", **kw): - return {"order_id": oid, "market_id": market, "paid": paid, "order_date": "2026-09-27T10:00:00+09:00", - "payment_date": "2026-09-28T11:21:35+09:00", "buyer_name": "홍길동", "receiver_address": "서울시", - "bank_account_no": "1234567890", "items": items, **kw} +def _c24_refund(code, oid, amount, status="T", order_date="2026-09-20T09:00:00+09:00"): + return {"refund_code": code, "order_id": oid, "order_date": order_date, "refund_date": "2026-09-29T17:31:50+09:00", + "actual_refund_amount": f"{amount}.00", "used_points": "0.00", "used_credits": "0.00", "quantity": 1, + "order_item_code": [f"{oid}-01"], "status": status, "refund_bank_account_no": "1234567890"} class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist=["Cafe24Adapter"]).Cafe24Adapter): - def __init__(self, pages): - self.pages = pages # date_type → [응답 orders 목록(페이지별)] + def __init__(self, orders_pages, refunds_pages=(), lookup=None): + self.orders_pages = orders_pages # 결제일 조회 페이지들 + self.refunds_pages = list(refunds_pages) + self.lookup = lookup or {} # order_id → market_id (환불 원 주문 조회) self.calls = [] def authenticate(self, ctx): return None - def _get(self, ctx, params): - self.calls.append(params) - pages = self.pages.get(params["date_type"], []) - idx = params.get("offset", 0) // 1000 - return {"orders": pages[idx] if idx < len(pages) else []} + def _get(self, ctx, path, params): + self.calls.append((path, params)) + idx = params.get("offset", 0) // max(1, params.get("limit", 1)) + if path == "/admin/refunds": + return {"refunds": self.refunds_pages[idx] if idx < len(self.refunds_pages) else []} + if params.get("date_type") == "order_date": # 원 주문 market_id 조회 + ids = params["order_id"].split(",") + return {"orders": [{"order_id": i, "market_id": self.lookup.get(i, "self")} for i in ids]} + return {"orders": self.orders_pages[idx] if idx < len(self.orders_pages) else []} -def test_cafe24_normalize(): - from app.modules.performance.adapters.cafe24 import Cafe24Adapter, item_amount +def test_cafe24_normalize_matches_daily_report(): + from app.modules.performance.adapters.base import AdapterContext + from app.modules.performance.adapters.cafe24 import order_total - paid = _c24_order("20260928-01", [_c24_item("20260928-01-01"), _c24_item("20260928-01-02", pay="10000.00")]) - market = _c24_order("20260928-02", [_c24_item("20260928-02-01")], market="shopn") # 스마트스토어 연동 주문 - unpaid = _c24_order("20260928-03", [_c24_item("20260928-03-01", status="N00")], paid="F") - canceled = _c24_order("20260928-01", [ - _c24_item("20260928-01-01", status="C40", cancel_date="2026-09-29 09:00:00"), - _c24_item("20260928-01-02", status="N40")]) - precancel = _c24_order("20260928-04", [_c24_item("20260928-04-01", status="C48", cancel_date="2026-09-29 09:00:00")]) - returned = _c24_order("20260928-05", [_c24_item("20260928-05-01", status="R40", qty=3, pay="90000.00", - claim_quantity=1, return_confirmed_date="2026-09-30 10:00:00")]) - fake = _FakeCafe24({"pay_date": [[paid, market, unpaid]], - "cancel_complete_date": [[canceled, precancel]], - "return_complete_date": [[returned]]}) - ctx = __import__("app.modules.performance.adapters.base", fromlist=["AdapterContext"]).AdapterContext( - code="cafe24", credentials=None) - fetched, events = fake.collect(ctx, date(2026, 9, 23), date(2026, 9, 30)) - by = {(e.event_type, e.external_line_id): e for e in events} - assert fetched == 6 - assert by[("SALE", "20260928-01-01")].amount == 29_000 and by[("SALE", "20260928-01-02")].amount == 10_000 - assert by[("SALE", "20260928-01-01")].event_date == date(2026, 9, 28) # 결제일 - assert ("SALE", "20260928-02-01") not in by and ("SALE", "20260928-03-01") not in by # 마켓 주문·미결제 제외 - c = by[("CANCEL", "20260928-01-01")] - assert c.amount == -29_000 and c.event_date == date(2026, 9, 29) and c.external_event_id == "20260928-01-01-C" - assert ("CANCEL", "20260928-01-02") not in by and ("CANCEL", "20260928-04-01") not in by # 미취소·입금전취소 제외 - r = by[("RETURN", "20260928-05-01")] - assert r.amount == -30_000 and r.quantity == -1 and r.event_date == date(2026, 9, 30) # 3개 중 1개 반품 + ctx = AdapterContext(code="cafe24", credentials=None) + fake = _FakeCafe24( + [[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C", paid="F")]], + [[_c24_refund("C20260929-01", "A", 12_610), _c24_refund("R20260929-02", "X", 20_000), + _c24_refund("C20260929-03", "M", 9_000), _c24_refund("C20260929-04", "A", 5_000, status="F")]], + lookup={"M": "shopn"}, + ) + fetched, events = fake.collect(ctx, date(2026, 9, 29), date(2026, 9, 29)) + by = {(e.event_type, e.external_event_id): e for e in events} + # 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (결제 당시 금액) + sale = by[("SALE", "A-PAY")] + assert sale.amount == 50_000 + 3_000 - 1_000 - 5_000 == 47_000 + assert sale.event_date == date(2026, 9, 29) and sale.quantity == 2 and sale.product_name == "상품1 외 1건" + assert not any(e.external_order_id in ("B", "C") and e.event_type == "SALE" for e in events) # 마켓·미결제 제외 + # 환불: 환불완료일, 실제 환불액, R→반품 / 그 밖→취소, 마켓 주문·미완료 환불 제외 + assert by[("CANCEL", "C20260929-01")].amount == -12_610 + assert by[("RETURN", "R20260929-02")].amount == -20_000 + assert ("CANCEL", "C20260929-03") not in by and ("CANCEL", "C20260929-04") not in by + assert by[("CANCEL", "C20260929-01")].event_date == date(2026, 9, 29) for e in events: - assert "buyer_name" not in e.raw and "receiver_address" not in e.raw and "bank_account_no" not in e.raw - # 금액: payment_amount 없으면 (판매가+옵션)×수량 − 할인 - assert item_amount({"product_price": "10000.00", "option_price": "500.00", "quantity": 2, - "coupon_discount_price": "1000.00"}) == 20_000 + assert "buyer_name" not in str(e.raw) and "1234567890" not in str(e.raw) # 개인정보 미저장 + assert order_total({"initial_order_amount": {"order_price_amount": "1578300.00", "shipping_fee": "45500.00", + "coupon_discount_price": "57000.00"}}) == 1_566_800 # 9/29 화면값 + # 대조: 자체몰/마켓 나눠 합산 + rec = fake.reconcile(ctx, date(2026, 9, 29)) + assert rec["orders"]["self"]["orders"] == 1 and rec["orders"]["self"]["total"] == 47_000 + assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 + assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1 # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) - page1 = [_c24_order(f"x-{i}", []) for i in range(1000)] - fake2 = _FakeCafe24({"pay_date": [page1, [paid]]}) - got = list(fake2.fetch_orders(ctx, date(2026, 7, 1), date(2026, 9, 30))) - pay_calls = [c for c in fake2.calls if c["date_type"] == "pay_date"] + page1 = [_c24_order(f"x-{i}") for i in range(1000)] + fake2 = _FakeCafe24([page1, [_c24_order("y")]]) + got = list(fake2.paid_orders(ctx, date(2026, 7, 1), date(2026, 9, 30))) + calls = [p for path, p in fake2.calls if path == "/admin/orders"] assert len(got) == 2002 # 60일 구간 2개 × (1000건 페이지 + 다음 페이지 1건) - assert pay_calls[0]["start_date"] == "2026-07-01" and pay_calls[0]["end_date"] == "2026-08-29" - assert pay_calls[1]["offset"] == 1000 and all(c["limit"] == 1000 and c["embed"] == "items" for c in pay_calls) - assert any(c["start_date"] == "2026-08-30" for c in pay_calls) - # 주문 권한 없는 토큰 → 인증 실패(재연결 안내) + assert calls[0]["start_date"] == "2026-07-01" and calls[0]["end_date"] == "2026-08-29" + assert calls[1]["offset"] == 1000 and all(c["limit"] == 1000 and c["date_type"] == "pay_date" for c in calls) + + +def test_cafe24_scope_and_replace_range(): + import app.modules.performance.sync as syncmod + from app.modules.performance.adapters.base import AdapterContext + from app.modules.performance.adapters.cafe24 import Cafe24Adapter + + ctx = AdapterContext(code="cafe24", credentials=None) real = Cafe24Adapter() - real.shared_status = lambda ctx: {"connected": True, "scopes": "mall.read_product,mall.write_product"} + real.shared_status = lambda c: {"connected": True, "scopes": "mall.read_product,mall.write_product"} try: real.authenticate(ctx) except AuthFailed as exc: assert "mall.read_order" in exc.message else: raise AssertionError("주문 권한 없으면 인증 실패여야 합니다") - real.shared_status = lambda ctx: {"connected": True, "scopes": "mall.read_product,mall.read_order"} + real.shared_status = lambda c: {"connected": True, "scopes": "mall.read_product,mall.read_order"} real.authenticate(ctx) + # 기간 교체: 그 기간의 예전 실데이터(품목 단위 등)는 지우고, 테스트 데이터·기간 밖은 남긴다 + st = FakeStore() + st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "old-item-S", "external_order_id": "A", + "event_date": date(2026, 9, 29), "sales_date": date(2026, 9, 29), "amount": 1}]) + st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "outside", "external_order_id": "Z", + "event_date": date(2026, 9, 1), "sales_date": date(2026, 9, 1), "amount": 1}]) + st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "sample", "external_order_id": "S", + "event_date": date(2026, 9, 29), "sales_date": date(2026, 9, 29), "amount": 1}], + is_sample=True) + fake = _FakeCafe24([[_c24_order("A")]]) + orig = syncmod.get_adapter + syncmod.get_adapter = lambda c: fake + try: + r = SyncService(st, CredentialService(st, lambda: ring())).sync_marketplace( + "cafe24", date(2026, 9, 29), date(2026, 9, 29)) + finally: + syncmod.get_adapter = orig + ids = {k[2] for k in st.events if k[0] == "cafe24"} + assert r["ok"] and ids == {"A-PAY", "outside", "sample"}, ids def test_registry_and_event_validation(): diff --git a/app/static/performance.js b/app/static/performance.js index 2be3082..6922482 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -470,6 +470,60 @@ } finally { btn.disabled = false; btn.textContent = label; } } + // ── 카페24 매출 대조 — 카페24 "일별 매출내역" 열 순서대로 ── + const recon = document.getElementById("perf-recon"); + if (recon) recon.addEventListener("click", async function () { + const day = document.getElementById("perf-recon-date").value; + const out = document.getElementById("perf-recon-result"); + if (!day) return; + recon.disabled = true; + out.innerHTML = '

카페24에서 불러오는 중…

'; + try { + const r = await api("GET", "/performance/api/marketplaces/cafe24/reconcile?date=" + encodeURIComponent(day)); + if (!r.ok) { out.innerHTML = '

' + esc((r.label ? r.label + " — " : "") + r.message) + "

"; return; } + const s = r.orders.self, m = r.orders.market, rs = r.refunds.self, rm = r.refunds.market; + const disc = ["membership_discount_amount", "set_product_discount_amount", "app_discount_amount", + "market_other_discount_amount", "shipping_fee_discount_amount"]; + const coup = ["coupon_discount_price", "coupon_shipping_fee_amount"]; + const LABEL = { + membership_discount_amount: "회원할인", set_product_discount_amount: "세트상품할인", app_discount_amount: "앱할인", + market_other_discount_amount: "마켓 기타할인", shipping_fee_discount_amount: "배송비할인", + coupon_discount_price: "상품쿠폰", coupon_shipping_fee_amount: "배송비쿠폰", + }; + const sum = function (g, keys) { return keys.reduce(function (a, k) { return a + (g[k] || 0); }, 0); }; + const rows = [ + ["주문수", s.orders, m.orders, "cnt"], ["품목수(수량 합계)", s.items, m.items, "cnt"], ["품목수(품목 줄 수)", s.lines, m.lines, "cnt"], + ["상품구매금액", s.order_price_amount, m.order_price_amount], ["배송비", s.shipping_fee, m.shipping_fee], + ["할인 합계", sum(s, disc), sum(m, disc)], + ].concat(disc.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) + .concat([["쿠폰 합계", sum(s, coup), sum(m, coup)]]) + .concat(coup.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) + .concat([ + ["결제합계(계산)", s.total, m.total, "key"], + [" 참고: 실결제금액", s.payment_amount, m.payment_amount, "sub"], + [" 참고: 적립금 사용", s.points_spent_amount, m.points_spent_amount, "sub"], + [" 참고: 예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "sub"], + ["환불 건수", rs.count, rm.count, "cnt"], + ["환불합계(실제 환불액)", rs.actual_refund_amount, rm.actual_refund_amount, "key"], + [" 참고: 환불 적립금", rs.used_points, rm.used_points, "sub"], + [" 참고: 환불 예치금", rs.used_credits, rm.used_credits, "sub"], + ["순매출(결제합계 − 환불합계)", s.total - rs.actual_refund_amount, m.total - rm.actual_refund_amount, "key"], + ]); + out.innerHTML = '" + + rows.map(function (x) { + const cls = x[3] === "key" ? ' class="perf-row-week"' : ""; + const f = function (v) { return x[3] === "cnt" ? fmt(v) : won(v); }; + return ""; + }).join("") + "
' + esc(r.date) + + "자체몰(실적 반영)다른 마켓 연동(제외)
' + esc(x[0]) + + '' + f(x[1]) + '' + f(x[2]) + "
" + + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + + "건 제외. 카페24 화면과 다른 줄이 있으면 알려 주세요 — 규칙을 맞추겠습니다.

"; + } catch (err) { + out.innerHTML = '

' + esc(err.message) + "

"; + } finally { recon.disabled = false; } + }); + // ── 과거 매출 가져오기(기간 지정 수집, 관리자) ── const backfill = document.getElementById("perf-backfill"); if (backfill) backfill.addEventListener("click", async function () { diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 9758bd2..727d81d 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -36,20 +36,24 @@ `auth_type="shared"` — 기존 `app/integrations/cafe24` OAuth 토큰(cafe24_db)과 클라이언트(재시도·429·토큰 자동 갱신)를 재사용한다. 토큰에 `mall.read_order` 가 있어야 한다(`DEFAULT_SCOPES` 포함, 권한 추가 후 카페24 상품관리 → 시스템에서 재연결). -Admin API `GET /admin/orders`(문서 버전 2026-09-01 확인: 검색기간 한 호출 3개월 미만, limit ≤ 1000, offset ≤ 15000). -| 사건 | 조회 | 대상 | 금액·날짜 | -|---|---|---|---| -| SALE | `date_type=pay_date`, `embed=items` | `paid=T` 주문의 모든 품목 | +품목 결제금액(`payment_amount`, 할인 반영·배송비 제외), 결제일 | -| CANCEL | `date_type=cancel_complete_date` | 품목 상태 C40~C43(취소완료). 입금전취소 C47~C49 제외 | −같은 품목 금액, 품목 `cancel_date` | -| RETURN | `date_type=return_complete_date` | 품목 상태 R40~R43(반품완료) | −품목 금액(부분 반품은 `claim_quantity/quantity` 비율), `return_confirmed_date` | +**카페24 관리자 "일별 매출내역"과 같은 기준**으로 센다(처음의 품목 결제금액 방식은 배송비가 빠지고 환불 날짜 기준이 달라 +화면과 맞지 않아 교체). -- 사건 ID = `{order_item_code}-S|C|R` (중복 방지). 교환(E**)은 1단계에서 반영 안 함. -- **자체몰 주문만**(`market_id` = self/빈값). 카페24 로 연동돼 들어온 다른 마켓 주문(스마트스토어·쿠팡 등)은 해당 쇼핑몰 - 어댑터와 이중 집계되지 않게 제외. 네이버페이 결제(`order_place_id=NCHECKOUT`)는 자체몰 주문이라 포함. -- 기간은 60일씩 나눠 요청, 1000건 단위 페이지. 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않고 raw 에는 금액·상태만. -- **실데이터로 확인할 것**: 품목 `payment_amount` 가 적립금·예치금 사용분을 어떻게 반영하는지, 부분 취소/반품 시 품목이 - 분리되는지(`claim_quantity` 해석). 카페24 관리자 화면 매출과 한 주 정도 대조 후 필요하면 규칙 조정. +| 사건 | 조회 | 금액·날짜 | +|---|---|---| +| SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(상품구매금액 + 배송비 − 할인 − 쿠폰), `initial_order_amount`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) | +| CANCEL / RETURN(환불합계) | `GET /admin/refunds` `date_type=refund_date`, `status=T` | −실제 환불액(`actual_refund_amount`), 환불완료일. 환불코드 R… = 반품, 그 밖 = 취소. 사건 ID = 환불코드 | + +- 할인 = 회원·세트상품·앱·마켓 기타·배송비 할인, 쿠폰 = 상품쿠폰 + 배송비쿠폰(`DISCOUNT_FIELDS`/`COUPON_FIELDS`). +- **기간 교체(`replace_range=True`)**: 결제·환불 모두 기간 안 날짜로 조회되므로 동기화 때 그 기간의 카페24 실데이터를 지우고 + 새로 넣는다(한 트랜잭션, 테스트 데이터 제외). 규칙이 바뀌어도 예전 행이 남지 않는다 → 규칙을 고친 뒤에는 같은 기간을 + [과거 매출 가져오기]로 다시 받으면 된다. +- **자체몰 주문만**(`market_id` = self/빈값). 환불은 원 주문을 100건씩 조회해 `market_id` 로 판단. 네이버페이는 자체몰 주문. +- 60일 단위 분할(한 호출 3개월 미만), orders limit 1000 / refunds limit 500 페이지. 개인정보는 저장하지 않는다. +- **카페24 매출 대조**(설정 화면, `GET /api/marketplaces/cafe24/reconcile?date=`): 그날 결제 주문·환불을 카페24 화면 열 순서대로 + (주문수·품목수·상품구매금액·배송비·할인·쿠폰·결제합계·환불합계·순매출) 자체몰/다른 마켓으로 나눠 합산. 저장하지 않음. + 카페24 화면과 다른 줄이 있으면 할인 항목 구성·마켓 포함 여부를 이 결과로 조정한다. ### 연동 단계 체크리스트(쇼핑몰마다) From 4cb37688ed262d83a4d05951260732ff48f4e6bc Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:46:28 +0900 Subject: [PATCH 05/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=EC=97=90=20=EB=8B=A4?= =?UTF-8?q?=EB=A5=B8=20=EB=A7=88=EC=BC=93=20=EC=97=B0=EB=8F=99=20=EC=A3=BC?= =?UTF-8?q?=EB=AC=B8=EC=9D=84=20=EB=A7=88=EC=BC=93=EB=B3=84(market=5Fid?= =?UTF-8?q?=C2=B7=EC=A3=BC=EB=AC=B8=EA=B2=BD=EB=A1=9C)=EB=A1=9C=20?= =?UTF-8?q?=ED=91=9C=EC=8B=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/28 대조 결과 자체몰 + 다른 마켓 연동 합계가 카페24 일별 매출내역과 모든 줄에서 일치(공식 확인). 어느 마켓 주문인지 확인할 수 있게 market_id 별 주문수·결제합계·환불·순매출 표를 추가. Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 21 ++++++++++++++++++- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 2 ++ app/static/performance.js | 10 +++++++++ 5 files changed, 34 insertions(+), 3 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 7db0708..257f9c4 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -278,11 +278,21 @@ class Cafe24Adapter(MarketplaceAdapter): return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, "total": 0} groups = {"self": empty(), "market": empty()} + by_market: dict[str, dict[str, Any]] = {} # 다른 마켓 연동 주문 — market_id 별 unpaid = 0 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 continue + if not is_self_market(o.get("market_id")): + key = str(o.get("market_id")) + bm = by_market.setdefault(key, {"market_id": key, "names": set(), "orders": 0, "total": 0, + "refund_count": 0, "refund_amount": 0}) + bm["orders"] += 1 + bm["total"] += order_total(o) + for n in (o.get("order_place_name"), o.get("order_place_id")): + if n: + bm["names"].add(str(n)) g = groups["self" if is_self_market(o.get("market_id")) else "market"] g["orders"] += 1 g["items"] += sum(int(i.get("quantity") or 0) for i in o.get("items") or []) @@ -295,10 +305,19 @@ class Cafe24Adapter(MarketplaceAdapter): refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} for r in rows: - g = refunds["self" if is_self_market(markets.get(str(r.get("order_id")), "self")) else "market"] + mid = markets.get(str(r.get("order_id")), "self") + g = refunds["self" if is_self_market(mid) else "market"] g["count"] += 1 for k in ("actual_refund_amount", "used_points", "used_credits"): g[k] += _won(r.get(k)) + if not is_self_market(mid): + bm = by_market.setdefault(str(mid), {"market_id": str(mid), "names": set(), "orders": 0, "total": 0, + "refund_count": 0, "refund_amount": 0}) + bm["refund_count"] += 1 + bm["refund_amount"] += _won(r.get("actual_refund_amount")) + markets_out = sorted(({**v, "names": sorted(v["names"])} for v in by_market.values()), + key=lambda v: v["total"], reverse=True) return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, + "by_market": markets_out, "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index c1f3341..bb762d9 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 572675e..26bac50 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -142,4 +142,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 1365cae..53c35da 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -456,6 +456,8 @@ def test_cafe24_normalize_matches_daily_report(): assert rec["orders"]["self"]["orders"] == 1 and rec["orders"]["self"]["total"] == 47_000 assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1 + assert rec["by_market"] == [{"market_id": "shopn", "names": [], "orders": 1, "total": 47_000, + "refund_count": 1, "refund_amount": 9_000}] # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) page1 = [_c24_order(f"x-{i}") for i in range(1000)] fake2 = _FakeCafe24([page1, [_c24_order("y")]]) diff --git a/app/static/performance.js b/app/static/performance.js index 6922482..9035fc8 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -517,6 +517,16 @@ return "' + esc(x[0]) + '' + f(x[1]) + '' + f(x[2]) + ""; }).join("") + "" + + ((r.by_market || []).length + ? '

다른 마켓 연동 주문 — 마켓별

' + + '' + + "" + + r.by_market.map(function (b) { + return '"; + }).join("") + "
market_id주문경로주문수결제합계환불순매출
' + esc(b.market_id) + "" + esc((b.names || []).join(", ")) + + '' + fmt(b.orders) + '' + won(b.total) + + '' + won(-b.refund_amount) + '' + won(b.total - b.refund_amount) + "
" + : "") + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + "건 제외. 카페24 화면과 다른 줄이 있으면 알려 주세요 — 규칙을 맞추겠습니다.

"; } catch (err) { From 19396f1745fe7645c7c2b59e17d7224cfe2d9630 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:54:10 +0900 Subject: [PATCH 06/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=88=EC=BC=93=20=EC=97=B0=EB=8F=99=20=EC=A3=BC=EB=AC=B8?= =?UTF-8?q?=EC=9D=84=20=ED=95=B4=EB=8B=B9=20=EC=87=BC=ED=95=91=EB=AA=B0=20?= =?UTF-8?q?=EC=97=B4=EB=A1=9C=20=EC=A7=91=EA=B3=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 카페24 마켓 통합관리가 가져온 주문(market_id ≠ self)을 MARKET_MAP 으로 네이버·쿠팡·11번가 등 열에 (SaleEvent.marketplace_code). 연결표에 없는 마켓은 카페24 열 — 전체 합계는 카페24 일별 매출내역과 같음 - 환불도 원 주문의 마켓으로 같은 열에 - 카페24 사건 ID 에 c24: 접두어, 기간 교체는 카페24 열 + 다른 열의 c24: 행만 — 직접 연동분은 보존 - 매출 대조 마켓별 표에 "반영 열", 설정 화면에 "카페24 경유" 표시 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/base.py | 6 ++ app/modules/performance/adapters/cafe24.py | 68 ++++++++++++---- app/modules/performance/dashboard.py | 4 + app/modules/performance/db.py | 31 +++++--- app/modules/performance/sync.py | 7 +- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 3 +- .../performance/tests/test_performance.py | 78 +++++++++++-------- app/static/performance.js | 8 +- docs/PERFORMANCE_MODULE.md | 10 ++- 10 files changed, 156 insertions(+), 61 deletions(-) diff --git a/app/modules/performance/adapters/base.py b/app/modules/performance/adapters/base.py index a7e6328..3f90796 100644 --- a/app/modules/performance/adapters/base.py +++ b/app/modules/performance/adapters/base.py @@ -105,6 +105,9 @@ class SaleEvent: discount_amount: int = 0 order_status: str = "" raw: dict[str, Any] = field(default_factory=dict) + # 어느 쇼핑몰 열로 집계할지 — None 이면 이 어댑터의 쇼핑몰. 다른 쇼핑몰 주문을 대신 받아 오는 + # 연동(예: 카페24 마켓 통합관리가 가져온 스마트스토어 주문)은 해당 쇼핑몰 코드를 넣는다. + marketplace_code: str | None = None def validate(self) -> None: if self.event_type not in EVENT_TYPES: @@ -148,6 +151,9 @@ class MarketplaceAdapter(ABC): # 쇼핑몰 API 가 "기간 안 결제·환불"을 빠짐없이 돌려줄 때만 켠다 — 규칙이 바뀌거나 # 주문이 사라져도 예전 행이 남지 않는다. False 면 같은 사건 ID 만 덮어쓴다(upsert). replace_range: bool = False + # replace_range 일 때 이 어댑터가 만든 사건을 가려내는 외부 사건 ID 접두어. 다른 쇼핑몰 열로 보낸 + # 사건(marketplace_code 지정)도 이 접두어로 찾아 함께 교체한다 — 그 쇼핑몰의 직접 연동분은 건드리지 않음. + event_prefix: str = "" note: str = "" # 설정 화면 안내 문구 # ── 설정 ────────────────────────────────────────────── diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 257f9c4..1a63621 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -13,9 +13,13 @@ 실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소. - 수집 기간을 통째로 다시 받는다(replace_range) — 결제·환불 모두 기간 안 날짜로 조회되므로 그 기간의 카페24 실데이터를 지우고 새로 넣는다. 규칙이 바뀌거나 주문이 사라져도 이중 집계 없음. - - 자체몰 주문만(market_id 가 self/빈값). 카페24 로 연동돼 들어온 다른 마켓(스마트스토어·쿠팡 등) - 주문은 해당 쇼핑몰 어댑터와 이중 집계되지 않게 제외(환불도 원 주문의 market_id 로 판단). - 네이버페이 결제(order_place_id=NCHECKOUT)는 자체몰 주문이라 포함. + - 자체몰 주문(market_id 가 self/빈값)은 카페24 열. 카페24 마켓 통합관리로 들어온 다른 마켓 주문 + (스마트스토어·쿠팡 등)은 MARKET_MAP 으로 해당 쇼핑몰 열에 넣는다(환불도 원 주문으로 판단). + MARKET_MAP 에 없는 마켓은 카페24 열 — 전체 합계는 항상 카페24 일별 매출내역과 같다. + 네이버페이 결제(order_place_id=NCHECKOUT)는 자체몰 주문이라 카페24 열. + 카페24 가 만든 사건은 모두 외부 사건 ID 앞에 "c24:" — 다시 받을 때 이것만 골라 교체하므로 + 해당 쇼핑몰을 나중에 직접 연동해도 그 데이터는 건드리지 않는다(단, 같은 주문을 양쪽에서 받지 않게 + 직접 연동을 켜는 쇼핑몰은 MARKET_MAP 에서 빼야 한다). - 한 호출 검색기간 3개월 미만 → 60일씩 나눠 요청. orders limit ≤ 1000, refunds limit ≤ 500, offset ≤ 15000. - 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않는다 — raw 에는 금액·상태 필드만. - 할인 항목 구성·마켓 주문 포함 여부는 `reconcile()`(설정 화면 "카페24 매출 대조")로 카페24 화면과 @@ -45,6 +49,33 @@ LOOKUP_BATCH = 100 MAX_OFFSET = 15000 CHUNK_DAYS = 60 SELF_MARKETS = {"", "self", None} +EVENT_PREFIX = "c24:" + +# 카페24 마켓 통합관리가 가져온 주문의 market_id(또는 order_place_id) → 우리 쇼핑몰 열. +# 여기 없는 마켓(예: 옥션·인터파크)은 카페24 열에 남긴다 — 전체 합계는 항상 카페24 화면과 같다. +# 실제 값은 설정 → "카페24 매출 대조"의 마켓별 표(market_id / 주문경로 / 반영 열)로 확인해 보탠다. +MARKET_MAP: dict[str, str] = { + "shopn": "naver", "smartstore": "naver", "storefarm": "naver", "naver": "naver", + "coupang": "coupang", + "sk11st": "elevenst", "11st": "elevenst", "elevenst": "elevenst", + "gmarket": "gmarket", + "lotteon": "lotteon", "lotte": "lotteon", + "gsshop": "gsshop", "gs": "gsshop", + "kakao": "kakao", "kakaotalkstore": "kakao", "talkstore": "kakao", "kakaostyle": "kakao", + "ohouse": "ohouse", "todayhouse": "ohouse", "bucketplace": "ohouse", + "toss": "toss", "tossshopping": "toss", +} + + +def target_code(market_id: Any, order_place_id: Any = None) -> str: + """이 주문을 집계할 쇼핑몰 열. 자체몰·모르는 마켓은 카페24.""" + if is_self_market(market_id): + return "cafe24" + for key in (market_id, order_place_id): + code = MARKET_MAP.get(str(key or "").strip().lower()) + if code: + return code + return "cafe24" # 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (initial_order_amount 의 필드) DISCOUNT_FIELDS = ("membership_discount_amount", "set_product_discount_amount", "app_discount_amount", @@ -104,6 +135,7 @@ class Cafe24Adapter(MarketplaceAdapter): auth_type = "shared" implemented = True replace_range = True + event_prefix = EVENT_PREFIX docs_url = "https://apidocs.cafe24.com/docs/admin/get-orders" note = ("카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음). " "주문 읽기 권한이 필요해 권한 추가 후 한 번 다시 연결해야 합니다.") @@ -198,8 +230,8 @@ class Cafe24Adapter(MarketplaceAdapter): {"start_date": s.isoformat(), "end_date": e.isoformat(), "date_type": "refund_date"}, REFUND_LIMIT) - def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, Any]: - """환불의 원 주문 market_id — 주문일 60일 구간·100건씩 묶어 조회.""" + def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any]]: + """환불의 원 주문 (market_id, order_place_id) — 주문일 60일 구간·100건씩 묶어 조회. 못 찾으면 자체몰.""" pairs = sorted({(_day(r.get("order_date")) or date.min, str(r.get("order_id") or "")) for r in refunds if r.get("order_id")}) out: dict[str, Any] = {} @@ -212,7 +244,7 @@ class Cafe24Adapter(MarketplaceAdapter): params = {"order_id": ",".join(ids), "start_date": first.isoformat(), "end_date": group[-1][0].isoformat(), "date_type": "order_date", "limit": LOOKUP_BATCH} for o in self._get(ctx, "/admin/orders", params).get("orders") or []: - out[str(o.get("order_id"))] = o.get("market_id") + out[str(o.get("order_id"))] = (o.get("market_id"), o.get("order_place_id")) i += len(group) return out @@ -224,10 +256,12 @@ class Cafe24Adapter(MarketplaceAdapter): rows = [r for r in self.refunds(ctx, start, end) if str(r.get("status") or "T") == "T"] markets = self.market_ids(ctx, rows) for r in rows: - yield {**r, "_market_id": markets.get(str(r.get("order_id")), "self")} + mid, place = markets.get(str(r.get("order_id")), ("self", None)) + yield {**r, "_market_id": mid, "_order_place_id": place} def normalize_order(self, order: dict[str, Any]) -> list[SaleEvent]: - if not is_self_market(order.get("market_id")) or order.get("paid") != "T": + """결제 주문 → SALE. 자체몰은 카페24 열, 마켓 연동 주문은 해당 쇼핑몰 열(MARKET_MAP).""" + if order.get("paid") != "T": return [] pay_day = _day(order.get("payment_date")) if pay_day is None: @@ -236,8 +270,10 @@ class Cafe24Adapter(MarketplaceAdapter): names = [str(i.get("product_name") or "") for i in items if i.get("product_name")] name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else "" oid = str(order.get("order_id") or "") + target = target_code(order.get("market_id"), order.get("order_place_id")) return [SaleEvent( - event_type="SALE", external_event_id=f"{oid}-PAY", external_order_id=oid, + marketplace_code=target, + event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}-PAY", external_order_id=oid, order_date=_day(order.get("order_date")), payment_date=pay_day, event_date=pay_day, amount=max(0, order_total(order)), product_name=name, quantity=sum(int(i.get("quantity") or 0) for i in items), order_status="결제완료", @@ -247,16 +283,16 @@ class Cafe24Adapter(MarketplaceAdapter): )] def normalize_refund(self, refund: dict[str, Any]) -> list[SaleEvent]: - if not is_self_market(refund.get("_market_id")): - return [] + """환불 → CANCEL/RETURN(−). 원 주문의 market_id 로 결제와 같은 쇼핑몰 열에 넣는다.""" day = _day(refund.get("refund_date")) code = str(refund.get("refund_code") or "") if day is None or not code: return [] amount = _won(refund.get("actual_refund_amount")) return [SaleEvent( + marketplace_code=target_code(refund.get("_market_id"), refund.get("_order_place_id")), event_type="RETURN" if code.upper().startswith("R") else "CANCEL", - external_event_id=code, external_order_id=str(refund.get("order_id") or ""), + external_event_id=f"{EVENT_PREFIX}{code}", external_order_id=str(refund.get("order_id") or ""), external_line_id=",".join(refund.get("order_item_code") or []), order_date=_day(refund.get("order_date")), event_date=day, amount=-amount, quantity=-int(refund.get("quantity") or 0), order_status="환불완료", @@ -287,7 +323,8 @@ class Cafe24Adapter(MarketplaceAdapter): if not is_self_market(o.get("market_id")): key = str(o.get("market_id")) bm = by_market.setdefault(key, {"market_id": key, "names": set(), "orders": 0, "total": 0, - "refund_count": 0, "refund_amount": 0}) + "refund_count": 0, "refund_amount": 0, + "target": target_code(o.get("market_id"), o.get("order_place_id"))}) bm["orders"] += 1 bm["total"] += order_total(o) for n in (o.get("order_place_name"), o.get("order_place_id")): @@ -305,14 +342,15 @@ class Cafe24Adapter(MarketplaceAdapter): refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} for r in rows: - mid = markets.get(str(r.get("order_id")), "self") + mid, place = markets.get(str(r.get("order_id")), ("self", None)) g = refunds["self" if is_self_market(mid) else "market"] g["count"] += 1 for k in ("actual_refund_amount", "used_points", "used_credits"): g[k] += _won(r.get(k)) if not is_self_market(mid): bm = by_market.setdefault(str(mid), {"market_id": str(mid), "names": set(), "orders": 0, "total": 0, - "refund_count": 0, "refund_amount": 0}) + "refund_count": 0, "refund_amount": 0, + "target": target_code(mid, place)}) bm["refund_count"] += 1 bm["refund_amount"] += _won(r.get("actual_refund_amount")) markets_out = sorted(({**v, "names": sorted(v["names"])} for v in by_market.values()), diff --git a/app/modules/performance/dashboard.py b/app/modules/performance/dashboard.py index e74b313..23bc798 100644 --- a/app/modules/performance/dashboard.py +++ b/app/modules/performance/dashboard.py @@ -157,9 +157,12 @@ def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapp key_versions_in_use: Mapping[int, int], sample_count: int) -> dict[str, Any]: from app.timezone import today_kst # noqa: WPS433 + from .adapters.cafe24 import MARKET_MAP # noqa: WPS433 + statuses = store.statuses() rates = store.rate_table() today = today_kst() + via_cafe24 = set(MARKET_MAP.values()) # 카페24 마켓 통합관리 경유로 매출이 들어오는 쇼핑몰 rows = [] by_code = {m["code"]: m for m in store.list_marketplaces()} for adapter in all_adapters(): @@ -178,6 +181,7 @@ def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapp "auth_type": adapter.auth_type, "shared": adapter.uses_shared_integration, "implemented": adapter.implemented, "note": adapter.note, "docs_url": adapter.docs_url, "configured": configured.get(adapter.code, False), + "via_cafe24": adapter.code in via_cafe24, "status": st, "status_label": STATUS_LABELS.get(st, st), "last_test_at": st_row.get("last_test_at"), "last_test_ok": st_row.get("last_test_ok"), "last_sync_at": st_row.get("last_sync_at"), "last_success_sync_at": st_row.get("last_success_sync_at"), diff --git a/app/modules/performance/db.py b/app/modules/performance/db.py index 5c00b60..1a4180c 100644 --- a/app/modules/performance/db.py +++ b/app/modules/performance/db.py @@ -224,17 +224,28 @@ class PerformanceDBStore: cur.executemany(self._UPSERT_SQL, rows) return len(rows) - def replace_events(self, code: str, start: date, end: date, events: Iterable[dict[str, Any]]) -> int: - """기간(sales_date) 안 이 쇼핑몰 실데이터(is_sample 아님)를 지우고 새로 넣는다 — 한 트랜잭션. - 테스트 데이터는 건드리지 않는다. 실패하면 롤백되어 예전 데이터가 그대로 남는다.""" + 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(): - 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 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) @@ -242,8 +253,10 @@ class PerformanceDBStore: @staticmethod def _event_rows(code: str, events: Iterable[dict[str, Any]], is_sample: bool) -> list[tuple]: + """행마다 집계할 쇼핑몰 = 사건의 marketplace_code(다른 쇼핑몰 대신 받은 주문), 없으면 code.""" return [ - (code, e["event_type"], e["external_event_id"], e["external_order_id"], e.get("external_line_id", ""), + (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", ""), diff --git a/app/modules/performance/sync.py b/app/modules/performance/sync.py index 0551445..e53e2c7 100644 --- a/app/modules/performance/sync.py +++ b/app/modules/performance/sync.py @@ -108,10 +108,15 @@ class SyncService: 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) + 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) diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index bb762d9..693e4b6 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 26bac50..34b114e 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -57,6 +57,7 @@ {% if r.shared %}공통 연동 {% elif r.configured %}설정완료 {% else %}미설정{% endif %} + {% if r.via_cafe24 %}카페24 경유{% endif %} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 53c35da..70c9e5a 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -245,15 +245,18 @@ class FakeStore: def record_test(self, code, *, status, ok, error=""): self.status[code] = {"status": status, "ok": ok, "error": error, "test": True} - def replace_events(self, code, start, end, events): + def replace_events(self, code, start, end, events, *, id_prefix=""): + def mine(k, v): + return k[0] == code or (id_prefix and k[2].startswith(id_prefix)) self.events = {k: v for k, v in self.events.items() - if not (k[0] == code and not v["is_sample"] and start <= v["sales_date"] <= end)} + if not (mine(k, v) and not v["is_sample"] and start <= v["sales_date"] <= end)} return self.upsert_events(code, events) def upsert_events(self, code, events, *, is_sample=False): n = 0 for e in events: - self.events[(code, e["event_type"], e["external_event_id"])] = {**e, "is_sample": is_sample} + target = e.get("marketplace_code") or code + self.events[(target, e["event_type"], e["external_event_id"])] = {**e, "is_sample": is_sample} n += 1 return n @@ -426,38 +429,47 @@ class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist def test_cafe24_normalize_matches_daily_report(): from app.modules.performance.adapters.base import AdapterContext - from app.modules.performance.adapters.cafe24 import order_total + from app.modules.performance.adapters.cafe24 import order_total, target_code ctx = AdapterContext(code="cafe24", credentials=None) fake = _FakeCafe24( - [[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C", paid="F")]], + [[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C", paid="F"), + _c24_order("D", market="auction")]], [[_c24_refund("C20260929-01", "A", 12_610), _c24_refund("R20260929-02", "X", 20_000), _c24_refund("C20260929-03", "M", 9_000), _c24_refund("C20260929-04", "A", 5_000, status="F")]], lookup={"M": "shopn"}, ) fetched, events = fake.collect(ctx, date(2026, 9, 29), date(2026, 9, 29)) by = {(e.event_type, e.external_event_id): e for e in events} - # 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (결제 당시 금액) - sale = by[("SALE", "A-PAY")] - assert sale.amount == 50_000 + 3_000 - 1_000 - 5_000 == 47_000 + # 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (결제 당시 금액), 사건 ID 는 c24: 접두어 + sale = by[("SALE", "c24:A-PAY")] + assert sale.amount == 50_000 + 3_000 - 1_000 - 5_000 == 47_000 and sale.marketplace_code == "cafe24" assert sale.event_date == date(2026, 9, 29) and sale.quantity == 2 and sale.product_name == "상품1 외 1건" - assert not any(e.external_order_id in ("B", "C") and e.event_type == "SALE" for e in events) # 마켓·미결제 제외 - # 환불: 환불완료일, 실제 환불액, R→반품 / 그 밖→취소, 마켓 주문·미완료 환불 제외 - assert by[("CANCEL", "C20260929-01")].amount == -12_610 - assert by[("RETURN", "R20260929-02")].amount == -20_000 - assert ("CANCEL", "C20260929-03") not in by and ("CANCEL", "C20260929-04") not in by - assert by[("CANCEL", "C20260929-01")].event_date == date(2026, 9, 29) + # 마켓 연동 주문은 해당 쇼핑몰 열로, 연결표에 없는 마켓(옥션)은 카페24 열, 미결제는 제외 + assert by[("SALE", "c24:B-PAY")].marketplace_code == "naver" + assert by[("SALE", "c24:D-PAY")].marketplace_code == "cafe24" + assert ("SALE", "c24:C-PAY") not in by + # 환불: 환불완료일, 실제 환불액, R→반품 / 그 밖→취소, 원 주문의 마켓 열로, 미완료 환불 제외 + assert by[("CANCEL", "c24:C20260929-01")].amount == -12_610 + assert by[("CANCEL", "c24:C20260929-01")].marketplace_code == "cafe24" + assert by[("RETURN", "c24:R20260929-02")].amount == -20_000 + assert by[("CANCEL", "c24:C20260929-03")].marketplace_code == "naver" + assert ("CANCEL", "c24:C20260929-04") not in by + assert by[("CANCEL", "c24:C20260929-01")].event_date == date(2026, 9, 29) for e in events: assert "buyer_name" not in str(e.raw) and "1234567890" not in str(e.raw) # 개인정보 미저장 assert order_total({"initial_order_amount": {"order_price_amount": "1578300.00", "shipping_fee": "45500.00", "coupon_discount_price": "57000.00"}}) == 1_566_800 # 9/29 화면값 - # 대조: 자체몰/마켓 나눠 합산 + assert target_code("self") == "cafe24" and target_code("SK11ST") == "elevenst" + assert target_code("unknown", "coupang") == "coupang" and target_code("unknown") == "cafe24" + # 대조: 자체몰/마켓 나눠 합산 + 마켓별 반영 열 rec = fake.reconcile(ctx, date(2026, 9, 29)) assert rec["orders"]["self"]["orders"] == 1 and rec["orders"]["self"]["total"] == 47_000 - assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 + assert rec["orders"]["market"]["orders"] == 2 and rec["unpaid_orders"] == 1 assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1 - assert rec["by_market"] == [{"market_id": "shopn", "names": [], "orders": 1, "total": 47_000, - "refund_count": 1, "refund_amount": 9_000}] + bym = {b["market_id"]: b for b in rec["by_market"]} + assert bym["shopn"]["target"] == "naver" and bym["shopn"]["refund_amount"] == 9_000 + assert bym["auction"]["target"] == "cafe24" and bym["auction"]["orders"] == 1 # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) page1 = [_c24_order(f"x-{i}") for i in range(1000)] fake2 = _FakeCafe24([page1, [_c24_order("y")]]) @@ -484,25 +496,29 @@ def test_cafe24_scope_and_replace_range(): raise AssertionError("주문 권한 없으면 인증 실패여야 합니다") real.shared_status = lambda c: {"connected": True, "scopes": "mall.read_product,mall.read_order"} real.authenticate(ctx) - # 기간 교체: 그 기간의 예전 실데이터(품목 단위 등)는 지우고, 테스트 데이터·기간 밖은 남긴다 + + def ev(eid, day, **kw): + return {"event_type": "SALE", "external_event_id": eid, "external_order_id": "o", + "event_date": day, "sales_date": day, "amount": 1, **kw} + + # 기간 교체: 기간 안 카페24 행(예전 품목 단위)·카페24 경유 네이버 행은 지우고, + # 네이버 직접 연동분·테스트 데이터·기간 밖은 남긴다 st = FakeStore() - st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "old-item-S", "external_order_id": "A", - "event_date": date(2026, 9, 29), "sales_date": date(2026, 9, 29), "amount": 1}]) - st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "outside", "external_order_id": "Z", - "event_date": date(2026, 9, 1), "sales_date": date(2026, 9, 1), "amount": 1}]) - st.upsert_events("cafe24", [{"event_type": "SALE", "external_event_id": "sample", "external_order_id": "S", - "event_date": date(2026, 9, 29), "sales_date": date(2026, 9, 29), "amount": 1}], - is_sample=True) - fake = _FakeCafe24([[_c24_order("A")]]) + d, out = date(2026, 9, 29), date(2026, 9, 1) + st.upsert_events("cafe24", [ev("old-item-S", d), ev("outside", out)]) + st.upsert_events("naver", [ev("c24:OLD-PAY", d), ev("direct-naver-1", d)]) + st.upsert_events("cafe24", [ev("sample", d)], is_sample=True) + fake = _FakeCafe24([[_c24_order("A"), _c24_order("B", market="shopn")]]) orig = syncmod.get_adapter syncmod.get_adapter = lambda c: fake try: - r = SyncService(st, CredentialService(st, lambda: ring())).sync_marketplace( - "cafe24", date(2026, 9, 29), date(2026, 9, 29)) + r = SyncService(st, CredentialService(st, lambda: ring())).sync_marketplace("cafe24", d, d) finally: syncmod.get_adapter = orig - ids = {k[2] for k in st.events if k[0] == "cafe24"} - assert r["ok"] and ids == {"A-PAY", "outside", "sample"}, ids + got = {(k[0], k[2]) for k in st.events} + assert r["ok"], r + assert got == {("cafe24", "c24:A-PAY"), ("naver", "c24:B-PAY"), ("cafe24", "outside"), + ("naver", "direct-naver-1"), ("cafe24", "sample")}, got def test_registry_and_event_validation(): diff --git a/app/static/performance.js b/app/static/performance.js index 9035fc8..62b8520 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -482,6 +482,8 @@ const r = await api("GET", "/performance/api/marketplaces/cafe24/reconcile?date=" + encodeURIComponent(day)); if (!r.ok) { out.innerHTML = '

' + esc((r.label ? r.label + " — " : "") + r.message) + "

"; return; } const s = r.orders.self, m = r.orders.market, rs = r.refunds.self, rm = r.refunds.market; + const MARKET_NAMES = {}; + root.querySelectorAll("tr[data-code]").forEach(function (tr) { MARKET_NAMES[tr.dataset.code] = tr.dataset.name; }); const disc = ["membership_discount_amount", "set_product_discount_amount", "app_discount_amount", "market_other_discount_amount", "shipping_fee_discount_amount"]; const coup = ["coupon_discount_price", "coupon_shipping_fee_amount"]; @@ -510,7 +512,7 @@ ["순매출(결제합계 − 환불합계)", s.total - rs.actual_refund_amount, m.total - rm.actual_refund_amount, "key"], ]); out.innerHTML = '" + + "" + rows.map(function (x) { const cls = x[3] === "key" ? ' class="perf-row-week"' : ""; const f = function (v) { return x[3] === "cnt" ? fmt(v) : won(v); }; @@ -520,9 +522,11 @@ ((r.by_market || []).length ? '

다른 마켓 연동 주문 — 마켓별

' + '
' + esc(r.date) + - "자체몰(실적 반영)다른 마켓 연동(제외)
자체몰(카페24 열)다른 마켓 연동(해당 쇼핑몰 열)
' + - "" + + '' + r.by_market.map(function (b) { + const col = MARKET_NAMES[b.target] || b.target; return '"; }).join("") + "
market_id주문경로주문수결제합계환불순매출
반영 열주문수결제합계환불순매출
' + esc(b.market_id) + "" + esc((b.names || []).join(", ")) + + "" + esc(col) + (b.target === "cafe24" ? ' (연결표 없음)' : "") + '' + fmt(b.orders) + '' + won(b.total) + '' + won(-b.refund_amount) + '' + won(b.total - b.refund_amount) + "
" diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 727d81d..8ca3e34 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -49,7 +49,15 @@ - **기간 교체(`replace_range=True`)**: 결제·환불 모두 기간 안 날짜로 조회되므로 동기화 때 그 기간의 카페24 실데이터를 지우고 새로 넣는다(한 트랜잭션, 테스트 데이터 제외). 규칙이 바뀌어도 예전 행이 남지 않는다 → 규칙을 고친 뒤에는 같은 기간을 [과거 매출 가져오기]로 다시 받으면 된다. -- **자체몰 주문만**(`market_id` = self/빈값). 환불은 원 주문을 100건씩 조회해 `market_id` 로 판단. 네이버페이는 자체몰 주문. +- **마켓 연동 주문은 해당 쇼핑몰 열로**: 자체몰(`market_id` = self/빈값)은 카페24 열. 카페24 마켓 통합관리가 가져온 + 다른 마켓 주문은 `MARKET_MAP`(market_id 또는 order_place_id → 우리 쇼핑몰 코드)으로 네이버·쿠팡·11번가 등 열에 넣는다 + (`SaleEvent.marketplace_code`). 연결표에 없는 마켓은 카페24 열 — **전체 합계는 항상 카페24 일별 매출내역과 같다** + (9/28 대조로 자체몰+마켓 합계가 모든 줄에서 일치 확인). 환불은 원 주문을 100건씩 조회해 같은 열로. 네이버페이는 자체몰. +- 카페24 가 만든 사건 ID 는 모두 `c24:` 접두어(`event_prefix`) — 다시 받을 때 카페24 열 + 다른 열의 `c24:` 행만 교체해 + 그 쇼핑몰의 **직접 연동분은 건드리지 않는다**. 어떤 쇼핑몰을 직접 API 로 연동하면 같은 주문을 두 번 받지 않도록 그 마켓을 + `MARKET_MAP` 에서 빼야 한다. 설정 화면 API 설정 칸의 "카페24 경유" 표시 = 카페24 수집 때 함께 반영되는 쇼핑몰. +- 실제 market_id 값은 "카페24 매출 대조"의 마켓별 표(market_id / 주문경로 / 반영 열)로 확인하고, "(연결표 없음)"으로 나오는 + 마켓이 우리 쇼핑몰이면 `MARKET_MAP` 에 추가한다. - 60일 단위 분할(한 호출 3개월 미만), orders limit 1000 / refunds limit 500 페이지. 개인정보는 저장하지 않는다. - **카페24 매출 대조**(설정 화면, `GET /api/marketplaces/cafe24/reconcile?date=`): 그날 결제 주문·환불을 카페24 화면 열 순서대로 (주문수·품목수·상품구매금액·배송비·할인·쿠폰·결제합계·환불합계·순매출) 자체몰/다른 마켓으로 나눠 합산. 저장하지 않음. From f63f82d64297cfd4839a06a284b27889d335fb2d Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 16:59:16 +0900 Subject: [PATCH 07/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20market=5Fid=20=EC=9D=98=20=EC=9E=90=EC=B2=B4=EB=AA=B0=20?= =?UTF-8?q?=EC=B1=84=EB=84=90(=EB=AA=A8=EB=B0=94=EC=9D=BC=EC=9B=B9=C2=B7?= =?UTF-8?q?=EB=84=A4=EC=9D=B4=EB=B2=84=ED=8E=98=EC=9D=B4=C2=B7=ED=86=A1?= =?UTF-8?q?=EC=B2=B4=ED=81=AC=EC=95=84=EC=9B=83)=EC=9D=84=20=EC=9E=90?= =?UTF-8?q?=EC=B2=B4=EB=AA=B0=EB=A1=9C=20=EB=B6=84=EB=A5=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 실데이터 대조 결과 "다른 마켓 연동"으로 보이던 주문은 mobile(모바일웹)·NCHECKOUT(네이버페이)· KAKAOPAY(톡체크아웃) — 모두 카페24 자체몰 주문. 금액은 이미 카페24 열이었지만 대조 표시가 오해를 불렀다. - SELF_CHANNELS 로 자체몰 채널 명시, channel_kind(self/market/unknown) - MARKET_MAP 에서 결제수단과 헷갈리는 일반 이름(naver, kakao 등) 제거 - 매출 대조: "카페24 열 / 다른 쇼핑몰 열" + "주문 채널별" 표(자체몰 채널/외부 마켓/알 수 없는 채널) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 101 +++++++++++------- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 22 ++-- app/static/performance.js | 16 +-- docs/PERFORMANCE_MODULE.md | 6 +- 6 files changed, 92 insertions(+), 57 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 1a63621..e6c2f71 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -48,34 +48,51 @@ REFUND_LIMIT = 500 LOOKUP_BATCH = 100 MAX_OFFSET = 15000 CHUNK_DAYS = 60 -SELF_MARKETS = {"", "self", None} EVENT_PREFIX = "c24:" -# 카페24 마켓 통합관리가 가져온 주문의 market_id(또는 order_place_id) → 우리 쇼핑몰 열. -# 여기 없는 마켓(예: 옥션·인터파크)은 카페24 열에 남긴다 — 전체 합계는 항상 카페24 화면과 같다. -# 실제 값은 설정 → "카페24 매출 대조"의 마켓별 표(market_id / 주문경로 / 반영 열)로 확인해 보탠다. +# 카페24 자체몰 주문 채널 — market_id 는 외부 마켓만이 아니라 주문 채널·간편결제도 담는다 +# (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃). +# 이 주문들은 카페24 자체몰 매출이다. 비교는 소문자로. +SELF_CHANNELS: dict[str, str] = { + "": "자체몰", "self": "자체몰(PC)", "cafe24": "자체몰", "mobile": "모바일웹", "mobile_d": "모바일앱", + "ncheckout": "네이버페이", "kakaopay": "톡체크아웃", +} + +# 카페24 마켓 통합관리가 가져온 외부 마켓 주문의 market_id(또는 order_place_id) → 우리 쇼핑몰 열. +# 여기에도 SELF_CHANNELS 에도 없는 채널은 "알 수 없는 채널"로 카페24 열에 남긴다 — 전체 합계는 항상 +# 카페24 화면과 같다. 결제수단(네이버페이·카카오페이)과 헷갈릴 수 있는 일반 이름(naver, kakao)은 넣지 않는다. +# 실제 값은 설정 → "카페24 매출 대조"의 주문 채널별 표로 확인해 보탠다. MARKET_MAP: dict[str, str] = { - "shopn": "naver", "smartstore": "naver", "storefarm": "naver", "naver": "naver", + "shopn": "naver", "smartstore": "naver", "storefarm": "naver", "coupang": "coupang", "sk11st": "elevenst", "11st": "elevenst", "elevenst": "elevenst", "gmarket": "gmarket", - "lotteon": "lotteon", "lotte": "lotteon", - "gsshop": "gsshop", "gs": "gsshop", - "kakao": "kakao", "kakaotalkstore": "kakao", "talkstore": "kakao", "kakaostyle": "kakao", + "lotteon": "lotteon", + "gsshop": "gsshop", + "kakaotalkstore": "kakao", "talkstore": "kakao", "kakaostyle": "kakao", "ohouse": "ohouse", "todayhouse": "ohouse", "bucketplace": "ohouse", - "toss": "toss", "tossshopping": "toss", + "tossshopping": "toss", } +def _key(value: Any) -> str: + return str(value or "").strip().lower() + + +def channel_kind(market_id: Any, order_place_id: Any = None) -> str: + """self(자체몰 채널) / market(외부 마켓, 해당 쇼핑몰 열) / unknown(모르는 채널 → 카페24 열).""" + if market_id is None or _key(market_id) in SELF_CHANNELS: + return "self" + if _key(market_id) in MARKET_MAP or _key(order_place_id) in MARKET_MAP: + return "market" + return "unknown" + + def target_code(market_id: Any, order_place_id: Any = None) -> str: - """이 주문을 집계할 쇼핑몰 열. 자체몰·모르는 마켓은 카페24.""" - if is_self_market(market_id): + """이 주문을 집계할 쇼핑몰 열. 자체몰 채널·모르는 채널은 카페24.""" + if channel_kind(market_id, order_place_id) != "market": return "cafe24" - for key in (market_id, order_place_id): - code = MARKET_MAP.get(str(key or "").strip().lower()) - if code: - return code - return "cafe24" + return MARKET_MAP.get(_key(market_id)) or MARKET_MAP[_key(order_place_id)] # 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (initial_order_amount 의 필드) DISCOUNT_FIELDS = ("membership_discount_amount", "set_product_discount_amount", "app_discount_amount", @@ -118,7 +135,8 @@ def order_total(order: dict[str, Any]) -> int: def is_self_market(market_id: Any) -> bool: - return market_id in SELF_MARKETS + """카페24 자체몰 채널(PC·모바일·네이버페이·톡체크아웃 등)인가.""" + return channel_kind(market_id) == "self" def _chunks(start: date, end: date) -> Iterable[tuple[date, date]]: @@ -306,31 +324,37 @@ class Cafe24Adapter(MarketplaceAdapter): def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]: """그날 결제 주문·환불을 항목별로 합산 — 카페24 일별 매출내역과 비교해 규칙을 확정하는 용도. - 자체몰/다른 마켓을 나눠 합산한다. 개인정보는 담지 않는다. + groups["self"] = 카페24 열(자체몰 채널 + 알 수 없는 채널), groups["market"] = 다른 쇼핑몰 열로 가는 + 외부 마켓 주문. by_channel = 주문 채널(market_id)별 내역. 개인정보는 담지 않는다. """ self.authenticate(ctx) def empty() -> dict[str, int]: return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, "total": 0} + def channel(mid: Any, place: Any) -> dict[str, Any]: + key = "" if mid is None else str(mid) + kind = channel_kind(mid, place) + return by_channel.setdefault(key, { + "market_id": key or "(없음)", "label": SELF_CHANNELS.get(_key(mid), ""), "names": set(), + "kind": kind, "target": target_code(mid, place), + "orders": 0, "total": 0, "refund_count": 0, "refund_amount": 0, + }) + groups = {"self": empty(), "market": empty()} - by_market: dict[str, dict[str, Any]] = {} # 다른 마켓 연동 주문 — market_id 별 + by_channel: dict[str, dict[str, Any]] = {} unpaid = 0 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 continue - if not is_self_market(o.get("market_id")): - key = str(o.get("market_id")) - bm = by_market.setdefault(key, {"market_id": key, "names": set(), "orders": 0, "total": 0, - "refund_count": 0, "refund_amount": 0, - "target": target_code(o.get("market_id"), o.get("order_place_id"))}) - bm["orders"] += 1 - bm["total"] += order_total(o) - for n in (o.get("order_place_name"), o.get("order_place_id")): - if n: - bm["names"].add(str(n)) - g = groups["self" if is_self_market(o.get("market_id")) else "market"] + ch = channel(o.get("market_id"), o.get("order_place_id")) + ch["orders"] += 1 + ch["total"] += order_total(o) + for n in (o.get("order_place_name"), o.get("order_place_id")): + if n: + ch["names"].add(str(n)) + g = groups["self" if ch["target"] == "cafe24" else "market"] g["orders"] += 1 g["items"] += sum(int(i.get("quantity") or 0) for i in o.get("items") or []) g["lines"] += len(o.get("items") or []) @@ -343,19 +367,16 @@ class Cafe24Adapter(MarketplaceAdapter): "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} for r in rows: mid, place = markets.get(str(r.get("order_id")), ("self", None)) - g = refunds["self" if is_self_market(mid) else "market"] + ch = channel(mid, place) + g = refunds["self" if ch["target"] == "cafe24" else "market"] g["count"] += 1 for k in ("actual_refund_amount", "used_points", "used_credits"): g[k] += _won(r.get(k)) - if not is_self_market(mid): - bm = by_market.setdefault(str(mid), {"market_id": str(mid), "names": set(), "orders": 0, "total": 0, - "refund_count": 0, "refund_amount": 0, - "target": target_code(mid, place)}) - bm["refund_count"] += 1 - bm["refund_amount"] += _won(r.get("actual_refund_amount")) - markets_out = sorted(({**v, "names": sorted(v["names"])} for v in by_market.values()), - key=lambda v: v["total"], reverse=True) + ch["refund_count"] += 1 + ch["refund_amount"] += _won(r.get("actual_refund_amount")) + channels_out = sorted(({**v, "names": sorted(v["names"])} for v in by_channel.values()), + key=lambda v: v["total"], reverse=True) return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, - "by_market": markets_out, + "by_channel": channels_out, "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 693e4b6..aa7df32 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 34b114e..bec4221 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 70c9e5a..4bc9d5d 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -434,7 +434,8 @@ def test_cafe24_normalize_matches_daily_report(): ctx = AdapterContext(code="cafe24", credentials=None) fake = _FakeCafe24( [[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C", paid="F"), - _c24_order("D", market="auction")]], + _c24_order("D", market="auction"), _c24_order("E", market="NCHECKOUT"), + _c24_order("F", market="KAKAOPAY"), _c24_order("G", market="mobile")]], [[_c24_refund("C20260929-01", "A", 12_610), _c24_refund("R20260929-02", "X", 20_000), _c24_refund("C20260929-03", "M", 9_000), _c24_refund("C20260929-04", "A", 5_000, status="F")]], lookup={"M": "shopn"}, @@ -448,6 +449,9 @@ def test_cafe24_normalize_matches_daily_report(): # 마켓 연동 주문은 해당 쇼핑몰 열로, 연결표에 없는 마켓(옥션)은 카페24 열, 미결제는 제외 assert by[("SALE", "c24:B-PAY")].marketplace_code == "naver" assert by[("SALE", "c24:D-PAY")].marketplace_code == "cafe24" + # 네이버페이·톡체크아웃·모바일웹은 카페24 자체몰 주문(실데이터 확인) — 네이버/카카오 열로 가면 안 된다 + for oid in ("E", "F", "G"): + assert by[("SALE", f"c24:{oid}-PAY")].marketplace_code == "cafe24", oid assert ("SALE", "c24:C-PAY") not in by # 환불: 환불완료일, 실제 환불액, R→반품 / 그 밖→취소, 원 주문의 마켓 열로, 미완료 환불 제외 assert by[("CANCEL", "c24:C20260929-01")].amount == -12_610 @@ -462,14 +466,18 @@ def test_cafe24_normalize_matches_daily_report(): "coupon_discount_price": "57000.00"}}) == 1_566_800 # 9/29 화면값 assert target_code("self") == "cafe24" and target_code("SK11ST") == "elevenst" assert target_code("unknown", "coupang") == "coupang" and target_code("unknown") == "cafe24" - # 대조: 자체몰/마켓 나눠 합산 + 마켓별 반영 열 + assert target_code("NCHECKOUT", "NCHECKOUT") == "cafe24" and target_code("KAKAOPAY") == "cafe24" + assert target_code("naver") == "cafe24" and target_code("kakao") == "cafe24" # 결제수단과 헷갈리는 일반 이름 X + # 대조: 카페24 열(자체몰 채널+모르는 채널)/다른 쇼핑몰 열 + 주문 채널별 rec = fake.reconcile(ctx, date(2026, 9, 29)) - assert rec["orders"]["self"]["orders"] == 1 and rec["orders"]["self"]["total"] == 47_000 - assert rec["orders"]["market"]["orders"] == 2 and rec["unpaid_orders"] == 1 + assert rec["orders"]["self"]["orders"] == 5 and rec["orders"]["self"]["total"] == 5 * 47_000 # A,D,E,F,G + assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 # B(스마트스토어) assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1 - bym = {b["market_id"]: b for b in rec["by_market"]} - assert bym["shopn"]["target"] == "naver" and bym["shopn"]["refund_amount"] == 9_000 - assert bym["auction"]["target"] == "cafe24" and bym["auction"]["orders"] == 1 + ch = {b["market_id"]: b for b in rec["by_channel"]} + assert ch["shopn"]["kind"] == "market" and ch["shopn"]["target"] == "naver" and ch["shopn"]["refund_amount"] == 9_000 + assert ch["auction"]["kind"] == "unknown" and ch["auction"]["target"] == "cafe24" + assert ch["NCHECKOUT"]["kind"] == "self" and ch["NCHECKOUT"]["label"] == "네이버페이" + assert ch["KAKAOPAY"]["label"] == "톡체크아웃" and ch["mobile"]["label"] == "모바일웹" # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) page1 = [_c24_order(f"x-{i}") for i in range(1000)] fake2 = _FakeCafe24([page1, [_c24_order("y")]]) diff --git a/app/static/performance.js b/app/static/performance.js index 62b8520..b1dc828 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -512,27 +512,29 @@ ["순매출(결제합계 − 환불합계)", s.total - rs.actual_refund_amount, m.total - rm.actual_refund_amount, "key"], ]); out.innerHTML = '" + + "" + rows.map(function (x) { const cls = x[3] === "key" ? ' class="perf-row-week"' : ""; const f = function (v) { return x[3] === "cnt" ? fmt(v) : won(v); }; return ""; }).join("") + "
' + esc(r.date) + - "자체몰(카페24 열)다른 마켓 연동(해당 쇼핑몰 열)
카페24 열(자체몰 채널)다른 쇼핑몰 열(외부 마켓)
' + esc(x[0]) + '' + f(x[1]) + '' + f(x[2]) + "
" + - ((r.by_market || []).length - ? '

다른 마켓 연동 주문 — 마켓별

' + + ((r.by_channel || []).length + ? '

주문 채널별

' + '' + - '' + - r.by_market.map(function (b) { + '' + + r.by_channel.map(function (b) { const col = MARKET_NAMES[b.target] || b.target; + const kind = b.kind === "self" ? "자체몰 채널" + (b.label ? "(" + b.label + ")" : "") + : b.kind === "market" ? "외부 마켓" : '알 수 없는 채널'; return '"; }).join("") + "
market_id주문경로반영 열주문수결제합계환불순매출
구분반영 열주문수결제합계환불순매출
' + esc(b.market_id) + "" + esc((b.names || []).join(", ")) + - "" + esc(col) + (b.target === "cafe24" ? ' (연결표 없음)' : "") + + "" + (b.kind === "unknown" ? kind : esc(kind)) + "" + esc(col) + '' + fmt(b.orders) + '' + won(b.total) + '' + won(-b.refund_amount) + '' + won(b.total - b.refund_amount) + "
" : "") + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + - "건 제외. 카페24 화면과 다른 줄이 있으면 알려 주세요 — 규칙을 맞추겠습니다.

"; + "건 제외. \"알 수 없는 채널\"은 카페24 열에 넣습니다 — 외부 마켓이면 어느 쇼핑몰인지 알려 주세요.

"; } catch (err) { out.innerHTML = '

' + esc(err.message) + "

"; } finally { recon.disabled = false; } diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 8ca3e34..3f5751b 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -49,7 +49,11 @@ - **기간 교체(`replace_range=True`)**: 결제·환불 모두 기간 안 날짜로 조회되므로 동기화 때 그 기간의 카페24 실데이터를 지우고 새로 넣는다(한 트랜잭션, 테스트 데이터 제외). 규칙이 바뀌어도 예전 행이 남지 않는다 → 규칙을 고친 뒤에는 같은 기간을 [과거 매출 가져오기]로 다시 받으면 된다. -- **마켓 연동 주문은 해당 쇼핑몰 열로**: 자체몰(`market_id` = self/빈값)은 카페24 열. 카페24 마켓 통합관리가 가져온 +- **주의 — `market_id` 는 외부 마켓만이 아니라 자체몰 주문 채널·간편결제도 담는다**(실데이터 확인 2026-09-30: + `mobile`=모바일웹, `NCHECKOUT`=네이버페이, `KAKAOPAY`=톡체크아웃). 이들은 `SELF_CHANNELS` 로 카페24 열. + 대조 도구의 "주문 채널별" 표가 채널마다 자체몰 채널 / 외부 마켓 / 알 수 없는 채널(→ 카페24 열)을 보여 준다. + `MARKET_MAP` 에는 결제수단과 헷갈릴 수 있는 일반 이름(naver, kakao)을 넣지 않는다. +- **마켓 연동 주문은 해당 쇼핑몰 열로**: 자체몰 채널은 카페24 열. 카페24 마켓 통합관리가 가져온 다른 마켓 주문은 `MARKET_MAP`(market_id 또는 order_place_id → 우리 쇼핑몰 코드)으로 네이버·쿠팡·11번가 등 열에 넣는다 (`SaleEvent.marketplace_code`). 연결표에 없는 마켓은 카페24 열 — **전체 합계는 항상 카페24 일별 매출내역과 같다** (9/28 대조로 자체몰+마켓 합계가 모든 줄에서 일치 확인). 환불은 원 주문을 100건씩 조회해 같은 열로. 네이버페이는 자체몰. From ef12a346005595355389d453db4f9829f89da250 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:04:51 +0900 Subject: [PATCH 08/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=E2=80=94=20?= =?UTF-8?q?=EC=B1=84=EB=84=90=EB=B3=84=20PC/=EB=AA=A8=EB=B0=94=EC=9D=BC=20?= =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EB=B6=84=EB=A6=AC=20+=20=EA=B2=B0?= =?UTF-8?q?=EC=A0=9C=EC=88=98=EB=8B=A8=EB=B3=84=20=ED=91=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 주문 채널별 표에 PC 주문 / 모바일 주문(주문의 order_from_mobile 기준 — PC 채널이어도 휴대폰 주문은 모바일) 건수·결제합계, 카페24 열(자체몰) 합계 줄 - 결제수단별 표(카페24 열 주문의 payment_method_name 조합별 주문수·결제합계·비중) - 대조 카드를 설정 화면 가로 전체 폭으로(넓은 표가 잘리지 않게), 자체몰 채널 이름 정리(PC) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 18 +++++++++-- .../templates/performance/index.html | 4 +-- .../templates/performance/settings.html | 6 ++-- .../performance/tests/test_performance.py | 16 ++++++++-- app/static/performance.css | 1 + app/static/performance.js | 32 +++++++++++++++++-- 6 files changed, 65 insertions(+), 12 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index e6c2f71..82a5ded 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -54,7 +54,7 @@ EVENT_PREFIX = "c24:" # (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃). # 이 주문들은 카페24 자체몰 매출이다. 비교는 소문자로. SELF_CHANNELS: dict[str, str] = { - "": "자체몰", "self": "자체몰(PC)", "cafe24": "자체몰", "mobile": "모바일웹", "mobile_d": "모바일앱", + "": "기본", "self": "PC", "cafe24": "PC", "mobile": "모바일웹", "mobile_d": "모바일앱", "ncheckout": "네이버페이", "kakaopay": "톡체크아웃", } @@ -339,18 +339,31 @@ class Cafe24Adapter(MarketplaceAdapter): "market_id": key or "(없음)", "label": SELF_CHANNELS.get(_key(mid), ""), "names": set(), "kind": kind, "target": target_code(mid, place), "orders": 0, "total": 0, "refund_count": 0, "refund_amount": 0, + # 기기 — 주문의 order_from_mobile(T=모바일에서 주문). PC 채널(self)에도 모바일 주문이 섞여 있다. + "pc_orders": 0, "pc_total": 0, "mobile_orders": 0, "mobile_total": 0, }) groups = {"self": empty(), "market": empty()} by_channel: dict[str, dict[str, Any]] = {} + by_payment: dict[str, dict[str, Any]] = {} # 결제수단 조합별(카페24 열 주문만) unpaid = 0 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 continue ch = channel(o.get("market_id"), o.get("order_place_id")) + total = order_total(o) ch["orders"] += 1 - ch["total"] += order_total(o) + ch["total"] += total + dev = "mobile" if str(o.get("order_from_mobile") or "").upper() == "T" else "pc" + ch[f"{dev}_orders"] += 1 + ch[f"{dev}_total"] += total + if ch["target"] == "cafe24": + names = [str(n) for n in (o.get("payment_method_name") or o.get("payment_method") or []) if n] + pkey = " + ".join(names) or "(없음)" + pm = by_payment.setdefault(pkey, {"method": pkey, "orders": 0, "total": 0}) + pm["orders"] += 1 + pm["total"] += total for n in (o.get("order_place_name"), o.get("order_place_id")): if n: ch["names"].add(str(n)) @@ -378,5 +391,6 @@ class Cafe24Adapter(MarketplaceAdapter): key=lambda v: v["total"], reverse=True) return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, "by_channel": channels_out, + "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index aa7df32..e57b2ef 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro won(v) -%} {%- if v is none -%} @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index bec4221..bb2e1e9 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} @@ -116,7 +116,7 @@
-
+

카페24 매출 대조

카페24 관리자 → 통계 → 일별 매출내역과 같은 날짜를 비교합니다. 그날 결제 주문과 환불을 카페24 API 에서 바로 합산하며(저장하지 않음), 자체몰과 다른 마켓 연동 주문을 나눠 보여 줍니다.

@@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 4bc9d5d..ef70190 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -433,9 +433,11 @@ def test_cafe24_normalize_matches_daily_report(): ctx = AdapterContext(code="cafe24", credentials=None) fake = _FakeCafe24( - [[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C", paid="F"), - _c24_order("D", market="auction"), _c24_order("E", market="NCHECKOUT"), - _c24_order("F", market="KAKAOPAY"), _c24_order("G", market="mobile")]], + [[_c24_order("A", order_from_mobile="T", payment_method_name=["신용카드"]), _c24_order("B", market="shopn"), + _c24_order("C", paid="F"), _c24_order("D", market="auction", payment_method_name=["신용카드"]), + _c24_order("E", market="NCHECKOUT", payment_method_name=["네이버페이"]), + _c24_order("F", market="KAKAOPAY", payment_method_name=["카카오페이", "적립금"]), + _c24_order("G", market="mobile", order_from_mobile="T", payment_method_name=["무통장입금"])]], [[_c24_refund("C20260929-01", "A", 12_610), _c24_refund("R20260929-02", "X", 20_000), _c24_refund("C20260929-03", "M", 9_000), _c24_refund("C20260929-04", "A", 5_000, status="F")]], lookup={"M": "shopn"}, @@ -478,6 +480,14 @@ def test_cafe24_normalize_matches_daily_report(): assert ch["auction"]["kind"] == "unknown" and ch["auction"]["target"] == "cafe24" assert ch["NCHECKOUT"]["kind"] == "self" and ch["NCHECKOUT"]["label"] == "네이버페이" assert ch["KAKAOPAY"]["label"] == "톡체크아웃" and ch["mobile"]["label"] == "모바일웹" + # 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일 + assert ch["self"]["mobile_orders"] == 1 and ch["self"]["pc_orders"] == 0 and ch["self"]["mobile_total"] == 47_000 + assert ch["NCHECKOUT"]["pc_orders"] == 1 and ch["mobile"]["mobile_orders"] == 1 + # 결제수단별(카페24 열만 — 외부 마켓 B 제외) + pay = {p["method"]: p for p in rec["by_payment"]} + assert pay["신용카드"]["orders"] == 2 and pay["신용카드"]["total"] == 94_000 + assert pay["카카오페이 + 적립금"]["orders"] == 1 and "네이버페이" in pay and "무통장입금" in pay + assert sum(p["orders"] for p in rec["by_payment"]) == 5 # 60일 단위 분할 + 페이지 넘김(1000건이면 다음 페이지) page1 = [_c24_order(f"x-{i}") for i in range(1000)] fake2 = _FakeCafe24([page1, [_c24_order("y")]]) diff --git a/app/static/performance.css b/app/static/performance.css index 544e6e7..66e2ee4 100644 --- a/app/static/performance.css +++ b/app/static/performance.css @@ -92,6 +92,7 @@ a.perf-seg.is-active, a.perf-seg.is-active:link, a.perf-seg.is-active:visited { .perf-card-head { display: flex; align-items: center; justify-content: space-between; gap: 10px; margin-bottom: 8px; flex-wrap: wrap; } .perf-h { margin: 0; font-size: 14px; font-weight: 600; } .perf-grid2 { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 12px; } +.perf-grid2 > .perf-card-wide { grid-column: 1 / -1; } /* 표가 넓은 카드(매출 대조)는 한 줄 전체 */ .perf-foot { margin: 8px 0 0; line-height: 1.5; } /* 표 */ diff --git a/app/static/performance.js b/app/static/performance.js index b1dc828..607052a 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -482,6 +482,7 @@ const r = await api("GET", "/performance/api/marketplaces/cafe24/reconcile?date=" + encodeURIComponent(day)); if (!r.ok) { out.innerHTML = '

' + esc((r.label ? r.label + " — " : "") + r.message) + "

"; return; } const s = r.orders.self, m = r.orders.market, rs = r.refunds.self, rm = r.refunds.market; + const dev = function (n, amt) { return n ? fmt(n) + '건 ' + won(amt) + "" : won(0); }; const MARKET_NAMES = {}; root.querySelectorAll("tr[data-code]").forEach(function (tr) { MARKET_NAMES[tr.dataset.code] = tr.dataset.name; }); const disc = ["membership_discount_amount", "set_product_discount_amount", "app_discount_amount", @@ -522,7 +523,8 @@ ((r.by_channel || []).length ? '

주문 채널별

' + '' + - '' + + '' + + "" + r.by_channel.map(function (b) { const col = MARKET_NAMES[b.target] || b.target; const kind = b.kind === "self" ? "자체몰 채널" + (b.label ? "(" + b.label + ")" : "") @@ -530,8 +532,34 @@ return '"; - }).join("") + "
market_id주문경로구분반영 열주문수결제합계환불순매출
구분반영 열주문수결제합계PC 주문모바일 주문환불순매출
' + esc(b.market_id) + "" + esc((b.names || []).join(", ")) + "" + (b.kind === "unknown" ? kind : esc(kind)) + "" + esc(col) + '' + fmt(b.orders) + '' + won(b.total) + + '' + dev(b.pc_orders, b.pc_total) + '' + dev(b.mobile_orders, b.mobile_total) + '' + won(-b.refund_amount) + '' + won(b.total - b.refund_amount) + "
" + }).join("") + "" + + // 카페24 열(자체몰) 기기 합계 + (function () { + const own = r.by_channel.filter(function (b) { return b.target === "cafe24"; }); + const t = own.reduce(function (a, b) { + a.o += b.orders; a.t += b.total; a.po += b.pc_orders; a.pt += b.pc_total; a.mo += b.mobile_orders; a.mt += b.mobile_total; + a.ra += b.refund_amount; return a; + }, { o: 0, t: 0, po: 0, pt: 0, mo: 0, mt: 0, ra: 0 }); + return '카페24 열(자체몰) 합계' + + fmt(t.o) + '' + won(t.t) + '' + dev(t.po, t.pt) + + '' + dev(t.mo, t.mt) + '' + won(-t.ra) + + '' + won(t.t - t.ra) + ""; + })() + "" + + '

PC/모바일은 주문의 모바일 주문 여부(order_from_mobile) 기준입니다 — 채널이 PC(self)여도 휴대폰에서 주문하면 모바일로 셉니다.

' + : "") + + ((r.by_payment || []).length + ? '

결제수단별 (카페24 열)

' + + '' + + (function () { + const tot = r.by_payment.reduce(function (a, p) { return a + p.total; }, 0); + return r.by_payment.map(function (p) { + return '"; + }).join(""); + })() + "
결제수단주문수결제합계비중
' + esc(p.method) + '' + fmt(p.orders) + + '' + won(p.total) + '' + + (tot > 0 ? (p.total / tot * 100).toFixed(1) + "%" : "–") + "
" : "") + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + "건 제외. \"알 수 없는 채널\"은 카페24 열에 넣습니다 — 외부 마켓이면 어느 쇼핑몰인지 알려 주세요.

"; From fb7c29833e027cad6c4d8f92f3868514c7f973f3 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:11:27 +0900 Subject: [PATCH 09/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=EC=B1=84=EB=84=90?= =?UTF-8?q?=20=ED=91=9C=EB=A5=BC=20market=5Fid=20=C3=97=20=EC=A3=BC?= =?UTF-8?q?=EB=AC=B8=EA=B2=BD=EB=A1=9C=EB=A1=9C=20=E2=80=94=20self=20?= =?UTF-8?q?=EB=A5=BC=20"PC"=EB=A1=9C=20=EC=9E=98=EB=AA=BB=20=ED=91=9C?= =?UTF-8?q?=EC=8B=9C=ED=95=98=EB=8D=98=20=EB=AC=B8=EC=A0=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 실데이터 확인: market_id "self" 는 PC 전용이 아니라 자체몰 전체이고, 그 안에 주문경로 "PC쇼핑몰"·"모바일웹"이 섞여 있다. 구분을 "자체몰"로 고치고, (market_id, 주문경로) 한 쌍을 한 줄로 나눠 표시. 환불도 원 주문의 주문경로로 같은 줄에 붙인다. Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 29 +++++++++++-------- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 6 ++++ app/static/performance.js | 6 ++-- 5 files changed, 29 insertions(+), 16 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 82a5ded..0def30a 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -54,7 +54,8 @@ EVENT_PREFIX = "c24:" # (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃). # 이 주문들은 카페24 자체몰 매출이다. 비교는 소문자로. SELF_CHANNELS: dict[str, str] = { - "": "기본", "self": "PC", "cafe24": "PC", "mobile": "모바일웹", "mobile_d": "모바일앱", + # self 는 PC 전용이 아니다 — 주문경로(order_place_name)가 "PC쇼핑몰"·"모바일웹"으로 나뉘어 섞여 있다(실데이터 확인). + "": "자체몰", "self": "자체몰", "cafe24": "자체몰", "mobile": "모바일웹", "mobile_d": "모바일앱", "ncheckout": "네이버페이", "kakaopay": "톡체크아웃", } @@ -248,8 +249,9 @@ class Cafe24Adapter(MarketplaceAdapter): {"start_date": s.isoformat(), "end_date": e.isoformat(), "date_type": "refund_date"}, REFUND_LIMIT) - def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any]]: - """환불의 원 주문 (market_id, order_place_id) — 주문일 60일 구간·100건씩 묶어 조회. 못 찾으면 자체몰.""" + def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any, Any]]: + """환불의 원 주문 (market_id, order_place_id, order_place_name) — 주문일 60일 구간·100건씩 묶어 조회. + 못 찾으면 자체몰.""" pairs = sorted({(_day(r.get("order_date")) or date.min, str(r.get("order_id") or "")) for r in refunds if r.get("order_id")}) out: dict[str, Any] = {} @@ -262,7 +264,7 @@ class Cafe24Adapter(MarketplaceAdapter): params = {"order_id": ",".join(ids), "start_date": first.isoformat(), "end_date": group[-1][0].isoformat(), "date_type": "order_date", "limit": LOOKUP_BATCH} for o in self._get(ctx, "/admin/orders", params).get("orders") or []: - out[str(o.get("order_id"))] = (o.get("market_id"), o.get("order_place_id")) + out[str(o.get("order_id"))] = (o.get("market_id"), o.get("order_place_id"), o.get("order_place_name")) i += len(group) return out @@ -274,7 +276,7 @@ class Cafe24Adapter(MarketplaceAdapter): rows = [r for r in self.refunds(ctx, start, end) if str(r.get("status") or "T") == "T"] markets = self.market_ids(ctx, rows) for r in rows: - mid, place = markets.get(str(r.get("order_id")), ("self", None)) + mid, place, _name = markets.get(str(r.get("order_id")), ("self", None, None)) yield {**r, "_market_id": mid, "_order_place_id": place} def normalize_order(self, order: dict[str, Any]) -> list[SaleEvent]: @@ -332,11 +334,14 @@ class Cafe24Adapter(MarketplaceAdapter): def empty() -> dict[str, int]: return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, "total": 0} - def channel(mid: Any, place: Any) -> dict[str, Any]: - key = "" if mid is None else str(mid) + def channel(mid: Any, place: Any, place_name: Any = None) -> dict[str, Any]: + """(market_id, 주문경로) 한 쌍 = 한 줄. self 안에도 PC쇼핑몰·모바일웹 경로가 섞여 있어 나눠 본다.""" + mkey = "" if mid is None else str(mid) + pname = str(place_name or place or "") kind = channel_kind(mid, place) - return by_channel.setdefault(key, { - "market_id": key or "(없음)", "label": SELF_CHANNELS.get(_key(mid), ""), "names": set(), + return by_channel.setdefault((mkey, pname), { + "market_id": mkey or "(없음)", "place": pname, "place_id": str(place or ""), + "label": SELF_CHANNELS.get(_key(mid), ""), "names": set(), "kind": kind, "target": target_code(mid, place), "orders": 0, "total": 0, "refund_count": 0, "refund_amount": 0, # 기기 — 주문의 order_from_mobile(T=모바일에서 주문). PC 채널(self)에도 모바일 주문이 섞여 있다. @@ -351,7 +356,7 @@ class Cafe24Adapter(MarketplaceAdapter): if o.get("paid") != "T": unpaid += 1 continue - ch = channel(o.get("market_id"), o.get("order_place_id")) + ch = channel(o.get("market_id"), o.get("order_place_id"), o.get("order_place_name")) total = order_total(o) ch["orders"] += 1 ch["total"] += total @@ -379,8 +384,8 @@ class Cafe24Adapter(MarketplaceAdapter): refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} for r in rows: - mid, place = markets.get(str(r.get("order_id")), ("self", None)) - ch = channel(mid, place) + mid, place, place_name = markets.get(str(r.get("order_id")), ("self", None, None)) + ch = channel(mid, place, place_name) g = refunds["self" if ch["target"] == "cafe24" else "market"] g["count"] += 1 for k in ("actual_refund_amount", "used_points", "used_credits"): diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index e57b2ef..b2300db 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -235,4 +235,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index bb2e1e9..6ec6b29 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index ef70190..19a239f 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -483,6 +483,12 @@ def test_cafe24_normalize_matches_daily_report(): # 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일 assert ch["self"]["mobile_orders"] == 1 and ch["self"]["pc_orders"] == 0 and ch["self"]["mobile_total"] == 47_000 assert ch["NCHECKOUT"]["pc_orders"] == 1 and ch["mobile"]["mobile_orders"] == 1 + # self 는 PC 전용이 아니다 — 주문경로(PC쇼핑몰/모바일웹)별로 한 줄씩(실데이터 확인) + fake3 = _FakeCafe24([[_c24_order("P1", order_place_name="PC쇼핑몰"), _c24_order("P2", order_place_name="PC쇼핑몰"), + _c24_order("M1", order_place_name="모바일웹", order_from_mobile="T")]]) + rows3 = {(b["market_id"], b["place"]): b for b in fake3.reconcile(ctx, date(2026, 9, 29))["by_channel"]} + assert rows3[("self", "PC쇼핑몰")]["orders"] == 2 and rows3[("self", "모바일웹")]["mobile_orders"] == 1 + assert rows3[("self", "PC쇼핑몰")]["label"] == "자체몰" # 결제수단별(카페24 열만 — 외부 마켓 B 제외) pay = {p["method"]: p for p in rec["by_payment"]} assert pay["신용카드"]["orders"] == 2 and pay["신용카드"]["total"] == 94_000 diff --git a/app/static/performance.js b/app/static/performance.js index 607052a..e9c8f08 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -529,7 +529,8 @@ const col = MARKET_NAMES[b.target] || b.target; const kind = b.kind === "self" ? "자체몰 채널" + (b.label ? "(" + b.label + ")" : "") : b.kind === "market" ? "외부 마켓" : '알 수 없는 채널'; - return '' + esc(b.market_id) + "" + esc((b.names || []).join(", ")) + + return '' + esc(b.market_id) + "" + esc(b.place || "–") + + (b.place_id && b.place_id !== b.place ? ' ' + esc(b.place_id) + "" : "") + "" + (b.kind === "unknown" ? kind : esc(kind)) + "" + esc(col) + '' + fmt(b.orders) + '' + won(b.total) + '' + dev(b.pc_orders, b.pc_total) + '' + dev(b.mobile_orders, b.mobile_total) + @@ -547,7 +548,8 @@ '' + dev(t.mo, t.mt) + '' + won(-t.ra) + '' + won(t.t - t.ra) + ""; })() + "" + - '

PC/모바일은 주문의 모바일 주문 여부(order_from_mobile) 기준입니다 — 채널이 PC(self)여도 휴대폰에서 주문하면 모바일로 셉니다.

' + '

한 줄 = market_id × 주문경로. market_id "self"는 PC 전용이 아니라 자체몰 전체이며, 그 안에 PC쇼핑몰·모바일웹 경로가 섞여 있습니다. ' + + 'PC/모바일 주문은 카페24가 주문마다 주는 모바일 주문 여부(order_from_mobile) 기준입니다.

' : "") + ((r.by_payment || []).length ? '

결제수단별 (카페24 열)

' + From a19c1f4cab6491b7374dad1a8cf38550df437755 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:21:08 +0900 Subject: [PATCH 10/30] =?UTF-8?q?feat(performance):=20=EB=A7=A4=EC=B6=9C?= =?UTF-8?q?=20=EC=97=85=EB=8D=B0=EC=9D=B4=ED=8A=B8=EB=8A=94=20=EB=B3=B4?= =?UTF-8?q?=EA=B3=A0=20=EC=9E=88=EB=8A=94=20=EA=B8=B0=EA=B0=84=EC=9D=84=20?= =?UTF-8?q?=EA=B0=80=EC=A0=B8=EC=98=A4=EA=B8=B0=20+=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=ED=99=98=EB=B6=88=20=EA=B8=B0=EC=A4=80=20=EB=B9=84=EA=B5=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 대시보드 [매출 업데이트]가 최근 7일 고정이 아니라 지금 보고 있는 기간(오늘까지)을 가져온다 ("이번달"이면 1일~오늘). 모듈 권한자 92일까지, 더 긴 기간(최대 366일)은 관리자만. 미래 기간은 400 - 카페24 매출 대조에 "환불 기준 비교": 환불완료일(완료) vs 환불접수일(전체 상태·상태별), 실제 환불액만 / 적립금·예치금 포함 — 9/23~27 순매출이 카페24보다 크게 나오는 원인 확인용 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 32 +++++++++++++++++-- app/modules/performance/router.py | 14 +++++--- .../templates/performance/index.html | 10 ++++-- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 5 +++ app/static/performance.js | 23 ++++++++++++- docs/PERFORMANCE_MODULE.md | 7 ++-- 7 files changed, 79 insertions(+), 14 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 0def30a..6c90731 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -243,11 +243,13 @@ class Cafe24Adapter(MarketplaceAdapter): {"start_date": s.isoformat(), "end_date": e.isoformat(), "date_type": "pay_date", "embed": "items"}, ORDER_LIMIT) - def refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + def refunds(self, ctx: AdapterContext, start: date, end: date, + date_type: str = "refund_date") -> Iterable[dict[str, Any]]: + """환불 목록. date_type: refund_date(환불완료일, 기본) / accepted_refund_date(환불접수일).""" for s, e in _chunks(start, end): yield from self._paged(ctx, "/admin/refunds", "refunds", {"start_date": s.isoformat(), "end_date": e.isoformat(), - "date_type": "refund_date"}, REFUND_LIMIT) + "date_type": date_type}, REFUND_LIMIT) def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any, Any]]: """환불의 원 주문 (market_id, order_place_id, order_place_name) — 주문일 60일 구간·100건씩 묶어 조회. @@ -394,8 +396,32 @@ class Cafe24Adapter(MarketplaceAdapter): ch["refund_amount"] += _won(r.get("actual_refund_amount")) channels_out = sorted(({**v, "names": sorted(v["names"])} for v in by_channel.values()), key=lambda v: v["total"], reverse=True) + + # 환불 기준 비교 — 카페24 "환불합계"가 어느 기준인지 확정하는 용도. + # 완료일(refund_date, 완료 T) vs 접수일(accepted_refund_date, 상태 T/F/M 전부) + # 각각 실제 환불액만 / 적립금·예치금 환불 포함 + def rsum(items: Iterable[dict[str, Any]]) -> dict[str, int]: + out = {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0} + for x in items: + out["count"] += 1 + for k in ("actual_refund_amount", "used_points", "used_credits"): + out[k] += _won(x.get(k)) + out["with_points"] = out["actual_refund_amount"] + out["used_points"] + out["used_credits"] + return out + + accepted = list(self.refunds(ctx, day, day, "accepted_refund_date")) + status_names = {"T": "환불완료", "F": "환불전", "M": "환불보류"} + refund_basis = { + "completed": rsum(rows), + "accepted_all": rsum(accepted), + "accepted_by_status": [ + {"status": s, "label": status_names.get(s, s or "(없음)"), + **rsum(x for x in accepted if str(x.get("status") or "") == s)} + for s in sorted({str(x.get("status") or "") for x in accepted}) + ], + } return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, - "by_channel": channels_out, + "by_channel": channels_out, "refund_basis": refund_basis, "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py index bfdf077..83f5bb6 100644 --- a/app/modules/performance/router.py +++ b/app/modules/performance/router.py @@ -37,6 +37,7 @@ router = APIRouter(prefix="/performance", tags=["performance"]) MAX_EVENT_DAYS = 31 MAX_BACKFILL_DAYS = 366 +MAX_USER_SYNC_DAYS = 92 # 관리자가 아니어도 가져올 수 있는 기간(이번달·직접선택 짧은 기간) def _parse_date(value: Any, *, field: str = "날짜") -> date | None: @@ -128,7 +129,8 @@ def settings_page(request: Request): # ════════════════════════════════════════════════════════════ @router.post("/api/sync") def api_sync(request: Request, payload: dict[str, Any] = Body(default={})) -> JSONResponse: - """기본은 최근 N일(PERFORMANCE_SYNC_DAYS). from/to 로 기간을 지정한 수집(과거 매출 가져오기)은 관리자만.""" + """from/to 가 없으면 최근 N일(PERFORMANCE_SYNC_DAYS). 기간 지정은 대시보드 [매출 업데이트](보고 있는 기간)와 + 설정 [과거 매출 가져오기]가 쓴다 — 모듈 권한자는 92일까지, 그보다 길면(최대 366일) 관리자만.""" store, user = common.require_store(request) _, sync = common.services(request, store) codes = [str(c) for c in (payload.get("codes") or []) if get_adapter(str(c))] @@ -137,16 +139,20 @@ def api_sync(request: Request, payload: dict[str, Any] = Body(default={})) -> JS if start or end: from app.store import is_admin # noqa: WPS433 - if not is_admin(user): - raise HTTPException(status_code=403, detail="기간을 지정한 수집은 관리자만 할 수 있습니다.") end = end or today_kst() start = start or end if end < start: start, end = end, start if end > today_kst(): end = today_kst() - if (end - start).days + 1 > MAX_BACKFILL_DAYS: + if start > end: + raise HTTPException(status_code=400, detail="앞으로의 기간은 가져올 수 없습니다.") + days = (end - start).days + 1 + if days > MAX_BACKFILL_DAYS: raise HTTPException(status_code=400, detail=f"한 번에 {MAX_BACKFILL_DAYS}일까지 가져올 수 있습니다.") + if days > MAX_USER_SYNC_DAYS and not is_admin(user): + raise HTTPException(status_code=403, + detail=f"{MAX_USER_SYNC_DAYS}일보다 긴 기간은 관리자만 가져올 수 있습니다.") results = sync.sync_all(start=start, end=end, codes=codes or None, user=user["email"]) return JSONResponse({"results": results, "last_update_at": store.last_update_at()}) diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index b2300db..3aec4ae 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -64,7 +64,8 @@
마지막 업데이트 {{ (last_update_at or '')[:16] | replace('T', ' ') or '—' }} -
@@ -231,8 +232,11 @@ "codes": codes, "daily": chart_daily, "share": chart_share, - "period_kind": period_kind + "period_kind": period_kind, + "period_start": period.start.isoformat(), + "period_end": period.end.isoformat(), + "today": today } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 6ec6b29..40789dd 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 19a239f..7e96d23 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -480,6 +480,11 @@ def test_cafe24_normalize_matches_daily_report(): assert ch["auction"]["kind"] == "unknown" and ch["auction"]["target"] == "cafe24" assert ch["NCHECKOUT"]["kind"] == "self" and ch["NCHECKOUT"]["label"] == "네이버페이" assert ch["KAKAOPAY"]["label"] == "톡체크아웃" and ch["mobile"]["label"] == "모바일웹" + # 환불 기준 비교: 완료일(완료만) vs 접수일(전체 상태) — 가짜 API 는 두 기준에 같은 목록을 돌려준다 + rb = rec["refund_basis"] + assert rb["completed"]["count"] == 3 and rb["completed"]["actual_refund_amount"] == 12_610 + 20_000 + 9_000 + assert rb["accepted_all"]["count"] == 4 and rb["accepted_all"]["with_points"] == 12_610 + 20_000 + 9_000 + 5_000 + assert {s["status"]: s["count"] for s in rb["accepted_by_status"]} == {"T": 3, "F": 1} # 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일 assert ch["self"]["mobile_orders"] == 1 and ch["self"]["pc_orders"] == 0 and ch["self"]["mobile_total"] == 47_000 assert ch["NCHECKOUT"]["pc_orders"] == 1 and ch["mobile"]["mobile_orders"] == 1 diff --git a/app/static/performance.js b/app/static/performance.js index e9c8f08..3db180a 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -126,7 +126,10 @@ const label = syncBtn.textContent; syncBtn.textContent = "업데이트 중…"; try { - const res = await api("POST", "/performance/api/sync", {}); + // 지금 보고 있는 기간(오늘까지)을 가져온다 — "이번달"이면 1일부터 오늘까지. + const from = data.period_start, to = data.period_end < data.today ? data.period_end : data.today; + if (from > data.today) throw new Error("앞으로의 기간은 가져올 수 없습니다."); + const res = await api("POST", "/performance/api/sync", { from: from, to: to }); // 실패(빨강)는 인증 실패·API 오류처럼 손봐야 하는 것만. 인증정보를 아직 안 넣은 쇼핑몰(미설정)과 // 수집을 아직 만들지 않은 쇼핑몰(연동 준비 중)은 회색 한 줄로 이름만. const ok = [], bad = [], pending = [], unset = [], busy = []; @@ -520,6 +523,24 @@ return "' + esc(x[0]) + '' + f(x[1]) + '' + f(x[2]) + ""; }).join("") + "" + + (r.refund_basis + ? (function () { + const b = r.refund_basis; + const row = function (label, x, cls) { + return "' + label + '' + + fmt(x.count) + '' + won(x.actual_refund_amount) + '' + + won(x.used_points + x.used_credits) + '' + won(x.with_points) + ""; + }; + return '

환불 기준 비교 — 카페24 화면의 그날 "환불합계"와 같은 칸을 찾아 주세요

' + + '' + + "" + + row("환불완료일 기준 · 완료 현재 적용", b.completed, "perf-row-week") + + row("환불접수일 기준 · 전체 상태", b.accepted_all) + + (b.accepted_by_status || []).map(function (s) { + return row(" · 접수일 기준 " + esc(s.label), s); + }).join("") + "
기준건수실제 환불액적립금·예치금 환불합계(포함)
"; + })() + : "") + ((r.by_channel || []).length ? '

주문 채널별

' + '' + diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 3f5751b..472ef22 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -126,8 +126,11 @@ - `SyncService.sync_all()` / `sync_marketplace()` — 버튼·향후 cron/worker 공용. 기본 기간: 오늘 포함 최근 `PERFORMANCE_SYNC_DAYS`(기본 7)일. -- **과거 매출 가져오기**(설정 화면, 관리자): `POST /api/sync {from, to}` — 기간 지정 수집(최대 366일, 미래는 오늘까지). - 처음 연동했거나 빠진 기간을 채울 때. 같은 사건은 덮어써서 여러 번 해도 중복 없음. 일반 사용자가 기간을 주면 403. +- **대시보드 [매출 업데이트]** = 지금 보고 있는 기간(오늘까지)을 `POST /api/sync {from, to}` 로 다시 가져온다 + ("이번달"이면 1일~오늘). 모듈 권한자는 92일까지, 더 긴 기간(올해 등, 최대 366일)은 관리자만. +- **과거 매출 가져오기**(설정 화면, 관리자): 같은 API 로 임의 기간(최대 366일). 같은 사건은 덮어써서 여러 번 해도 중복 없음. +- 카페24 **환불 기준**은 현재 환불완료일(refund_date)·실제 환불액. 대조 도구의 "환불 기준 비교"(완료일 vs 접수일, 적립금·예치금 + 포함 여부)로 카페24 "환불합계"와 같은 기준을 확인한 뒤 확정한다(9/23~27 순매출이 카페24보다 크게 나온 원인 조사 중). - 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리). - 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고 상단에 오류 쇼핑몰만 표시. From 370834b58b2b86b13be3279095ac5cdf0d3e846c Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:44:21 +0900 Subject: [PATCH 11/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=E2=80=94=20?= =?UTF-8?q?=ED=99=98=EB=B6=88=ED=95=A9=EA=B3=84=20=ED=9B=84=EB=B3=B4=C2=B7?= =?UTF-8?q?=ED=99=98=EB=B6=88=20=EA=B1=B4=EB=B3=84=C2=B7=EC=B7=A8=EC=86=8C?= =?UTF-8?q?/=EB=B0=98=ED=92=88=20=EC=99=84=EB=A3=8C=20=ED=92=88=EB=AA=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/26 은 결제합계가 카페24와 같고 환불만 97,580 모자라며 완료일·접수일·적립금 어느 기준으로도 맞지 않아, 환불 API 에 빠진 건을 찾는 진단을 추가. - 환불합계 후보 표: 카페24 화면 값을 입력하면 같은 줄 강조 - 환불 건별 목록(완료일·접수일 기준 합침, 계좌 등 개인정보 제외) - 그날 취소/반품/교환 완료 품목(orders date_type=*_complete_date, embed=items) 품목 판매가·결제금액·쿠폰·환불 기록 유무 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 107 ++++++++++++++++++ .../templates/performance/index.html | 4 +- .../templates/performance/settings.html | 4 +- .../performance/tests/test_performance.py | 32 +++++- app/static/performance.css | 2 + app/static/performance.js | 52 +++++++++ docs/PERFORMANCE_MODULE.md | 4 + 7 files changed, 199 insertions(+), 6 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 6c90731..5abd9a5 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -50,6 +50,12 @@ MAX_OFFSET = 15000 CHUNK_DAYS = 60 EVENT_PREFIX = "c24:" +# 매출 대조 전용 — 클레임 완료 주문 조회 날짜 유형과 "완료" 상태(입금전취소 C47~49 는 결제 전이라 제외) +CLAIM_DATE_TYPES = (("cancel_complete_date", "취소완료"), ("return_complete_date", "반품완료"), + ("exchange_complete_date", "교환완료")) +CLAIM_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43", "E40"}) +UNPAID_CANCEL = frozenset({"C47", "C48", "C49"}) + # 카페24 자체몰 주문 채널 — market_id 는 외부 마켓만이 아니라 주문 채널·간편결제도 담는다 # (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃). # 이 주문들은 카페24 자체몰 매출이다. 비교는 소문자로. @@ -251,6 +257,55 @@ class Cafe24Adapter(MarketplaceAdapter): {"start_date": s.isoformat(), "end_date": e.isoformat(), "date_type": date_type}, REFUND_LIMIT) + def claim_items(self, ctx: AdapterContext, day: date) -> dict[str, Any]: + """그날 취소완료·반품완료·교환완료된 주문의 클레임 품목(대조 전용). 환불 API 에 안 잡히는 건 + (네이버페이 취소 등)을 찾기 위한 것. 조회 실패는 errors 에 담고 계속한다. 개인정보 제외.""" + items: list[dict[str, Any]] = [] + errors: list[str] = [] + seen: set[str] = set() + full_cancel_shipping = 0 + for date_type, label in CLAIM_DATE_TYPES: + try: + orders = list(self._paged(ctx, "/admin/orders", "orders", + {"start_date": day.isoformat(), "end_date": day.isoformat(), + "date_type": date_type, "embed": "items"}, ORDER_LIMIT)) + except ApiError as exc: + errors.append(f"{label}: {exc}") + continue + for o in orders: + oid = str(o.get("order_id") or "") + its = o.get("items") or [] + claimed = [i for i in its if str(i.get("order_status") or "")[:1] in ("C", "R", "E") + and str(i.get("order_status") or "") not in UNPAID_CANCEL] + if claimed and len(claimed) == len(its) and oid not in seen and \ + all(str(i.get("order_status") or "") in CLAIM_DONE and str(i.get("order_status"))[:1] == "C" for i in its): + full_cancel_shipping += order_amounts(o)["shipping_fee"] + for i in claimed: + key = str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}") + if key in seen: + continue + seen.add(key) + status = str(i.get("order_status") or "") + qty = int(i.get("quantity") or 0) + items.append({ + "via": label, "order_id": oid, "item_code": key, + "channel": str(o.get("order_place_name") or o.get("market_id") or ""), + "paid": o.get("paid") == "T", "pay_date": str(o.get("payment_date") or "")[:10], + "status": status, "status_text": str(i.get("status_text") or ""), + "done": status in CLAIM_DONE, + "claim_code": str(i.get("claim_code") or ""), + "product_name": str(i.get("product_name") or "")[:40], "quantity": qty, + "product_amount": (_won(i.get("product_price")) + _won(i.get("option_price"))) * qty, + "payment_amount": _won(i.get("payment_amount")), + "coupon": _won(i.get("coupon_discount_price")), + "naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""), + "cancel_date": str(i.get("cancel_date") or "")[:16], + "refund_date": str(i.get("refund_date") or "")[:16], + "return_confirmed_date": str(i.get("return_confirmed_date") or "")[:16], + }) + seen.add(oid) + return {"items": items, "errors": errors, "full_cancel_shipping": full_cancel_shipping} + def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any, Any]]: """환불의 원 주문 (market_id, order_place_id, order_place_name) — 주문일 60일 구간·100건씩 묶어 조회. 못 찾으면 자체몰.""" @@ -420,8 +475,60 @@ class Cafe24Adapter(MarketplaceAdapter): for s in sorted({str(x.get("status") or "") for x in accepted}) ], } + + # 환불 건별 목록(완료일 기준 + 접수일 기준, 환불코드로 합침) — 개인정보(이메일·계좌) 제외 + extra = markets | self.market_ids(ctx, [a for a in accepted if str(a.get("order_id")) not in markets]) + refund_list: dict[str, dict[str, Any]] = {} + for basis, items in (("completed", rows), ("accepted", accepted)): + for x in items: + code = str(x.get("refund_code") or "") + mid, place, place_name = extra.get(str(x.get("order_id")), ("self", None, None)) + e = refund_list.setdefault(code, { + "refund_code": code, "order_id": str(x.get("order_id") or ""), + "channel": str(place_name or mid or ""), "status": str(x.get("status") or ""), + "accepted_date": str(x.get("accepted_refund_date") or "")[:16].replace("T", " "), + "refund_date": str(x.get("refund_date") or "")[:16].replace("T", " "), + "quantity": int(x.get("quantity") or 0), + "actual_refund_amount": _won(x.get("actual_refund_amount")), + "used_points": _won(x.get("used_points")), "used_credits": _won(x.get("used_credits")), + "cancel_fee_amount": _won(x.get("cancel_fee_amount")), + "methods": [str(m) for m in (x.get("refund_methods") or []) if m], + "in_completed": False, "in_accepted": False, + }) + e["in_" + basis] = True + + claims = self.claim_items(ctx, day) + refunded_orders = {r["order_id"] for r in refund_list.values()} + for c in claims["items"]: + c["has_refund"] = c["order_id"] in refunded_orders + + def csum(pred) -> dict[str, int]: + sel = [c for c in claims["items"] if c["done"] and pred(c)] + return {"count": len(sel), "payment_amount": sum(c["payment_amount"] for c in sel), + "product_amount": sum(c["product_amount"] for c in sel)} + + comp = refund_basis["completed"] + no_refund = csum(lambda c: not c["has_refund"]) + claimed = csum(lambda c: True) + # 카페24 "환불합계" 후보 — 화면 값과 같은 줄을 찾는다(화면에서 값을 입력하면 강조) + candidates = [ + {"key": "completed", "label": "환불완료일 · 실제 환불액 (현재 적용)", "amount": comp["actual_refund_amount"]}, + {"key": "completed_pts", "label": "환불완료일 · 실제 환불액 + 적립금·예치금", "amount": comp["with_points"]}, + {"key": "accepted", "label": "환불접수일(전체 상태) · 실제 환불액", "amount": refund_basis["accepted_all"]["actual_refund_amount"]}, + {"key": "accepted_pts", "label": "환불접수일(전체 상태) · 실제 + 적립금·예치금", "amount": refund_basis["accepted_all"]["with_points"]}, + {"key": "claim_pay", "label": "취소·반품·교환 완료 품목 · 품목 결제금액", "amount": claimed["payment_amount"]}, + {"key": "claim_prod", "label": "취소·반품·교환 완료 품목 · 판매가(+옵션)×수량", "amount": claimed["product_amount"]}, + {"key": "claim_pay_ship", "label": "완료 품목 결제금액 + 전체취소 주문 배송비", + "amount": claimed["payment_amount"] + claims["full_cancel_shipping"]}, + {"key": "completed_plus_noref", "label": "환불완료 실제 환불액 + 환불 기록 없는 완료 품목 결제금액", + "amount": comp["actual_refund_amount"] + no_refund["payment_amount"]}, + {"key": "completed_pts_plus_noref", "label": "환불완료 (실제+적립금) + 환불 기록 없는 완료 품목 결제금액", + "amount": comp["with_points"] + no_refund["payment_amount"]}, + ] return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid, "by_channel": channels_out, "refund_basis": refund_basis, + "refund_list": sorted(refund_list.values(), key=lambda r: r["refund_code"]), + "claims": claims, "refund_candidates": candidates, "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 3aec4ae..32d9c25 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro won(v) -%} {%- if v is none -%} @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 40789dd..d8883f5 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 7e96d23..31e48b1 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -407,8 +407,9 @@ def _c24_refund(code, oid, amount, status="T", order_date="2026-09-20T09:00:00+0 class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist=["Cafe24Adapter"]).Cafe24Adapter): - def __init__(self, orders_pages, refunds_pages=(), lookup=None): + def __init__(self, orders_pages, refunds_pages=(), lookup=None, claims=None): self.orders_pages = orders_pages # 결제일 조회 페이지들 + self.claims = claims or {} # date_type(취소/반품/교환 완료일) → 주문 목록 self.refunds_pages = list(refunds_pages) self.lookup = lookup or {} # order_id → market_id (환불 원 주문 조회) self.calls = [] @@ -424,6 +425,8 @@ class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist if params.get("date_type") == "order_date": # 원 주문 market_id 조회 ids = params["order_id"].split(",") return {"orders": [{"order_id": i, "market_id": self.lookup.get(i, "self")} for i in ids]} + if params.get("date_type", "").endswith("_complete_date"): + return {"orders": self.claims.get(params["date_type"], []) if idx == 0 else []} return {"orders": self.orders_pages[idx] if idx < len(self.orders_pages) else []} @@ -485,7 +488,32 @@ def test_cafe24_normalize_matches_daily_report(): assert rb["completed"]["count"] == 3 and rb["completed"]["actual_refund_amount"] == 12_610 + 20_000 + 9_000 assert rb["accepted_all"]["count"] == 4 and rb["accepted_all"]["with_points"] == 12_610 + 20_000 + 9_000 + 5_000 assert {s["status"]: s["count"] for s in rb["accepted_by_status"]} == {"T": 3, "F": 1} - # 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일 + assert {c["key"] for c in rec["refund_candidates"]} >= {"completed", "completed_pts", "claim_pay"} + assert {r["refund_code"] for r in rec["refund_list"]} == {"C20260929-01", "R20260929-02", "C20260929-03", "C20260929-04"} + assert "1234567890" not in str(rec["refund_list"]) # 환불 계좌 미노출 + # 클레임 완료 품목: 환불 API 에 없는 취소(네이버페이 등)를 찾는다. 입금전취소·미완료는 합계 제외 + item = lambda code, st, pay, price=10_000, qty=1: {"order_item_code": code, "order_status": st, "quantity": qty, + "product_price": f"{price}.00", "option_price": "0.00", + "payment_amount": f"{pay}.00", "product_name": "상품"} + fake4 = _FakeCafe24([[]], [[_c24_refund("C1", "A", 9_000)]], claims={ + "cancel_complete_date": [ + {**_c24_order("A"), "items": [item("A-01", "C40", 9_000)]}, + {**_c24_order("N"), "market_id": "NCHECKOUT", "items": [item("N-01", "C40", 19_800, 20_000), item("N-02", "C40", 5_000, 5_000)]}, + {**_c24_order("U"), "items": [item("U-01", "C48", 7_000)]}, + {**_c24_order("P"), "items": [item("P-01", "C34", 3_000), item("P-02", "N40", 4_000)]}], + "return_complete_date": [{**_c24_order("N"), "items": [item("N-01", "C40", 19_800, 20_000)]}, + {**_c24_order("R"), "items": [item("R-01", "R40", 12_000, 6_000, 2)]}], + }) + rec4 = fake4.reconcile(ctx, date(2026, 9, 29)) + cl = {c["item_code"]: c for c in rec4["claims"]["items"]} + assert set(cl) == {"A-01", "N-01", "N-02", "P-01", "R-01"} # 입금전취소(U)·정상 품목 제외, 중복 제거 + assert cl["A-01"]["has_refund"] and not cl["N-01"]["has_refund"] and not cl["P-01"]["done"] + assert cl["R-01"]["product_amount"] == 12_000 + assert rec4["claims"]["full_cancel_shipping"] == 3_000 * 2 # A, N 전체취소(배송비 3,000씩) + cand = {c["key"]: c["amount"] for c in rec4["refund_candidates"]} + assert cand["claim_pay"] == 9_000 + 19_800 + 5_000 + 12_000 + assert cand["completed_plus_noref"] == 9_000 + 19_800 + 5_000 + 12_000 + # 기기: PC 채널(self)이어도 휴대폰 주문(order_from_mobile=T)은 모바일 assert ch["self"]["mobile_orders"] == 1 and ch["self"]["pc_orders"] == 0 and ch["self"]["mobile_total"] == 47_000 assert ch["NCHECKOUT"]["pc_orders"] == 1 and ch["mobile"]["mobile_orders"] == 1 # self 는 PC 전용이 아니다 — 주문경로(PC쇼핑몰/모바일웹)별로 한 줄씩(실데이터 확인) diff --git a/app/static/performance.css b/app/static/performance.css index 66e2ee4..d30ba31 100644 --- a/app/static/performance.css +++ b/app/static/performance.css @@ -208,3 +208,5 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; } .perf-kpis { grid-template-columns: repeat(2, minmax(0, 1fr)); } .perf-update { margin-left: 0; } } + +.perf-table tr.perf-row-match > *{background:#e7f6ec;font-weight:600} diff --git a/app/static/performance.js b/app/static/performance.js index 3db180a..76803df 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -541,6 +541,47 @@ }).join("") + "
market_id주문경로
"; })() : "") + + ((r.refund_candidates || []).length + ? '

환불합계 후보 — 카페24 화면 값을 넣으면 같은 줄을 표시합니다

' + + '
' + + '' + + r.refund_candidates.map(function (c) { + return ''; + }).join("") + "
후보금액차이
' + esc(c.label) + '' + + won(c.amount) + '–
" + : "") + + ((r.refund_list || []).length + ? '

환불 건별 (환불 API)

' + + '' + + '' + + "" + + r.refund_list.map(function (x) { + const st = { T: "환불완료", F: "환불전", M: "환불보류" }[x.status] || x.status; + return '"; + }).join("") + "
환불코드주문번호채널상태접수일완료일수량실제 환불액적립금·예치금환불수단
' + esc(x.refund_code) + "" + esc(x.order_id) + "" + esc(x.channel || "–") + + "" + esc(st) + "" + esc(x.accepted_date || "–") + "" + esc(x.refund_date || "–") + + '' + fmt(x.quantity) + '' + won(x.actual_refund_amount) + + '' + won(x.used_points + x.used_credits) + "" + esc((x.methods || []).join(", ") || "–") + "
" + : "") + + (r.claims + ? '

그날 취소·반품·교환 완료 품목 (주문 API)

' + + ((r.claims.errors || []).length ? '

' + esc(r.claims.errors.join(" / ")) + "

" : "") + + ((r.claims.items || []).length + ? '' + + '' + + "" + + r.claims.items.map(function (c) { + return ""; + }).join("") + "
조회주문번호채널상태클레임상품수량판매가×수량품목 결제금액쿠폰환불 기록
' + esc(c.via) + "" + esc(c.order_id) + + "" + esc(c.channel || "–") + "" + esc(c.status + (c.status_text ? " " + c.status_text : "")) + + "" + esc(c.claim_code || "–") + "" + esc(c.product_name) + '' + fmt(c.quantity) + + '' + won(c.product_amount) + '' + won(c.payment_amount) + + '' + won(c.coupon) + "" + (c.has_refund ? "있음" : '없음') + "
" + + '

전체취소 주문 배송비 ' + won(r.claims.full_cancel_shipping) + + '. 흐린 줄은 아직 완료되지 않은 클레임(후보 합계에서 제외).

' + : '

없음

') + : "") + ((r.by_channel || []).length ? '

주문 채널별

' + '' + @@ -586,6 +627,17 @@ : "") + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + "건 제외. \"알 수 없는 채널\"은 카페24 열에 넣습니다 — 외부 마켓이면 어느 쇼핑몰인지 알려 주세요.

"; + const target = document.getElementById("perf-recon-target"); + if (target) target.addEventListener("input", function () { + const v = parseInt(target.value.replace(/[^0-9-]/g, ""), 10); + out.querySelectorAll("#perf-recon-cands tr[data-amount]").forEach(function (tr) { + const a = parseInt(tr.dataset.amount, 10); + const d = tr.querySelector(".perf-cand-diff"); + if (isNaN(v)) { d.textContent = "–"; tr.classList.remove("perf-row-match"); return; } + d.textContent = a === v ? "일치" : fmt(a - v); + tr.classList.toggle("perf-row-match", a === v); + }); + }); } catch (err) { out.innerHTML = '

' + esc(err.message) + "

"; } finally { recon.disabled = false; } diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 472ef22..30f832a 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -131,6 +131,10 @@ - **과거 매출 가져오기**(설정 화면, 관리자): 같은 API 로 임의 기간(최대 366일). 같은 사건은 덮어써서 여러 번 해도 중복 없음. - 카페24 **환불 기준**은 현재 환불완료일(refund_date)·실제 환불액. 대조 도구의 "환불 기준 비교"(완료일 vs 접수일, 적립금·예치금 포함 여부)로 카페24 "환불합계"와 같은 기준을 확인한 뒤 확정한다(9/23~27 순매출이 카페24보다 크게 나온 원인 조사 중). + 9/26 은 결제합계가 카페24와 같고(3,568,265) 환불만 97,580 모자라며, 완료일·접수일·적립금 포함 어느 기준으로도 맞지 않았다 + → 환불 API 에 안 잡히는 환불이 있다고 보고, 대조 도구에 **환불합계 후보**(카페24 값 입력 시 일치 줄 강조)·**환불 건별**· + **그날 취소/반품/교환 완료 품목**(`GET /admin/orders` `date_type=cancel_complete_date|return_complete_date|exchange_complete_date`, + `embed=items`, 품목별 판매가·결제금액·환불 기록 유무, `claim_items()`)을 추가해 빠진 건을 찾는다. - 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리). - 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고 상단에 오류 쇼핑몰만 표시. From 1eca66838b85c703c3f4dd4ea149c7212c78a567 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:49:02 +0900 Subject: [PATCH 12/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=E2=80=94=20?= =?UTF-8?q?=EA=B2=B0=EC=A0=9C=EC=9D=BC=20=EA=B8=B0=EC=A4=80=20=ED=99=98?= =?UTF-8?q?=EB=B6=88=20=ED=9B=84=EB=B3=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/26 에 실제로 일어난 환불은 4건(178,220)뿐인데 카페24 환불합계는 275,800. 카페24 일별 매출이 환불을 원 주문 결제일에 빼는지 확인하기 위해 후보 추가: - 그날 결제한 주문이 오늘까지 환불된 금액(실제 / 적립금 포함, 환불일 표시) - 그날 결제한 주문의 결제 당시 금액 − 현재 금액(actual_order_amount) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 28 +++++++++++++++++++ .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 11 +++++++- app/static/performance.js | 2 ++ 5 files changed, 42 insertions(+), 3 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 5abd9a5..4c0bae8 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -141,6 +141,14 @@ def order_total(order: dict[str, Any]) -> int: - sum(a[k] for k in DISCOUNT_FIELDS) - sum(a[k] for k in COUPON_FIELDS)) +def order_total_now(order: dict[str, Any]) -> int: + """취소·반품 반영 후 현재 결제합계(actual_order_amount). 없으면 결제 당시 금액.""" + a = order.get("actual_order_amount") or order.get("initial_order_amount") or {} + w = {k: _won(a.get(k)) for k in AMOUNT_FIELDS} + return (w["order_price_amount"] + w["shipping_fee"] + - sum(w[k] for k in DISCOUNT_FIELDS) - sum(w[k] for k in COUPON_FIELDS)) + + def is_self_market(market_id: Any) -> bool: """카페24 자체몰 채널(PC·모바일·네이버페이·톡체크아웃 등)인가.""" return channel_kind(market_id) == "self" @@ -409,6 +417,7 @@ class Cafe24Adapter(MarketplaceAdapter): by_channel: dict[str, dict[str, Any]] = {} by_payment: dict[str, dict[str, Any]] = {} # 결제수단 조합별(카페24 열 주문만) unpaid = 0 + paid_self: dict[str, int] = {} # 그날 결제된 카페24 열 주문 → (결제 당시 − 현재) 금액 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 @@ -436,6 +445,8 @@ class Cafe24Adapter(MarketplaceAdapter): for k, v in order_amounts(o).items(): g[k] += v g["total"] += order_total(o) + if ch["target"] == "cafe24": + paid_self[str(o.get("order_id") or "")] = order_total(o) - order_total_now(o) rows = [r for r in self.refunds(ctx, day, day) if str(r.get("status") or "T") == "T"] markets = self.market_ids(ctx, rows) refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, @@ -507,6 +518,17 @@ class Cafe24Adapter(MarketplaceAdapter): return {"count": len(sel), "payment_amount": sum(c["payment_amount"] for c in sel), "product_amount": sum(c["product_amount"] for c in sel)} + # 결제일 기준 — 그날 결제된 주문이 그 뒤(오늘까지) 환불된 금액. 카페24 일별 매출이 환불을 원 주문 결제일에 + # 빼는지 확인하는 용도(최근일만 맞고 지난 날일수록 차이가 커지는 현상). + from app.timezone import today_kst # noqa: WPS433 + + later = [x for x in self.refunds(ctx, day, max(day, today_kst())) + if str(x.get("order_id") or "") in paid_self and str(x.get("status") or "T") == "T"] + by_pay = rsum(later) + by_pay["amount_diff"] = sum(v for v in paid_self.values() if v > 0) + by_pay["refund_dates"] = sorted({str(x.get("refund_date") or "")[:10] for x in later}) + refund_basis["by_pay_date"] = by_pay + comp = refund_basis["completed"] no_refund = csum(lambda c: not c["has_refund"]) claimed = csum(lambda c: True) @@ -514,6 +536,12 @@ class Cafe24Adapter(MarketplaceAdapter): candidates = [ {"key": "completed", "label": "환불완료일 · 실제 환불액 (현재 적용)", "amount": comp["actual_refund_amount"]}, {"key": "completed_pts", "label": "환불완료일 · 실제 환불액 + 적립금·예치금", "amount": comp["with_points"]}, + {"key": "pay_date", "label": "결제일 기준 · 그날 결제 주문의 환불(오늘까지) · 실제 환불액", + "amount": by_pay["actual_refund_amount"]}, + {"key": "pay_date_pts", "label": "결제일 기준 · 그날 결제 주문의 환불(오늘까지) · 실제 + 적립금·예치금", + "amount": by_pay["with_points"]}, + {"key": "pay_date_diff", "label": "결제일 기준 · 그날 결제 주문의 (결제 당시 금액 − 현재 금액)", + "amount": by_pay["amount_diff"]}, {"key": "accepted", "label": "환불접수일(전체 상태) · 실제 환불액", "amount": refund_basis["accepted_all"]["actual_refund_amount"]}, {"key": "accepted_pts", "label": "환불접수일(전체 상태) · 실제 + 적립금·예치금", "amount": refund_basis["accepted_all"]["with_points"]}, {"key": "claim_pay", "label": "취소·반품·교환 완료 품목 · 품목 결제금액", "amount": claimed["payment_amount"]}, diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 32d9c25..17e5925 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index d8883f5..a980e9c 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 31e48b1..b453e50 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -474,7 +474,12 @@ def test_cafe24_normalize_matches_daily_report(): assert target_code("NCHECKOUT", "NCHECKOUT") == "cafe24" and target_code("KAKAOPAY") == "cafe24" assert target_code("naver") == "cafe24" and target_code("kakao") == "cafe24" # 결제수단과 헷갈리는 일반 이름 X # 대조: 카페24 열(자체몰 채널+모르는 채널)/다른 쇼핑몰 열 + 주문 채널별 - rec = fake.reconcile(ctx, date(2026, 9, 29)) + import app.timezone as _tz + _orig_today, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29)) + try: + rec = fake.reconcile(ctx, date(2026, 9, 29)) + finally: + _tz.today_kst = _orig_today assert rec["orders"]["self"]["orders"] == 5 and rec["orders"]["self"]["total"] == 5 * 47_000 # A,D,E,F,G assert rec["orders"]["market"]["orders"] == 1 and rec["unpaid_orders"] == 1 # B(스마트스토어) assert rec["refunds"]["self"]["actual_refund_amount"] == 32_610 and rec["refunds"]["market"]["count"] == 1 @@ -489,6 +494,10 @@ def test_cafe24_normalize_matches_daily_report(): assert rb["accepted_all"]["count"] == 4 and rb["accepted_all"]["with_points"] == 12_610 + 20_000 + 9_000 + 5_000 assert {s["status"]: s["count"] for s in rb["accepted_by_status"]} == {"T": 3, "F": 1} assert {c["key"] for c in rec["refund_candidates"]} >= {"completed", "completed_pts", "claim_pay"} + # 결제일 기준: 그날 결제된 카페24 열 주문(A,D,E,F,G)의 환불만 — X(결제 없음)·M(스마트스토어)·미완료 제외 + bp = rec["refund_basis"]["by_pay_date"] + assert bp["count"] == 1 and bp["actual_refund_amount"] == 12_610 + assert bp["amount_diff"] == 5 * 50_000 # 결제 당시 − 현재(가짜 현재 상품금액 0) assert {r["refund_code"] for r in rec["refund_list"]} == {"C20260929-01", "R20260929-02", "C20260929-03", "C20260929-04"} assert "1234567890" not in str(rec["refund_list"]) # 환불 계좌 미노출 # 클레임 완료 품목: 환불 API 에 없는 취소(네이버페이 등)를 찾는다. 입금전취소·미완료는 합계 제외 diff --git a/app/static/performance.js b/app/static/performance.js index 76803df..00e959c 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -536,6 +536,8 @@ "" + row("환불완료일 기준 · 완료 현재 적용", b.completed, "perf-row-week") + row("환불접수일 기준 · 전체 상태", b.accepted_all) + + (b.by_pay_date ? row("결제일 기준 · 그날 결제한 주문의 환불(오늘까지" + + (b.by_pay_date.refund_dates.length ? ", 환불일 " + esc(b.by_pay_date.refund_dates.join(", ")) : "") + ")", b.by_pay_date) : "") + (b.accepted_by_status || []).map(function (s) { return row(" · 접수일 기준 " + esc(s.label), s); }).join("") + "
market_id주문경로적립금·예치금 환불합계(포함)
"; From b3ee219858e0caa21c05f7e4a88b6946e558d7fb Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:52:57 +0900 Subject: [PATCH 13/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EB=8C=80=EC=A1=B0=20=E2=80=94=20?= =?UTF-8?q?=EA=B8=88=EC=95=A1=EC=9D=B4=20=EC=A4=84=EC=96=B4=EB=93=A0=20?= =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EA=B1=B4=EB=B3=84=20+=20=EC=A3=BC?= =?UTF-8?q?=EB=AC=B8=EC=B7=A8=EC=86=8C=EC=9D=BC=20=EC=A1=B0=ED=9A=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 결제일 기준 후보도 카페24 환불합계와 맞지 않음(9/26, 9/27). 9/26 결제 주문의 (결제 당시 − 현재) 205,200 중 환불 기록은 148,320 뿐이라, 환불 API 에 안 잡히는 취소(네이버페이 등)를 찾기 위해 줄어든 주문을 건별로(채널·결제수단·품목 상태· 네이버페이 클레임·취소일·환불 기록) 표시. 클레임 조회에 cancel_date 추가. Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 28 +++++++++++++++++-- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 3 ++ app/static/performance.js | 15 ++++++++++ 5 files changed, 45 insertions(+), 5 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 4c0bae8..b768ac7 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -51,8 +51,8 @@ CHUNK_DAYS = 60 EVENT_PREFIX = "c24:" # 매출 대조 전용 — 클레임 완료 주문 조회 날짜 유형과 "완료" 상태(입금전취소 C47~49 는 결제 전이라 제외) -CLAIM_DATE_TYPES = (("cancel_complete_date", "취소완료"), ("return_complete_date", "반품완료"), - ("exchange_complete_date", "교환완료")) +CLAIM_DATE_TYPES = (("cancel_complete_date", "취소완료"), ("cancel_date", "주문취소일"), + ("return_complete_date", "반품완료"), ("exchange_complete_date", "교환완료")) CLAIM_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43", "E40"}) UNPAID_CANCEL = frozenset({"C47", "C48", "C49"}) @@ -418,6 +418,7 @@ class Cafe24Adapter(MarketplaceAdapter): by_payment: dict[str, dict[str, Any]] = {} # 결제수단 조합별(카페24 열 주문만) unpaid = 0 paid_self: dict[str, int] = {} # 그날 결제된 카페24 열 주문 → (결제 당시 − 현재) 금액 + reduced: dict[str, dict[str, Any]] = {} # 그중 금액이 줄어든 주문(취소·반품) — 환불 기록과 대조 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 @@ -446,7 +447,22 @@ class Cafe24Adapter(MarketplaceAdapter): g[k] += v g["total"] += order_total(o) if ch["target"] == "cafe24": - paid_self[str(o.get("order_id") or "")] = order_total(o) - order_total_now(o) + oid_ = str(o.get("order_id") or "") + paid_self[oid_] = order_total(o) - order_total_now(o) + if paid_self[oid_] > 0: + reduced[oid_] = { + "order_id": oid_, "channel": str(o.get("order_place_name") or o.get("market_id") or ""), + "payment": " + ".join(str(n) for n in (o.get("payment_method_name") or []) if n), + "initial": order_total(o), "now": order_total_now(o), "diff": paid_self[oid_], + "statuses": sorted({f"{i.get('order_status') or ''} {i.get('status_text') or ''}".strip() + for i in o.get("items") or []}), + "naver_pay": sorted({str(i.get("naver_pay_claim_status")) for i in o.get("items") or [] + if i.get("naver_pay_claim_status")}), + "claim_dates": sorted({str(i.get(k))[:10] for i in o.get("items") or [] + for k in ("cancel_date", "refund_date", "return_confirmed_date") + if i.get(k)}), + "refunded": 0, "refund_dates": [], + } rows = [r for r in self.refunds(ctx, day, day) if str(r.get("status") or "T") == "T"] markets = self.market_ids(ctx, rows) refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, @@ -528,6 +544,11 @@ class Cafe24Adapter(MarketplaceAdapter): by_pay["amount_diff"] = sum(v for v in paid_self.values() if v > 0) by_pay["refund_dates"] = sorted({str(x.get("refund_date") or "")[:10] for x in later}) refund_basis["by_pay_date"] = by_pay + for x in later: + r_ = reduced.get(str(x.get("order_id") or "")) + if r_ is not None: + r_["refunded"] += _won(x.get("actual_refund_amount")) + _won(x.get("used_points")) + _won(x.get("used_credits")) + r_["refund_dates"] = sorted({*r_["refund_dates"], str(x.get("refund_date") or "")[:10]}) comp = refund_basis["completed"] no_refund = csum(lambda c: not c["has_refund"]) @@ -557,6 +578,7 @@ class Cafe24Adapter(MarketplaceAdapter): "by_channel": channels_out, "refund_basis": refund_basis, "refund_list": sorted(refund_list.values(), key=lambda r: r["refund_code"]), "claims": claims, "refund_candidates": candidates, + "reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True), "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 17e5925..f20d3e5 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index a980e9c..7144ec3 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index b453e50..d7a38a9 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -498,6 +498,9 @@ def test_cafe24_normalize_matches_daily_report(): bp = rec["refund_basis"]["by_pay_date"] assert bp["count"] == 1 and bp["actual_refund_amount"] == 12_610 assert bp["amount_diff"] == 5 * 50_000 # 결제 당시 − 현재(가짜 현재 상품금액 0) + red = {x["order_id"]: x for x in rec["reduced_orders"]} + assert set(red) == {"A", "D", "E", "F", "G"} and red["A"]["refunded"] == 12_610 and red["D"]["refunded"] == 0 + assert rec["reduced_orders"][-1]["order_id"] == "A" # 환불 기록으로 설명 안 되는 금액이 큰 순 assert {r["refund_code"] for r in rec["refund_list"]} == {"C20260929-01", "R20260929-02", "C20260929-03", "C20260929-04"} assert "1234567890" not in str(rec["refund_list"]) # 환불 계좌 미노출 # 클레임 완료 품목: 환불 API 에 없는 취소(네이버페이 등)를 찾는다. 입금전취소·미완료는 합계 제외 diff --git a/app/static/performance.js b/app/static/performance.js index 00e959c..e023872 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -566,6 +566,21 @@ '' + won(x.used_points + x.used_credits) + "" + esc((x.methods || []).join(", ") || "–") + ""; }).join("") + "" : "") + + ((r.reduced_orders || []).length + ? '

그날 결제한 주문 중 금액이 줄어든 주문 (취소·반품) — "환불 기록 없음"이 환불 API 에 안 잡힌 건

' + + '' + + '' + + "" + + r.reduced_orders.map(function (x) { + const miss = x.diff - x.refunded; + return " 0 ? ' class="perf-row-match"' : "") + '>"; + }).join("") + "
주문번호채널결제수단품목 상태취소·환불일결제 당시현재줄어든 금액환불 기록
' + esc(x.order_id) + "" + + esc(x.channel || "–") + "" + esc(x.payment || "–") + "" + + esc(x.statuses.join(", ") + (x.naver_pay.length ? " / 네이버페이 " + x.naver_pay.join(",") : "")) + "" + + esc(x.claim_dates.join(", ") || "–") + '' + won(x.initial) + '' + + won(x.now) + '' + won(x.diff) + '' + + (x.refunded ? won(x.refunded) + ' ' + esc(x.refund_dates.join(", ")) + "" : "없음") + "
" + : "") + (r.claims ? '

그날 취소·반품·교환 완료 품목 (주문 API)

' + ((r.claims.errors || []).length ? '

' + esc(r.claims.errors.join(" / ")) + "

" : "") + From 1d12ac878b96e8664d529dbebea8d5dfbf212322 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 17:59:24 +0900 Subject: [PATCH 14/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=ED=99=98=EB=B6=88=ED=95=A9=EA=B3=84=EB=A5=BC=20=EC=9D=BC?= =?UTF-8?q?=EB=B3=84=20=EB=A7=A4=EC=B6=9C=EB=82=B4=EC=97=AD=EA=B3=BC=20?= =?UTF-8?q?=EA=B0=99=EA=B2=8C=20=E2=80=94=20=EC=A0=81=EB=A6=BD=EA=B8=88=20?= =?UTF-8?q?=ED=99=98=EB=B6=88=20+=20=EB=84=A4=EC=9D=B4=EB=B2=84=ED=8E=98?= =?UTF-8?q?=EC=9D=B4=20=EC=B7=A8=EC=86=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 실데이터 대조 결과 카페24 일별 매출 환불합계 = 환불 목록(실제 환불액 + 적립금·예치금 환불) + 환불 목록에 없는 취소·반품(네이버페이 취소 등, 품목 취소일 기준) 9/26: 178,220 + 1,080 + 96,500 = 275,800, 9/27: 145,000 + 55,800 = 200,800 일치. - normalize_refund 금액에 적립금·예치금 환불 포함(refund_total) - unrefunded_claims: orders date_type=cancel_date|return_complete_date 의 C40~43/R40~43 품목 중 앞뒤 60일 환불 목록에 없는 주문 → CANCEL/RETURN 사건(c24:{품목코드}-CL) - 대조 화면 환불합계를 적용 규칙으로 표시 + "적용 규칙" 후보 - 테스트 추가 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 101 ++++++++++++++++-- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 46 +++++++- app/static/performance.js | 15 +-- docs/PERFORMANCE_MODULE.md | 13 ++- 6 files changed, 157 insertions(+), 22 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index b768ac7..e8acc3a 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -55,6 +55,10 @@ CLAIM_DATE_TYPES = (("cancel_complete_date", "취소완료"), ("cancel_date", " ("return_complete_date", "반품완료"), ("exchange_complete_date", "교환완료")) CLAIM_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43", "E40"}) UNPAID_CANCEL = frozenset({"C47", "C48", "C49"}) +# 환불 목록(/admin/refunds)에 없는 취소·반품(네이버페이 등) — 카페24 일별 매출 환불합계에는 들어간다(실데이터 확인) +NO_RECORD_DATE_TYPES = ("cancel_date", "return_complete_date") +NO_RECORD_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43"}) +REFUND_LOOKAROUND_DAYS = 60 # 카페24 자체몰 주문 채널 — market_id 는 외부 마켓만이 아니라 주문 채널·간편결제도 담는다 # (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃). @@ -141,6 +145,11 @@ def order_total(order: dict[str, Any]) -> int: - sum(a[k] for k in DISCOUNT_FIELDS) - sum(a[k] for k in COUPON_FIELDS)) +def refund_total(refund: dict[str, Any]) -> int: + """환불합계 = 실제 환불액 + 적립금·예치금 환불.""" + return _won(refund.get("actual_refund_amount")) + _won(refund.get("used_points")) + _won(refund.get("used_credits")) + + def order_total_now(order: dict[str, Any]) -> int: """취소·반품 반영 후 현재 결제합계(actual_order_amount). 없으면 결제 당시 금액.""" a = order.get("actual_order_amount") or order.get("initial_order_amount") or {} @@ -314,6 +323,49 @@ class Cafe24Adapter(MarketplaceAdapter): seen.add(oid) return {"items": items, "errors": errors, "full_cancel_shipping": full_cancel_shipping} + def unrefunded_claims(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]: + """환불 목록에 기록이 없는 취소·반품 완료 품목(네이버페이 취소 등). 날짜 = 품목 취소일(반품은 반품완료일). + 금액 = 판매가(+옵션)×수량 − 품목 할인·쿠폰. 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 있으면 제외해 + 환불 목록 쪽과 두 번 빼지 않는다.""" + from app.timezone import today_kst # noqa: WPS433 + + found: dict[str, dict[str, Any]] = {} + for date_type in NO_RECORD_DATE_TYPES: + for s, e in _chunks(start, end): + for o in self._paged(ctx, "/admin/orders", "orders", + {"start_date": s.isoformat(), "end_date": e.isoformat(), + "date_type": date_type, "embed": "items"}, ORDER_LIMIT): + oid = str(o.get("order_id") or "") + for i in o.get("items") or []: + status = str(i.get("order_status") or "") + if status not in NO_RECORD_DONE: + continue + keys = (("cancel_date", "refund_date", "return_confirmed_date") if status[:1] == "C" + else ("return_confirmed_date", "refund_date", "cancel_date")) + day = next((d for d in (_day(i.get(k)) for k in keys) if d), None) + if day is None or not (start <= day <= end): + continue + key = str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}") + qty = int(i.get("quantity") or 0) + amount = ((_won(i.get("product_price")) + _won(i.get("option_price"))) * qty + - _won(i.get("additional_discount_price")) - _won(i.get("coupon_discount_price")) + - _won(i.get("app_item_discount_amount"))) + found[key] = { + "order_id": oid, "item_code": key, "status": status, "day": day, + "market_id": o.get("market_id"), "place_id": o.get("order_place_id"), + "place_name": o.get("order_place_name"), "order_date": _day(o.get("order_date")), + "quantity": qty, "amount": max(0, amount), + "product_name": str(i.get("product_name") or "")[:40], + "naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""), + } + if not found: + return [] + lo = start - timedelta(days=REFUND_LOOKAROUND_DAYS) + hi = max(end, min(end + timedelta(days=REFUND_LOOKAROUND_DAYS), today_kst())) + refunded = {str(r.get("order_id") or "") for dt in ("refund_date", "accepted_refund_date") + for r in self.refunds(ctx, lo, hi, dt)} + return [c for c in found.values() if c["order_id"] not in refunded] + def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any, Any]]: """환불의 원 주문 (market_id, order_place_id, order_place_name) — 주문일 60일 구간·100건씩 묶어 조회. 못 찾으면 자체몰.""" @@ -343,6 +395,8 @@ class Cafe24Adapter(MarketplaceAdapter): for r in rows: mid, place, _name = markets.get(str(r.get("order_id")), ("self", None, None)) yield {**r, "_market_id": mid, "_order_place_id": place} + for c in self.unrefunded_claims(ctx, start, end): + yield {**c, "_kind": "claim"} def normalize_order(self, order: dict[str, Any]) -> list[SaleEvent]: """결제 주문 → SALE. 자체몰은 카페24 열, 마켓 연동 주문은 해당 쇼핑몰 열(MARKET_MAP).""" @@ -368,12 +422,15 @@ class Cafe24Adapter(MarketplaceAdapter): )] def normalize_refund(self, refund: dict[str, Any]) -> list[SaleEvent]: - """환불 → CANCEL/RETURN(−). 원 주문의 market_id 로 결제와 같은 쇼핑몰 열에 넣는다.""" + """환불 → CANCEL/RETURN(−). 원 주문의 market_id 로 결제와 같은 쇼핑몰 열에 넣는다. + 금액 = 실제 환불액 + 적립금·예치금 환불(카페24 일별 매출 환불합계와 같음, 실데이터 확인).""" + if refund.get("_kind") == "claim": + return self.normalize_claim(refund) day = _day(refund.get("refund_date")) code = str(refund.get("refund_code") or "") if day is None or not code: return [] - amount = _won(refund.get("actual_refund_amount")) + amount = refund_total(refund) return [SaleEvent( marketplace_code=target_code(refund.get("_market_id"), refund.get("_order_place_id")), event_type="RETURN" if code.upper().startswith("R") else "CANCEL", @@ -387,6 +444,23 @@ class Cafe24Adapter(MarketplaceAdapter): "quantity": refund.get("quantity"), "order_item_code": refund.get("order_item_code")}, )] + def normalize_claim(self, c: dict[str, Any]) -> list[SaleEvent]: + """환불 목록에 없는 취소·반품 품목(네이버페이 등) → CANCEL/RETURN(−), 취소일(반품완료일).""" + if not c.get("amount") or c.get("day") is None: + return [] + is_return = str(c.get("status"))[:1] == "R" + return [SaleEvent( + marketplace_code=target_code(c.get("market_id"), c.get("place_id")), + event_type="RETURN" if is_return else "CANCEL", + external_event_id=f"{EVENT_PREFIX}{c['item_code']}-CL", external_order_id=str(c.get("order_id") or ""), + external_line_id=str(c["item_code"]), order_date=c.get("order_date"), event_date=c["day"], + amount=-int(c["amount"]), quantity=-int(c.get("quantity") or 0), product_name=c.get("product_name") or "", + order_status="반품완료" if is_return else "취소완료", + raw={"order_id": c.get("order_id"), "item_code": c["item_code"], "status": c.get("status"), + "market_id": c.get("market_id"), "naver_pay_claim_status": c.get("naver_pay_claim_status"), + "no_refund_record": True}, + )] + # ── 대조(설정 화면 "카페24 매출 대조") ───────────────── def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]: """그날 결제 주문·환불을 항목별로 합산 — 카페24 일별 매출내역과 비교해 규칙을 확정하는 용도. @@ -465,8 +539,8 @@ class Cafe24Adapter(MarketplaceAdapter): } rows = [r for r in self.refunds(ctx, day, day) if str(r.get("status") or "T") == "T"] markets = self.market_ids(ctx, rows) - refunds = {"self": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}, - "market": {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}} + refunds = {k: {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0, + "no_record_count": 0, "no_record": 0, "total": 0} for k in ("self", "market")} for r in rows: mid, place, place_name = markets.get(str(r.get("order_id")), ("self", None, None)) ch = channel(mid, place, place_name) @@ -474,8 +548,18 @@ class Cafe24Adapter(MarketplaceAdapter): g["count"] += 1 for k in ("actual_refund_amount", "used_points", "used_credits"): g[k] += _won(r.get(k)) + g["total"] += refund_total(r) ch["refund_count"] += 1 - ch["refund_amount"] += _won(r.get("actual_refund_amount")) + ch["refund_amount"] += refund_total(r) + no_record = self.unrefunded_claims(ctx, day, day) + for c in no_record: + ch = channel(c["market_id"], c["place_id"], c["place_name"]) + g = refunds["self" if ch["target"] == "cafe24" else "market"] + g["no_record_count"] += 1 + g["no_record"] += c["amount"] + g["total"] += c["amount"] + ch["refund_count"] += 1 + ch["refund_amount"] += c["amount"] channels_out = sorted(({**v, "names": sorted(v["names"])} for v in by_channel.values()), key=lambda v: v["total"], reverse=True) @@ -555,7 +639,9 @@ class Cafe24Adapter(MarketplaceAdapter): claimed = csum(lambda c: True) # 카페24 "환불합계" 후보 — 화면 값과 같은 줄을 찾는다(화면에서 값을 입력하면 강조) candidates = [ - {"key": "completed", "label": "환불완료일 · 실제 환불액 (현재 적용)", "amount": comp["actual_refund_amount"]}, + {"key": "applied", "label": "적용 규칙 · 환불 목록(실제 + 적립금·예치금) + 환불 목록 없는 취소·반품(네이버페이 등)", + "amount": refunds["self"]["total"] + refunds["market"]["total"]}, + {"key": "completed", "label": "환불완료일 · 실제 환불액 (이전 규칙)", "amount": comp["actual_refund_amount"]}, {"key": "completed_pts", "label": "환불완료일 · 실제 환불액 + 적립금·예치금", "amount": comp["with_points"]}, {"key": "pay_date", "label": "결제일 기준 · 그날 결제 주문의 환불(오늘까지) · 실제 환불액", "amount": by_pay["actual_refund_amount"]}, @@ -578,6 +664,9 @@ class Cafe24Adapter(MarketplaceAdapter): "by_channel": channels_out, "refund_basis": refund_basis, "refund_list": sorted(refund_list.values(), key=lambda r: r["refund_code"]), "claims": claims, "refund_candidates": candidates, + "no_record_claims": [{**c, "day": c["day"].isoformat(), + "order_date": c["order_date"].isoformat() if c["order_date"] else None} + for c in no_record], "reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True), "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index f20d3e5..b66215f 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 7144ec3..5664b04 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -143,4 +143,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index d7a38a9..915eeb9 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -425,7 +425,7 @@ class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist if params.get("date_type") == "order_date": # 원 주문 market_id 조회 ids = params["order_id"].split(",") return {"orders": [{"order_id": i, "market_id": self.lookup.get(i, "self")} for i in ids]} - if params.get("date_type", "").endswith("_complete_date"): + if params.get("date_type", "").endswith("_complete_date") or params.get("date_type") == "cancel_date": return {"orders": self.claims.get(params["date_type"], []) if idx == 0 else []} return {"orders": self.orders_pages[idx] if idx < len(self.orders_pages) else []} @@ -549,6 +549,50 @@ def test_cafe24_normalize_matches_daily_report(): assert calls[1]["offset"] == 1000 and all(c["limit"] == 1000 and c["date_type"] == "pay_date" for c in calls) +def test_cafe24_refund_total_includes_points_and_naverpay_cancels(): + """카페24 일별 매출 환불합계 = 환불 목록(실제 + 적립금·예치금) + 환불 목록에 없는 취소·반품(네이버페이 등). + 실데이터: 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800, 9/27 = 145,000 + 네이버페이 55,800.""" + import app.timezone as _tz + from app.modules.performance.adapters.base import AdapterContext + + ctx = AdapterContext(code="cafe24", credentials=None) + item = lambda code, st, price, qty=1, day="2026-09-26 15:00:00", **kw: { + "order_item_code": code, "order_status": st, "quantity": qty, "product_price": f"{price}.00", + "option_price": "0.00", "product_name": "상품", "cancel_date": day, **kw} + refund = {**_c24_refund("C20260926-01", "O1", 63_720), "used_points": "1080.00", + "refund_date": "2026-09-26T20:25:08+09:00"} + fake = _FakeCafe24([[]], [[refund]], claims={ + "cancel_date": [ + {**_c24_order("O1"), "items": [item("O1-01", "C40", 64_800)]}, # 환불 목록 있음 → 제외 + {**_c24_order("NP1", market="NCHECKOUT"), "items": [item("NP1-01", "C40", 55_800), + item("NP1-02", "N40", 9_000)]}, # 정상 품목 제외 + {**_c24_order("NP2", market="NCHECKOUT"), "items": [item("NP2-01", "C40", 20_000, 2, + coupon_discount_price="1000.00")]}, + {**_c24_order("NP3", market="NCHECKOUT"), "items": [item("NP3-01", "C40", 5_000, day="2026-09-27 01:00:00")]}, + {**_c24_order("NP4", market="NCHECKOUT"), "items": [item("NP4-01", "C00", 5_000)]}, # 취소신청만 → 제외 + ], + "return_complete_date": [{**_c24_order("NP1", market="NCHECKOUT"), "items": [item("NP1-01", "C40", 55_800)]}], + }) + orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29)) + try: + _, events = fake.collect(ctx, date(2026, 9, 26), date(2026, 9, 26)) + rec = fake.reconcile(ctx, date(2026, 9, 26)) + finally: + _tz.today_kst = orig + by = {e.external_event_id: e for e in events if e.event_type != "SALE"} + assert by["c24:C20260926-01"].amount == -(63_720 + 1_080) # 적립금 환불 포함 + assert by["c24:NP1-01-CL"].amount == -55_800 and by["c24:NP1-01-CL"].event_type == "CANCEL" + assert by["c24:NP1-01-CL"].event_date == date(2026, 9, 26) and by["c24:NP1-01-CL"].marketplace_code == "cafe24" + assert by["c24:NP2-01-CL"].amount == -(40_000 - 1_000) # 판매가×수량 − 품목 쿠폰 + assert set(by) == {"c24:C20260926-01", "c24:NP1-01-CL", "c24:NP2-01-CL"} # 다른 날·신청·환불 기록 있는 주문 제외 + rs = rec["refunds"]["self"] + assert rs["no_record_count"] == 2 and rs["no_record"] == 55_800 + 39_000 + assert rs["total"] == 63_720 + 1_080 + 55_800 + 39_000 + cand = {c["key"]: c["amount"] for c in rec["refund_candidates"]} + assert cand["applied"] == rs["total"] + assert {c["item_code"] for c in rec["no_record_claims"]} == {"NP1-01", "NP2-01"} + + def test_cafe24_scope_and_replace_range(): import app.modules.performance.sync as syncmod from app.modules.performance.adapters.base import AdapterContext diff --git a/app/static/performance.js b/app/static/performance.js index e023872..ecf11f6 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -509,11 +509,14 @@ [" 참고: 실결제금액", s.payment_amount, m.payment_amount, "sub"], [" 참고: 적립금 사용", s.points_spent_amount, m.points_spent_amount, "sub"], [" 참고: 예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "sub"], - ["환불 건수", rs.count, rm.count, "cnt"], - ["환불합계(실제 환불액)", rs.actual_refund_amount, rm.actual_refund_amount, "key"], - [" 참고: 환불 적립금", rs.used_points, rm.used_points, "sub"], - [" 참고: 환불 예치금", rs.used_credits, rm.used_credits, "sub"], - ["순매출(결제합계 − 환불합계)", s.total - rs.actual_refund_amount, m.total - rm.actual_refund_amount, "key"], + ["환불 건수(환불 목록)", rs.count, rm.count, "cnt"], + [" · 실제 환불액", rs.actual_refund_amount, rm.actual_refund_amount, "sub"], + [" · 적립금 환불", rs.used_points, rm.used_points, "sub"], + [" · 예치금 환불", rs.used_credits, rm.used_credits, "sub"], + ["환불 목록 없는 취소·반품 품목 수(네이버페이 등)", rs.no_record_count, rm.no_record_count, "cnt"], + [" · 취소·반품 금액", rs.no_record, rm.no_record, "sub"], + ["환불합계", rs.total, rm.total, "key"], + ["순매출(결제합계 − 환불합계)", s.total - rs.total, m.total - rm.total, "key"], ]); out.innerHTML = '" + @@ -534,7 +537,7 @@ return '

환불 기준 비교 — 카페24 화면의 그날 "환불합계"와 같은 칸을 찾아 주세요

' + '
' + esc(r.date) + "카페24 열(자체몰 채널)다른 쇼핑몰 열(외부 마켓)
' + "" + - row("환불완료일 기준 · 완료 현재 적용", b.completed, "perf-row-week") + + row("환불완료일 기준 · 완료 적용(합계 포함 칸)", b.completed, "perf-row-week") + row("환불접수일 기준 · 전체 상태", b.accepted_all) + (b.by_pay_date ? row("결제일 기준 · 그날 결제한 주문의 환불(오늘까지" + (b.by_pay_date.refund_dates.length ? ", 환불일 " + esc(b.by_pay_date.refund_dates.join(", ")) : "") + ")", b.by_pay_date) : "") + diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 30f832a..db2e070 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -43,7 +43,8 @@ | 사건 | 조회 | 금액·날짜 | |---|---|---| | SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(상품구매금액 + 배송비 − 할인 − 쿠폰), `initial_order_amount`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) | -| CANCEL / RETURN(환불합계) | `GET /admin/refunds` `date_type=refund_date`, `status=T` | −실제 환불액(`actual_refund_amount`), 환불완료일. 환불코드 R… = 반품, 그 밖 = 취소. 사건 ID = 환불코드 | +| CANCEL / RETURN(환불합계) | `GET /admin/refunds` `date_type=refund_date`, `status=T` | −(실제 환불액 + 적립금·예치금 환불), 환불완료일. 환불코드 R… = 반품, 그 밖 = 취소. 사건 ID = 환불코드 | +| CANCEL / RETURN(환불 목록 없는 취소·반품) | `GET /admin/orders` `date_type=cancel_date|return_complete_date`, `embed=items` — 품목 상태 C40~43/R40~43 이고 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 없을 때 | −(판매가+옵션)×수량 − 품목 할인·쿠폰, 품목 취소일(반품은 반품완료일). 네이버페이 취소가 여기 해당 (네이버가 환불해 카페24 환불 목록에 없음). 사건 ID = `c24:{품목코드}-CL` (`unrefunded_claims`) | - 할인 = 회원·세트상품·앱·마켓 기타·배송비 할인, 쿠폰 = 상품쿠폰 + 배송비쿠폰(`DISCOUNT_FIELDS`/`COUPON_FIELDS`). - **기간 교체(`replace_range=True`)**: 결제·환불 모두 기간 안 날짜로 조회되므로 동기화 때 그 기간의 카페24 실데이터를 지우고 @@ -129,12 +130,10 @@ - **대시보드 [매출 업데이트]** = 지금 보고 있는 기간(오늘까지)을 `POST /api/sync {from, to}` 로 다시 가져온다 ("이번달"이면 1일~오늘). 모듈 권한자는 92일까지, 더 긴 기간(올해 등, 최대 366일)은 관리자만. - **과거 매출 가져오기**(설정 화면, 관리자): 같은 API 로 임의 기간(최대 366일). 같은 사건은 덮어써서 여러 번 해도 중복 없음. -- 카페24 **환불 기준**은 현재 환불완료일(refund_date)·실제 환불액. 대조 도구의 "환불 기준 비교"(완료일 vs 접수일, 적립금·예치금 - 포함 여부)로 카페24 "환불합계"와 같은 기준을 확인한 뒤 확정한다(9/23~27 순매출이 카페24보다 크게 나온 원인 조사 중). - 9/26 은 결제합계가 카페24와 같고(3,568,265) 환불만 97,580 모자라며, 완료일·접수일·적립금 포함 어느 기준으로도 맞지 않았다 - → 환불 API 에 안 잡히는 환불이 있다고 보고, 대조 도구에 **환불합계 후보**(카페24 값 입력 시 일치 줄 강조)·**환불 건별**· - **그날 취소/반품/교환 완료 품목**(`GET /admin/orders` `date_type=cancel_complete_date|return_complete_date|exchange_complete_date`, - `embed=items`, 품목별 판매가·결제금액·환불 기록 유무, `claim_items()`)을 추가해 빠진 건을 찾는다. +- 카페24 **환불합계 규칙(확정, 2026-09-29 실데이터)**: 카페24 "일별 매출내역" 환불합계 = 환불 목록의 (실제 환불액 + 적립금·예치금 환불) + + 환불 목록에 없는 취소·반품(네이버페이 등, 취소일 기준). 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800, + 9/27 = 145,000 + 네이버페이 55,800 = 200,800 으로 일치. 대조 도구에 환불합계 후보(값 입력 시 일치 줄 강조)·환불 건별· + 취소/반품 완료 품목·그날 결제 주문 중 줄어든 주문 표가 있어 규칙이 어긋나면 이것으로 다시 찾는다. - 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리). - 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고 상단에 오류 쇼핑몰만 표시. From 614332a1e6895e35c1038c388348a6331ef1cefb Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 21:36:32 +0900 Subject: [PATCH 15/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EC=9D=BC=EB=B3=84=20=EB=A7=A4=EC=B6=9C=EB=82=B4=EC=97=AD=20?= =?UTF-8?q?=EB=B6=99=EC=97=AC=EB=84=A3=EA=B8=B0=EB=A1=9C=20=EB=82=A0?= =?UTF-8?q?=EC=A7=9C=EB=B3=84=20=ED=95=9C=20=EB=B2=88=EC=97=90=20=EB=B9=84?= =?UTF-8?q?=EA=B5=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 카페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 --- app/modules/performance/db.py | 19 ++++ app/modules/performance/router.py | 18 +++ app/modules/performance/sync.py | 33 ++++++ .../templates/performance/index.html | 4 +- .../templates/performance/settings.html | 16 ++- .../performance/tests/test_performance.py | 42 +++++++ app/static/performance.css | 5 + app/static/performance.js | 104 ++++++++++++++++++ docs/PERFORMANCE_MODULE.md | 4 + 9 files changed, 241 insertions(+), 4 deletions(-) diff --git a/app/modules/performance/db.py b/app/modules/performance/db.py index 1a4180c..5ae6763 100644 --- a/app/modules/performance/db.py +++ b/app/modules/performance/db.py @@ -292,6 +292,25 @@ class PerformanceDBStore: ).fetchall() return {(r["sales_date"], r["marketplace_code"]): int(r["amount"] or 0) 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: diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py index 83f5bb6..e7e408c 100644 --- a/app/modules/performance/router.py +++ b/app/modules/performance/router.py @@ -11,6 +11,7 @@ JSON API — 관리자 POST /performance/api/marketplaces/{code}/rates 수수료율(적용 시작일) DELETE /performance/api/marketplaces/{code}/rates/{id} GET /performance/api/marketplaces/{code}/credentials 입력칸 + 저장 여부(비밀 원문 없음) + GET /performance/api/marketplaces/{code}/daily-check 일별 매출 비교(저장값 + 지금 API 값) PUT /performance/api/marketplaces/{code}/credentials 저장(암호화) POST /performance/api/marketplaces/{code}/test 연결 테스트(저장값 또는 새 입력값) POST /performance/api/sample-data 테스트 데이터 생성/삭제 @@ -36,6 +37,7 @@ from .adapters.registry import all_adapters, get_adapter router = APIRouter(prefix="/performance", tags=["performance"]) MAX_EVENT_DAYS = 31 +MAX_CHECK_DAYS = 62 # 쇼핑몰 화면 일별 비교(카페24 일별 매출내역 붙여넣기) MAX_BACKFILL_DAYS = 366 MAX_USER_SYNC_DAYS = 92 # 관리자가 아니어도 가져올 수 있는 기간(이번달·직접선택 짧은 기간) @@ -286,6 +288,22 @@ def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="da return JSONResponse(sync.reconcile(code, day, user=user["email"])) +@router.get("/api/marketplaces/{code}/daily-check") +def api_daily_check(request: Request, code: str, from_: str = Query(..., alias="from"), to: str | None = None, + live: bool = False) -> JSONResponse: + """쇼핑몰 화면 일별 매출과 날짜별 비교 — 저장값(db) + live=1 이면 지금 API 로 다시 계산한 값(저장 안 함).""" + store, user = common.require_store(request, admin=True) + _code_or_404(store, code) + start = _parse_date(from_) + end = _parse_date(to) or start + if end < start: + start, end = end, start + if (end - start).days + 1 > MAX_CHECK_DAYS: + raise HTTPException(status_code=400, detail=f"일별 비교는 {MAX_CHECK_DAYS}일 이내만 가능합니다.") + _, sync = common.services(request, store) + return JSONResponse(sync.daily_check(code, start, end, live=live, user=user["email"])) + + @router.post("/api/sample-data") def api_sample_data(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse: store, _ = common.require_store(request, admin=True) diff --git a/app/modules/performance/sync.py b/app/modules/performance/sync.py index e53e2c7..b0c1792 100644 --- a/app/modules/performance/sync.py +++ b/app/modules/performance/sync.py @@ -152,6 +152,39 @@ class SyncService: 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 diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index b66215f..4e803cd 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro won(v) -%} {%- if v is none -%} @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 5664b04..cd9c2e9 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} @@ -125,6 +125,18 @@
+ +

일별 한 번에 비교

+

카페24 일별 매출내역 표를 그대로 복사해 붙여 넣으면 날짜마다 결제합계·환불합계를 저장된 값과 비교합니다. + [API 값도 계산]을 켜면 지금 규칙으로 카페24에서 다시 계산한 값(저장 안 함)도 함께 보여 줘, 저장값만 틀린 날(다시 가져오면 해결)과 + 규칙이 틀린 날을 나눠 볼 수 있습니다. 날짜를 누르면 위 대조를 그날로 엽니다.

+ +
+ + +
+
@@ -143,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 915eeb9..d8f7a8a 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -252,6 +252,22 @@ class FakeStore: if not (mine(k, v) and not v["is_sample"] and start <= v["sales_date"] <= end)} return self.upsert_events(code, events) + def daily_breakdown(self, code, start, end, *, id_prefix=""): + days = {} + for (c, _, eid), v in self.events.items(): + if v["is_sample"] or not (start <= v["sales_date"] <= end): + continue + if not (c == code or (id_prefix and eid.startswith(id_prefix))): + continue + r = days.setdefault(v["sales_date"].isoformat(), {"date": v["sales_date"].isoformat(), "paid": 0, + "orders": 0, "refund": 0, "synced_at": None}) + if v["event_type"] == "SALE": + r["paid"] += v["amount"] + r["orders"] += 1 + else: + r["refund"] -= v["amount"] + return sorted(days.values(), key=lambda r: r["date"]) + def upsert_events(self, code, events, *, is_sample=False): n = 0 for e in events: @@ -634,6 +650,32 @@ def test_cafe24_scope_and_replace_range(): ("naver", "direct-naver-1"), ("cafe24", "sample")}, got +def test_daily_check_db_vs_live(): + """일별 비교: 저장값(카페24 경유 다른 마켓 열 포함) + 지금 API 값(저장 안 함).""" + import app.modules.performance.sync as syncmod + + st = FakeStore() + d = date(2026, 9, 29) + ev = lambda eid, t, amt, **kw: {"event_type": t, "external_event_id": eid, "external_order_id": "o", + "event_date": d, "sales_date": d, "amount": amt, **kw} + st.upsert_events("cafe24", [ev("c24:A-PAY", "SALE", 40_000), ev("c24:R1", "CANCEL", -5_000)]) + st.upsert_events("naver", [ev("c24:B-PAY", "SALE", 10_000), ev("direct-1", "SALE", 99_999)]) + fake = _FakeCafe24([[_c24_order("A"), _c24_order("B", market="shopn"), _c24_order("C")]], + [[_c24_refund("C20260929-01", "A", 7_000)]]) + orig = syncmod.get_adapter + syncmod.get_adapter = lambda c: fake + try: + svc = SyncService(st, CredentialService(st, lambda: ring())) + only_db = svc.daily_check("cafe24", d, d) + both = svc.daily_check("cafe24", d, d, live=True) + finally: + syncmod.get_adapter = orig + assert "live" not in only_db + assert both["db"] == [{"date": "2026-09-29", "paid": 50_000, "orders": 2, "refund": 5_000, "synced_at": None}] + assert both["live"] == [{"date": "2026-09-29", "paid": 3 * 47_000, "orders": 3, "refund": 7_000}] + assert len(st.events) == 4 # 저장값은 바뀌지 않음 + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 diff --git a/app/static/performance.css b/app/static/performance.css index d30ba31..2bf3cfb 100644 --- a/app/static/performance.css +++ b/app/static/performance.css @@ -210,3 +210,8 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; } } .perf-table tr.perf-row-match > *{background:#e7f6ec;font-weight:600} +.perf-paste { width: 100%; min-height: 96px; font-family: ui-monospace, Consolas, monospace; font-size: 12px; white-space: pre; resize: vertical; box-sizing: border-box; } +.perf-table tr.perf-row-diff > * { background: #fff7f5; } +.perf-diff-bad { color: var(--perf-down); font-weight: 600; } +.perf-diff-ok { color: #0f8a3a; } +.perf-link { background: none; border: 0; padding: 0; color: inherit; font: inherit; text-decoration: underline dotted; cursor: pointer; } diff --git a/app/static/performance.js b/app/static/performance.js index ecf11f6..13e1d8a 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -663,6 +663,110 @@ } finally { recon.disabled = false; } }); + // ── 일별 한 번에 비교 — 카페24 일별 매출내역 붙여넣기 ↔ 저장값 ↔ 지금 API 값 ── + // 붙여넣은 한 줄: "2026-09-29(화) 주문수 품목수 … 결제합계 환불합계 순매출" — 뒤의 세 숫자와 첫 숫자(주문수)만 쓴다. + function parseDaily(text) { + const out = {}; + String(text || "").split(/\r?\n/).forEach(function (line) { + const m = line.match(/(\d{4})[-./](\d{2})[-./](\d{2})/); + if (!m) return; + const nums = (line.slice(m.index + m[0].length).match(/-?\d[\d,]*/g) || []) + .map(function (x) { return parseInt(x.replace(/,/g, ""), 10); }); + if (nums.length < 3) return; + const n = nums.length; + out[m[1] + "-" + m[2] + "-" + m[3]] = { orders: n >= 13 ? nums[0] : null, paid: nums[n - 3], refund: nums[n - 2], net: nums[n - 1] }; + }); + return out; + } + const dailyBtn = document.getElementById("perf-daily-check"); + if (dailyBtn) dailyBtn.addEventListener("click", async function () { + const out = document.getElementById("perf-daily-result"); + const shop = parseDaily(document.getElementById("perf-daily-paste").value); + const dates = Object.keys(shop).sort(); + if (!dates.length) { out.innerHTML = '

날짜가 있는 줄을 찾지 못했습니다. 카페24 일별 매출내역 표를 복사해 붙여 넣으세요.

'; return; } + const live = document.getElementById("perf-daily-live").checked; + dailyBtn.disabled = true; + out.innerHTML = '

' + (live ? "저장값과 카페24 API 값을 계산하는 중… (기간이 길면 1~2분)" : "저장값을 불러오는 중…") + "

"; + try { + const from = dates[0], to = dates[dates.length - 1]; + const r = await api("GET", "/performance/api/marketplaces/cafe24/daily-check?from=" + from + "&to=" + to + (live ? "&live=1" : "")); + if (!r.ok) { out.innerHTML = '

' + esc(r.message) + "

"; return; } + const byDate = function (rows) { const o = {}; (rows || []).forEach(function (x) { o[x.date] = x; }); return o; }; + const db = byDate(r.db), lv = r.live ? byDate(r.live) : null; + const zero = { paid: 0, refund: 0, orders: 0 }; + const diff = function (ours, theirs) { + const d = ours - theirs; + return d === 0 ? '✓' : '' + (d > 0 ? "+" : "") + fmt(d) + ""; + }; + const todayIso = today(); + let bad = 0, stale = 0, rule = 0; + const sum = { cp: 0, cr: 0, dp: 0, dr: 0, lp: 0, lr: 0 }; + const body = dates.slice().reverse().map(function (d) { + const c = shop[d], x = db[d] || zero, l = lv ? (lv[d] || zero) : null; + sum.cp += c.paid; sum.cr += c.refund; sum.dp += x.paid; sum.dr += x.refund; + if (l) { sum.lp += l.paid; sum.lr += l.refund; } + const dbOk = x.paid === c.paid && x.refund === c.refund; + const liveOk = l && l.paid === c.paid && l.refund === c.refund; + let verdict; + if (dbOk) verdict = '일치'; + else if (l && liveOk) { verdict = '다시 가져오면 해결'; stale++; } + else if (l) { + const what = [l.paid !== c.paid ? "결제" : "", l.refund !== c.refund ? "환불" : ""].filter(Boolean).join("·"); + verdict = '규칙 차이(' + what + ")"; rule++; + } else verdict = '차이'; + if (!dbOk) bad++; + const wd = "일월화수목금토"[new Date(d + "T00:00:00").getDay()]; + return "
" + + '" + + '" + (l ? '" : "") + + '" + (l ? '" : "") + + ""; + }).join(""); + const head = '" + + "" + (lv ? "" : "") + + "" + (lv ? "" : "") + ''; + const foot = '" + (lv ? '" : "") + '" + (lv ? '" : "") + ""; + const summary = bad + ? "저장값이 다른 날 " + bad + "일" + (lv ? " — 다시 가져오면 해결 " + stale + "일, 규칙 차이 " + rule + "일" : " — [API 값도 계산]을 켜고 다시 비교하면 원인을 나눠 볼 수 있습니다") + : "모든 날짜가 일치합니다."; + out.innerHTML = '

' + esc(summary) + + (r.live_error ? "
API 계산 실패: " + esc(r.live_error) : "") + "

" + + (stale ? '
" : "") + + '
기준건수실제 환불액적립금·예치금 환불합계(포함)
" + (d === todayIso ? ' 오늘·집계 중' : "") + "' + (c.orders == null ? "–" : fmt(c.orders)) + ' / ' + fmt(x.orders) + (l ? " / " + fmt(l.orders) : "") + "' + won(c.paid) + '' + diff(x.paid, c.paid) + "' + diff(l.paid, c.paid) + "' + won(c.refund) + '' + diff(x.refund, c.refund) + "' + diff(l.refund, c.refund) + "" + verdict + (x.synced_at ? '
저장 ' + esc(String(x.synced_at).slice(5, 16).replace("T", " ")) + "
" : "") + "
날짜주문수 카페24 / 저장' + (lv ? " / API" : "") + "결제합계(카페24)저장값 차이API 차이환불합계(카페24)저장값 차이API 차이판정
합계' + won(sum.cp) + '' + + diff(sum.dp, sum.cp) + "' + diff(sum.lp, sum.cp) + "' + won(sum.cr) + + '' + diff(sum.dr, sum.cr) + "' + diff(sum.lr, sum.cr) + "
' + head + "" + body + "" + foot + "
" + + '

차이 = 우리 값 − 카페24 값. 저장값은 카페24 열과 카페24 경유 다른 마켓 열을 합친 금액(카페24 화면과 같은 범위)입니다.

'; + } catch (err) { + out.innerHTML = '

' + esc(err.message) + "

"; + } finally { dailyBtn.disabled = false; } + }); + const dailyOut = document.getElementById("perf-daily-result"); + if (dailyOut) dailyOut.addEventListener("click", async function (e) { + const dayBtn = e.target.closest("[data-recon-day]"); + if (dayBtn && recon) { + document.getElementById("perf-recon-date").value = dayBtn.dataset.reconDay; + recon.click(); + recon.scrollIntoView({ behavior: "smooth", block: "center" }); + return; + } + const rs = e.target.closest("#perf-daily-resync"); + if (!rs) return; + if (!(await confirmMsg(rs.dataset.from + " ~ " + rs.dataset.to + " 카페24 매출을 지금 규칙으로 다시 가져옵니다."))) return; + rs.disabled = true; + rs.textContent = "가져오는 중…"; + try { + const res = await api("POST", "/performance/api/sync", { from: rs.dataset.from, to: rs.dataset.to, codes: ["cafe24"] }); + const r0 = (res.results || [])[0]; + if (r0 && !r0.ok) throw new Error((r0.label || r0.status) + ": " + (r0.message || "")); + dailyBtn.click(); + } catch (err) { + alertMsg("다시 가져오기 실패: " + err.message); + rs.disabled = false; + } + }); + // ── 과거 매출 가져오기(기간 지정 수집, 관리자) ── const backfill = document.getElementById("perf-backfill"); if (backfill) backfill.addEventListener("click", async function () { diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index db2e070..0da9a2b 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -67,6 +67,10 @@ - **카페24 매출 대조**(설정 화면, `GET /api/marketplaces/cafe24/reconcile?date=`): 그날 결제 주문·환불을 카페24 화면 열 순서대로 (주문수·품목수·상품구매금액·배송비·할인·쿠폰·결제합계·환불합계·순매출) 자체몰/다른 마켓으로 나눠 합산. 저장하지 않음. 카페24 화면과 다른 줄이 있으면 할인 항목 구성·마켓 포함 여부를 이 결과로 조정한다. +- **일별 한 번에 비교**(같은 카드, `GET /api/marketplaces/{code}/daily-check?from=&to=&live=1`, 최대 62일): 카페24 일별 + 매출내역 표를 붙여 넣으면(날짜 + 뒤 세 숫자 = 결제합계·환불합계·순매출, 첫 숫자 = 주문수) 날짜마다 저장값(`c24:` 사건 전체, + 다른 마켓 열 포함)과 지금 API·현재 규칙으로 다시 계산한 값(`adapter.collect`, 저장 안 함)을 비교한다. + 저장값만 틀림 → 예전 규칙으로 받은 것([다시 가져오기] 버튼), API 값도 틀림 → 규칙 차이(결제/환불) → 날짜 클릭으로 그날 대조. ### 연동 단계 체크리스트(쇼핑몰마다) From 6f43f8066abd50a34e56e4c37028e197eb4db229 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 21:43:50 +0900 Subject: [PATCH 16/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EA=B2=B0=EC=A0=9C=ED=95=A9=EA=B3=84=EC=97=90=EC=84=9C=20?= =?UTF-8?q?=ED=92=88=EB=AA=A9=20=EC=83=81=ED=92=88=EC=B6=94=EA=B0=80?= =?UTF-8?q?=ED=95=A0=EC=9D=B8=20=EB=B9=BC=EA=B8=B0=20+=20=EB=8C=80?= =?UTF-8?q?=EC=A1=B0=20=ED=91=9C=EC=97=90=20=EC=B9=B4=ED=8E=9824=20?= =?UTF-8?q?=EC=97=B4=EB=B3=84=20=EC=B0=A8=EC=9D=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 일별 비교 결과 결제합계가 틀린 날은 모두 카페24 상품구매금액이 100원 단위가 아닌 날이고, 차이만큼 더하면 정확히 100원 단위가 된다(9/23 1,860,738+62, 9/22 2,620,740+260, 9/12 7,889,287+13 …). 카페24 화면의 상품구매금액은 품목 상품추가할인(items[].additional_discount_price, 문서: 상품추가할인액)을 뺀 값인데, initial_order_amount 에는 이 할인이 없어 우리가 그만큼 많았다. - order_total: 판매가 합계 − 품목 상품추가할인 + 배송비 − 할인 − 쿠폰 - order_total_now: 취소·반품 품목의 추가할인은 제외 - 대조 표: 상품구매금액을 추가할인 뺀 값으로 + 판매가 합계·추가할인 세부 줄 - 일별 비교에서 날짜를 눌러 연 대조 표에 붙여넣은 카페24 열과 열별 차이 표시 - 테스트 추가 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 27 ++++++++---- .../performance/tests/test_performance.py | 17 ++++++++ app/static/performance.js | 42 ++++++++++++------- docs/PERFORMANCE_MODULE.md | 4 ++ 4 files changed, 68 insertions(+), 22 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index e8acc3a..85ef0ad 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -8,6 +8,8 @@ 카페24 관리자 "일별 매출내역"과 같은 기준으로 센다(Admin API 문서 2026-09-01 확인). - 결제합계(SALE, +): GET /admin/orders date_type=pay_date(결제일), 결제된(paid=T) 주문마다 상품구매금액 + 배송비 − 할인 − 쿠폰 (주문의 initial_order_amount — 결제 당시 금액) + 카페24 화면의 상품구매금액은 품목의 상품추가할인(items[].additional_discount_price)을 뺀 값이다 — + initial_order_amount 에는 이 할인이 없어 품목에서 더해 뺀다(실데이터: 상품구매금액이 100원 단위가 아닌 날만 차이). 환불은 따로 빼므로 취소 후 금액(actual_order_amount)이 아니라 결제 당시 금액을 쓴다. - 환불합계(CANCEL/RETURN, −): GET /admin/refunds date_type=refund_date(환불완료일), 실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소. @@ -132,16 +134,23 @@ def _day(value: Any) -> date | None: return None +def item_additional_discount(order: dict[str, Any], *, active_only: bool = False) -> int: + """품목 상품추가할인 합계(items[].additional_discount_price, 품목 줄 금액). 주문 금액(initial/actual)에는 없다. + active_only 면 취소·반품된 품목은 빼고(현재 금액 계산용).""" + return sum(_won(i.get("additional_discount_price")) for i in order.get("items") or [] + if not (active_only and str(i.get("order_status") or "")[:1] in ("C", "R"))) + + def order_amounts(order: dict[str, Any]) -> dict[str, int]: - """결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위.""" + """결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위 + 품목 상품추가할인.""" a = order.get("initial_order_amount") or order.get("actual_order_amount") or {} - return {k: _won(a.get(k)) for k in AMOUNT_FIELDS} + return {**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "additional_discount_price": item_additional_discount(order)} def order_total(order: dict[str, Any]) -> int: - """결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰.""" + """결제합계 = 상품구매금액(− 품목 상품추가할인) + 배송비 − 할인 − 쿠폰.""" a = order_amounts(order) - return (a["order_price_amount"] + a["shipping_fee"] + return (a["order_price_amount"] - a["additional_discount_price"] + a["shipping_fee"] - sum(a[k] for k in DISCOUNT_FIELDS) - sum(a[k] for k in COUPON_FIELDS)) @@ -154,7 +163,7 @@ def order_total_now(order: dict[str, Any]) -> int: """취소·반품 반영 후 현재 결제합계(actual_order_amount). 없으면 결제 당시 금액.""" a = order.get("actual_order_amount") or order.get("initial_order_amount") or {} w = {k: _won(a.get(k)) for k in AMOUNT_FIELDS} - return (w["order_price_amount"] + w["shipping_fee"] + return (w["order_price_amount"] - item_additional_discount(order, active_only=True) + w["shipping_fee"] - sum(w[k] for k in DISCOUNT_FIELDS) - sum(w[k] for k in COUPON_FIELDS)) @@ -416,7 +425,8 @@ class Cafe24Adapter(MarketplaceAdapter): order_date=_day(order.get("order_date")), payment_date=pay_day, event_date=pay_day, amount=max(0, order_total(order)), product_name=name, quantity=sum(int(i.get("quantity") or 0) for i in items), order_status="결제완료", - discount_amount=sum(order_amounts(order)[k] for k in DISCOUNT_FIELDS + COUPON_FIELDS), + discount_amount=sum(order_amounts(order)[k] + for k in ("additional_discount_price", *DISCOUNT_FIELDS, *COUPON_FIELDS)), raw={"order_id": oid, "market_id": order.get("market_id"), "order_place_id": order.get("order_place_id"), "items": len(items), **{f"initial_{k}": v for k, v in order_amounts(order).items()}}, )] @@ -471,7 +481,8 @@ class Cafe24Adapter(MarketplaceAdapter): self.authenticate(ctx) def empty() -> dict[str, int]: - return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, "total": 0} + return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, + "additional_discount_price": 0, "total": 0} def channel(mid: Any, place: Any, place_name: Any = None) -> dict[str, Any]: """(market_id, 주문경로) 한 쌍 = 한 줄. self 안에도 PC쇼핑몰·모바일웹 경로가 섞여 있어 나눠 본다.""" @@ -669,5 +680,5 @@ class Cafe24Adapter(MarketplaceAdapter): for c in no_record], "reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True), "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), - "formula": "결제합계 = 상품구매금액 + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + + "formula": "결제합계 = 상품구매금액(− 품목 상품추가할인) + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index d8f7a8a..f989bd1 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -650,6 +650,23 @@ def test_cafe24_scope_and_replace_range(): ("naver", "direct-naver-1"), ("cafe24", "sample")}, got +def test_cafe24_item_additional_discount(): + """카페24 상품구매금액 = 판매가 합계 − 품목 상품추가할인(additional_discount_price). 주문 금액에는 없다. + 실데이터: 9/23 카페24 상품구매금액 1,860,738 — 판매가 합계 1,860,800 과 62원 차이.""" + from app.modules.performance.adapters.cafe24 import order_total, order_total_now + + o = _c24_order("A") # 50,000 + 3,000 − 1,000 − 5,000 + o["items"][0]["additional_discount_price"] = "38.00" + o["items"][1]["additional_discount_price"] = "24.00" + assert order_total(o) == 47_000 - 62 + ev = _FakeCafe24([]).normalize_order(o)[0] + assert ev.amount == 46_938 and ev.discount_amount == 62 + 1_000 + 5_000 + # 현재 금액: 취소된 품목의 추가할인은 빼지 않는다 + o["actual_order_amount"] = dict(o["initial_order_amount"]) + o["items"][1]["order_status"] = "C40" + assert order_total_now(o) == 47_000 - 38 + + def test_daily_check_db_vs_live(): """일별 비교: 저장값(카페24 경유 다른 마켓 열 포함) + 지금 API 값(저장 안 함).""" import app.modules.performance.sync as syncmod diff --git a/app/static/performance.js b/app/static/performance.js index 13e1d8a..811c1bc 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -474,6 +474,7 @@ } // ── 카페24 매출 대조 — 카페24 "일별 매출내역" 열 순서대로 ── + let lastShop = {}; // 일별 비교에 붙여넣은 카페24 값(날짜 → 열) — 대조 표에 차이 열로 표시 const recon = document.getElementById("perf-recon"); if (recon) recon.addEventListener("click", async function () { const day = document.getElementById("perf-recon-date").value; @@ -497,34 +498,46 @@ coupon_discount_price: "상품쿠폰", coupon_shipping_fee_amount: "배송비쿠폰", }; const sum = function (g, keys) { return keys.reduce(function (a, k) { return a + (g[k] || 0); }, 0); }; + // x[4] = 붙여넣은 카페24 일별 매출내역 열 번호(일별 비교에서 이 날짜를 눌렀을 때 차이 표시) const rows = [ - ["주문수", s.orders, m.orders, "cnt"], ["품목수(수량 합계)", s.items, m.items, "cnt"], ["품목수(품목 줄 수)", s.lines, m.lines, "cnt"], - ["상품구매금액", s.order_price_amount, m.order_price_amount], ["배송비", s.shipping_fee, m.shipping_fee], - ["할인 합계", sum(s, disc), sum(m, disc)], + ["주문수", s.orders, m.orders, "cnt", 0], ["품목수(수량 합계)", s.items, m.items, "cnt", 1], ["품목수(품목 줄 수)", s.lines, m.lines, "cnt", 1], + ["상품구매금액(− 상품추가할인)", s.order_price_amount - s.additional_discount_price, m.order_price_amount - m.additional_discount_price, "", 2], + [" · 판매가 합계", s.order_price_amount, m.order_price_amount, "sub"], + [" · 상품추가할인(품목)", s.additional_discount_price, m.additional_discount_price, "sub"], + ["배송비", s.shipping_fee, m.shipping_fee, "", 3], + ["할인 합계", sum(s, disc), sum(m, disc), "", 4], ].concat(disc.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) - .concat([["쿠폰 합계", sum(s, coup), sum(m, coup)]]) + .concat([["쿠폰 합계", sum(s, coup), sum(m, coup), "", 5]]) .concat(coup.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) .concat([ - ["결제합계(계산)", s.total, m.total, "key"], - [" 참고: 실결제금액", s.payment_amount, m.payment_amount, "sub"], - [" 참고: 적립금 사용", s.points_spent_amount, m.points_spent_amount, "sub"], - [" 참고: 예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "sub"], + ["결제합계(계산)", s.total, m.total, "key", 10], + [" 참고: 실결제금액", s.payment_amount, m.payment_amount, "sub", 6], + [" 참고: 적립금 사용", s.points_spent_amount, m.points_spent_amount, "sub", 7], + [" 참고: 예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "sub", 8], ["환불 건수(환불 목록)", rs.count, rm.count, "cnt"], [" · 실제 환불액", rs.actual_refund_amount, rm.actual_refund_amount, "sub"], [" · 적립금 환불", rs.used_points, rm.used_points, "sub"], [" · 예치금 환불", rs.used_credits, rm.used_credits, "sub"], ["환불 목록 없는 취소·반품 품목 수(네이버페이 등)", rs.no_record_count, rm.no_record_count, "cnt"], [" · 취소·반품 금액", rs.no_record, rm.no_record, "sub"], - ["환불합계", rs.total, rm.total, "key"], - ["순매출(결제합계 − 환불합계)", s.total - rs.total, m.total - rm.total, "key"], + ["환불합계", rs.total, rm.total, "key", 11], + ["순매출(결제합계 − 환불합계)", s.total - rs.total, m.total - rm.total, "key", 12], ]); + const shopCols = (lastShop[r.date] || {}).cols || null; out.innerHTML = '" + + "" + + (shopCols ? "" : "") + "" + rows.map(function (x) { const cls = x[3] === "key" ? ' class="perf-row-week"' : ""; const f = function (v) { return x[3] === "cnt" ? fmt(v) : won(v); }; + let cmp = ""; + if (shopCols) { + const both = (x[1] || 0) + (x[2] || 0), c = x[4] == null ? null : shopCols[x[4]]; + cmp = '"; + } return ""; + '" + cmp + ""; }).join("") + "
' + esc(r.date) + - "카페24 열(자체몰 채널)다른 쇼핑몰 열(외부 마켓)
카페24 열(자체몰 채널)다른 쇼핑몰 열(외부 마켓)합계카페24 화면차이
' + f(both) + '' + (c == null ? "" : f(c)) + '' + + (c == null ? "" : both === c ? '✓' : '' + (both > c ? "+" : "") + fmt(both - c) + "") + "' + esc(x[0]) + - '' + f(x[1]) + '' + f(x[2]) + "
' + f(x[1]) + '' + f(x[2]) + "
" + (r.refund_basis ? (function () { @@ -674,14 +687,15 @@ .map(function (x) { return parseInt(x.replace(/,/g, ""), 10); }); if (nums.length < 3) return; const n = nums.length; - out[m[1] + "-" + m[2] + "-" + m[3]] = { orders: n >= 13 ? nums[0] : null, paid: nums[n - 3], refund: nums[n - 2], net: nums[n - 1] }; + out[m[1] + "-" + m[2] + "-" + m[3]] = { orders: n >= 13 ? nums[0] : null, paid: nums[n - 3], refund: nums[n - 2], net: nums[n - 1], + cols: n >= 13 ? nums.slice(n - 13) : null }; }); return out; } const dailyBtn = document.getElementById("perf-daily-check"); if (dailyBtn) dailyBtn.addEventListener("click", async function () { const out = document.getElementById("perf-daily-result"); - const shop = parseDaily(document.getElementById("perf-daily-paste").value); + const shop = lastShop = parseDaily(document.getElementById("perf-daily-paste").value); const dates = Object.keys(shop).sort(); if (!dates.length) { out.innerHTML = '

날짜가 있는 줄을 찾지 못했습니다. 카페24 일별 매출내역 표를 복사해 붙여 넣으세요.

'; return; } const live = document.getElementById("perf-daily-live").checked; diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 0da9a2b..2ed7765 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -71,6 +71,10 @@ 매출내역 표를 붙여 넣으면(날짜 + 뒤 세 숫자 = 결제합계·환불합계·순매출, 첫 숫자 = 주문수) 날짜마다 저장값(`c24:` 사건 전체, 다른 마켓 열 포함)과 지금 API·현재 규칙으로 다시 계산한 값(`adapter.collect`, 저장 안 함)을 비교한다. 저장값만 틀림 → 예전 규칙으로 받은 것([다시 가져오기] 버튼), API 값도 틀림 → 규칙 차이(결제/환불) → 날짜 클릭으로 그날 대조. + 날짜를 눌러 연 대조 표에는 붙여넣은 카페24 열(주문수·품목수·상품구매금액·배송비·할인·쿠폰·실결제·적립금·예치금·결제·환불·순매출)과 + 열별 차이가 같이 나온다. +- 결제합계의 상품구매금액 = 판매가 합계 − **품목 상품추가할인**(`items[].additional_discount_price`). 주문 금액(initial_order_amount)에는 + 이 할인이 없다(2026-09 실데이터: 카페24 상품구매금액이 100원 단위가 아닌 날만 결제합계가 그만큼 많았음, 예 9/23 +62). ### 연동 단계 체크리스트(쇼핑몰마다) From 20d19792dd67a11c14b3dd6e57c7b9f380a21c50 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 21:49:12 +0900 Subject: [PATCH 17/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=8C=80=EC=A1=B0=EC=97=90=20=EC=9B=90=EB=B3=B8=20=EA=B8=88?= =?UTF-8?q?=EC=95=A1=20=ED=95=84=EB=93=9C=20=ED=95=A9=EA=B3=84=20=EC=A7=84?= =?UTF-8?q?=EB=8B=A8=20+=20=EC=9D=B4=EC=83=81=20=EC=A3=BC=EB=AC=B8=20?= =?UTF-8?q?=EB=AA=A9=EB=A1=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 품목 상품추가할인(additional_discount_price)을 빼도록 바꿨는데도 일별 비교 결과가 그대로(+62, +260 …)라, 카페24 상품구매금액과의 차이가 어느 원본 필드에 있는지 추측하지 않고 찾기 위해: - reconcile 결과에 diag: 그날 결제 주문 전체의 금액성 숫자 필드 합계 (initial_order_amount / actual_order_amount / items / 주문 최상위). 이름에 price·amount·discount·point·fee 등이 들어간 필드만 — 계좌·연락처 제외 - odd_orders: 상품금액이 100원 단위가 아니거나 판매가×수량 합과 다른 주문(최대 60건) + 품목의 0 아닌 금액 필드 - 화면: 판매가 합계 − 카페24 상품구매금액 = 찾는 금액, 같은 값 필드 강조 - performance.js 캐시 버전 올림(이전 커밋에서 빠짐) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 53 +++++++++++++++++++ .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 18 +++++++ app/static/performance.js | 31 +++++++++++ 5 files changed, 104 insertions(+), 2 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 85ef0ad..e8ce8b0 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -172,6 +172,38 @@ def is_self_market(market_id: Any) -> bool: return channel_kind(market_id) == "self" +# 대조 진단 — 이름에 이 말이 들어간 숫자 필드만 합산(계좌·연락처 같은 개인정보 숫자는 이름이 달라 제외) +DIAG_WORDS = ("price", "amount", "discount", "point", "fee", "credit", "mileage", "sale", "benefit", "incentive", "coupon") + + +def _num(value: Any) -> Decimal | None: + if isinstance(value, bool) or value is None: + return None + try: + d = Decimal(str(value).strip()) + except (InvalidOperation, ValueError): + return None + return d if d.is_finite() else None + + +def money_fields(obj: Any) -> dict[str, int]: + """dict 의 금액성 숫자 필드(이름에 DIAG_WORDS) → 원 단위. 중첩은 한 단계까지 "부모.자식".""" + out: dict[str, int] = {} + if not isinstance(obj, dict): + return out + for k, v in obj.items(): + if isinstance(v, dict): + for k2, v2 in money_fields(v).items(): + out[f"{k}.{k2}"] = v2 + continue + if not any(w in str(k).lower() for w in DIAG_WORDS): + continue + n = _num(v) + if n is not None: + out[str(k)] = int(n.quantize(Decimal(1), rounding=ROUND_HALF_UP)) + return out + + def _chunks(start: date, end: date) -> Iterable[tuple[date, date]]: s = start while s <= end: @@ -504,10 +536,30 @@ class Cafe24Adapter(MarketplaceAdapter): unpaid = 0 paid_self: dict[str, int] = {} # 그날 결제된 카페24 열 주문 → (결제 당시 − 현재) 금액 reduced: dict[str, dict[str, Any]] = {} # 그중 금액이 줄어든 주문(취소·반품) — 환불 기록과 대조 + # 진단 — 어떤 원본 필드가 카페24 화면 열과 맞는지 찾는 용도(결제 주문 전체, 개인정보 제외) + diag = {"order": {}, "initial": {}, "actual": {}, "item": {}} + odd: list[dict[str, Any]] = [] # 판매가×수량 합이 주문 상품금액과 다르거나 100원 단위가 아닌 주문 for o in self.paid_orders(ctx, day, day): if o.get("paid") != "T": unpaid += 1 continue + for part, src in (("order", {k: v for k, v in o.items() if not isinstance(v, (dict, list))}), + ("initial", o.get("initial_order_amount")), ("actual", o.get("actual_order_amount"))): + for k, v in money_fields(src).items(): + diag[part][k] = diag[part].get(k, 0) + v + its = o.get("items") or [] + for i in its: + for k, v in money_fields(i).items(): + diag["item"][k] = diag["item"].get(k, 0) + v + gross = sum((_won(i.get("product_price")) + _won(i.get("option_price"))) * int(i.get("quantity") or 0) for i in its) + opa = order_amounts(o)["order_price_amount"] + if (gross != opa or opa % 100) and len(odd) < 60: + odd.append({"order_id": str(o.get("order_id") or ""), + "channel": str(o.get("order_place_name") or o.get("market_id") or ""), + "order_price_amount": opa, "items_gross": gross, "total": order_total(o), + "items": [{"code": str(i.get("order_item_code") or ""), "status": str(i.get("order_status") or ""), + "quantity": int(i.get("quantity") or 0), + "fields": {k: v for k, v in money_fields(i).items() if v}} for i in its]}) ch = channel(o.get("market_id"), o.get("order_place_id"), o.get("order_place_name")) total = order_total(o) ch["orders"] += 1 @@ -680,5 +732,6 @@ class Cafe24Adapter(MarketplaceAdapter): for c in no_record], "reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True), "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), + "diag": {part: dict(sorted(v.items())) for part, v in diag.items()}, "odd_orders": odd, "formula": "결제합계 = 상품구매금액(− 품목 상품추가할인) + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 4e803cd..d858243 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index cd9c2e9..28e5235 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index f989bd1..91c9c30 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -661,6 +661,24 @@ def test_cafe24_item_additional_discount(): assert order_total(o) == 47_000 - 62 ev = _FakeCafe24([]).normalize_order(o)[0] assert ev.amount == 46_938 and ev.discount_amount == 62 + 1_000 + 5_000 + # 대조 진단: 원본 금액 필드 합계 + 이상 주문(개인정보 숫자 필드는 제외) + import app.timezone as _tz + from app.modules.performance.adapters.base import AdapterContext + from app.modules.performance.adapters.cafe24 import money_fields + + assert money_fields({"bank_account_no": "1234567890", "order_price_amount": "100.50", "x": {"coupon_discount_price": 3}}) == {"order_price_amount": 101, "x.coupon_discount_price": 3} + o2 = _c24_order("B", price=10_050) + o2["items"] = [{"order_item_code": "B-01", "product_price": "10000.00", "option_price": "0", "quantity": 1, + "additional_discount_price": "0.00", "order_status": "N40"}] + orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29)) + try: + rec = _FakeCafe24([[o, o2]]).reconcile(AdapterContext(code="cafe24", credentials=None), date(2026, 9, 29)) + finally: + _tz.today_kst = orig + assert rec["diag"]["item"]["additional_discount_price"] == 62 + assert rec["diag"]["initial"]["order_price_amount"] == 60_050 and "bank_account_no" not in rec["diag"]["order"] + odd = {x["order_id"]: x for x in rec["odd_orders"]} + assert odd["B"]["items_gross"] == 10_000 and odd["B"]["order_price_amount"] == 10_050 # 현재 금액: 취소된 품목의 추가할인은 빼지 않는다 o["actual_order_amount"] = dict(o["initial_order_amount"]) o["items"][1]["order_status"] = "C40" diff --git a/app/static/performance.js b/app/static/performance.js index 811c1bc..9436234 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -658,6 +658,37 @@ }).join(""); })() + "" : "") + + (r.diag + ? (function () { + // 판매가 합계 − 카페24 상품구매금액 = 찾는 금액(예: 9/23 → 62). 같은 값인 필드를 강조. + const gap = shopCols ? (s.order_price_amount + m.order_price_amount) - shopCols[2] : null; + const PART = { initial: "주문 금액(결제 당시 initial_order_amount)", actual: "주문 금액(현재 actual_order_amount)", + item: "품목(items) 합계", order: "주문 최상위 필드" }; + const cells = ["initial", "actual", "item", "order"].map(function (p) { + const f = r.diag[p] || {}; + const keys = Object.keys(f).filter(function (k) { return f[k]; }); + return '
' + esc(PART[p]) + "
" + + (keys.length ? '' + keys.map(function (k) { + return ""; + }).join("") + "
' + esc(k) + + '' + fmt(f[k]) + "
" : '

0 아닌 값 없음

') + "
"; + }).join(""); + const odd = (r.odd_orders || []).map(function (o) { + return '' + esc(o.order_id) + "" + esc(o.channel || "–") + '' + + fmt(o.items_gross) + '' + fmt(o.order_price_amount) + '' + fmt(o.total) + + '' + o.items.map(function (i) { + return esc(i.code + " " + i.status + " ×" + i.quantity + " — " + + Object.keys(i.fields).map(function (k) { return k + "=" + fmt(i.fields[k]); }).join(", ")); + }).join("
") + ""; + }).join(""); + return '

원본 금액 필드 합계 (진단 — 그날 결제 주문 전체)' + + (gap ? ' · 판매가 합계 − 카페24 상품구매금액 = ' + fmt(gap) + " (같은 값 강조)" : "") + "

" + + '
' + cells + "
" + + (odd ? '

상품금액이 100원 단위가 아니거나 판매가×수량 합과 다른 주문

' + + '' + + '' + odd + "
주문번호채널판매가×수량주문 상품금액결제합계(계산)품목 금액 필드(0 제외)
" : ""); + })() + : "") + '

' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) + "건 제외. \"알 수 없는 채널\"은 카페24 열에 넣습니다 — 외부 마켓이면 어느 쇼핑몰인지 알려 주세요.

"; const target = document.getElementById("perf-recon-target"); From 398e5181fdd67b464dee2093ab01f0b7d86e4274 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 22:08:18 +0900 Subject: [PATCH 18/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EA=B2=B0=EC=A0=9C=ED=95=A9=EA=B3=84=20=3D=20=EC=8B=A4?= =?UTF-8?q?=EA=B2=B0=EC=A0=9C=20+=20=EC=A0=81=EB=A6=BD=EA=B8=88=20+=20?= =?UTF-8?q?=EC=98=88=EC=B9=98=EA=B8=88=20+=20=EB=84=A4=EC=9D=B4=EB=B2=84?= =?UTF-8?q?=ED=8F=AC=EC=9D=B8=ED=8A=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/23 대조 진단으로 확인: 카페24 일별 매출내역 결제합계 1,874,738 = 실결제 1,713,128(initial payment_amount) + 적립금 10,110 + 예치금 0 + 네이버포인트 151,500(주문 naver_point). "상품구매금액 + 배송비 − 할인 − 쿠폰"은 1,874,800 으로 할인 필드에 안 잡히는 차이(62원)가 남는다 — 카페24 화면의 상품구매금액은 결제 금액에서 거꾸로 맞춘 값. 상품추가할인은 0 이라 원인 아님. - order_total / order_total_now: 실결제 + 적립금 + 예치금 + 네이버포인트 (모두 0인 주문만 상품식) - 품목 상품추가할인 차감 제거(직전 커밋의 잘못된 추정) - 대조 표: 실결제·적립금·예치금·네이버포인트 줄을 카페24 열과 비교, 상품식은 참고 줄로 - 테스트 갱신 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 54 ++++++++++--------- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 29 +++++----- app/static/performance.js | 14 ++--- docs/PERFORMANCE_MODULE.md | 7 +-- 6 files changed, 56 insertions(+), 52 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index e8ce8b0..cab1d3c 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -7,9 +7,11 @@ 카페24 관리자 "일별 매출내역"과 같은 기준으로 센다(Admin API 문서 2026-09-01 확인). - 결제합계(SALE, +): GET /admin/orders date_type=pay_date(결제일), 결제된(paid=T) 주문마다 - 상품구매금액 + 배송비 − 할인 − 쿠폰 (주문의 initial_order_amount — 결제 당시 금액) - 카페24 화면의 상품구매금액은 품목의 상품추가할인(items[].additional_discount_price)을 뺀 값이다 — - initial_order_amount 에는 이 할인이 없어 품목에서 더해 뺀다(실데이터: 상품구매금액이 100원 단위가 아닌 날만 차이). + 실결제금액 + 적립금 + 예치금 + 네이버포인트 = 고객이 실제로 낸 금액 + (initial_order_amount 의 payment_amount·points_spent_amount·credits_spent_amount + 주문의 naver_point) + "상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이(수십~수만 원)가 생겨 쓰지 않는다 + (2026-09-23 실데이터: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식은 1,874,800). + 위 네 값이 모두 0인 주문(0원 결제 등)만 상품식으로 계산한다. 환불은 따로 빼므로 취소 후 금액(actual_order_amount)이 아니라 결제 당시 금액을 쓴다. - 환불합계(CANCEL/RETURN, −): GET /admin/refunds date_type=refund_date(환불완료일), 실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소. @@ -107,12 +109,13 @@ def target_code(market_id: Any, order_place_id: Any = None) -> str: return "cafe24" return MARKET_MAP.get(_key(market_id)) or MARKET_MAP[_key(order_place_id)] -# 결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰 (initial_order_amount 의 필드) +# 참고식(상품구매금액 + 배송비 − 할인 − 쿠폰)의 필드 — 결제합계는 PAID_FIELDS + naver_point 로 센다 DISCOUNT_FIELDS = ("membership_discount_amount", "set_product_discount_amount", "app_discount_amount", "market_other_discount_amount", "shipping_fee_discount_amount") COUPON_FIELDS = ("coupon_discount_price", "coupon_shipping_fee_amount") AMOUNT_FIELDS = ("order_price_amount", "shipping_fee", *DISCOUNT_FIELDS, *COUPON_FIELDS, "points_spent_amount", "credits_spent_amount", "payment_amount") +PAID_FIELDS = ("payment_amount", "points_spent_amount", "credits_spent_amount") def _won(value: Any) -> int: @@ -134,24 +137,27 @@ def _day(value: Any) -> date | None: return None -def item_additional_discount(order: dict[str, Any], *, active_only: bool = False) -> int: - """품목 상품추가할인 합계(items[].additional_discount_price, 품목 줄 금액). 주문 금액(initial/actual)에는 없다. - active_only 면 취소·반품된 품목은 빼고(현재 금액 계산용).""" - return sum(_won(i.get("additional_discount_price")) for i in order.get("items") or [] - if not (active_only and str(i.get("order_status") or "")[:1] in ("C", "R"))) - - def order_amounts(order: dict[str, Any]) -> dict[str, int]: - """결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위 + 품목 상품추가할인.""" + """결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위 + 네이버포인트(주문 필드).""" a = order.get("initial_order_amount") or order.get("actual_order_amount") or {} - return {**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "additional_discount_price": item_additional_discount(order)} + return {**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "naver_point": _won(order.get("naver_point"))} + + +def goods_total(w: dict[str, int]) -> int: + """참고식: 상품구매금액 + 배송비 − 할인 − 쿠폰.""" + return (w["order_price_amount"] + w["shipping_fee"] + - sum(w[k] for k in DISCOUNT_FIELDS) - sum(w[k] for k in COUPON_FIELDS)) + + +def _paid_total(w: dict[str, int]) -> int: + """결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트. 모두 0이면 참고식.""" + paid = sum(w[k] for k in PAID_FIELDS) + w["naver_point"] + return paid if paid > 0 else goods_total(w) def order_total(order: dict[str, Any]) -> int: - """결제합계 = 상품구매금액(− 품목 상품추가할인) + 배송비 − 할인 − 쿠폰.""" - a = order_amounts(order) - return (a["order_price_amount"] - a["additional_discount_price"] + a["shipping_fee"] - - sum(a[k] for k in DISCOUNT_FIELDS) - sum(a[k] for k in COUPON_FIELDS)) + """결제합계(결제 당시) — 카페24 일별 매출내역 결제합계와 같은 기준.""" + return _paid_total(order_amounts(order)) def refund_total(refund: dict[str, Any]) -> int: @@ -162,9 +168,7 @@ def refund_total(refund: dict[str, Any]) -> int: def order_total_now(order: dict[str, Any]) -> int: """취소·반품 반영 후 현재 결제합계(actual_order_amount). 없으면 결제 당시 금액.""" a = order.get("actual_order_amount") or order.get("initial_order_amount") or {} - w = {k: _won(a.get(k)) for k in AMOUNT_FIELDS} - return (w["order_price_amount"] - item_additional_discount(order, active_only=True) + w["shipping_fee"] - - sum(w[k] for k in DISCOUNT_FIELDS) - sum(w[k] for k in COUPON_FIELDS)) + return _paid_total({**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "naver_point": _won(order.get("naver_point"))}) def is_self_market(market_id: Any) -> bool: @@ -457,8 +461,7 @@ class Cafe24Adapter(MarketplaceAdapter): order_date=_day(order.get("order_date")), payment_date=pay_day, event_date=pay_day, amount=max(0, order_total(order)), product_name=name, quantity=sum(int(i.get("quantity") or 0) for i in items), order_status="결제완료", - discount_amount=sum(order_amounts(order)[k] - for k in ("additional_discount_price", *DISCOUNT_FIELDS, *COUPON_FIELDS)), + discount_amount=sum(order_amounts(order)[k] for k in DISCOUNT_FIELDS + COUPON_FIELDS), raw={"order_id": oid, "market_id": order.get("market_id"), "order_place_id": order.get("order_place_id"), "items": len(items), **{f"initial_{k}": v for k, v in order_amounts(order).items()}}, )] @@ -514,7 +517,7 @@ class Cafe24Adapter(MarketplaceAdapter): def empty() -> dict[str, int]: return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS}, - "additional_discount_price": 0, "total": 0} + "naver_point": 0, "goods_total": 0, "total": 0} def channel(mid: Any, place: Any, place_name: Any = None) -> dict[str, Any]: """(market_id, 주문경로) 한 쌍 = 한 줄. self 안에도 PC쇼핑몰·모바일웹 경로가 섞여 있어 나눠 본다.""" @@ -582,6 +585,7 @@ class Cafe24Adapter(MarketplaceAdapter): g["lines"] += len(o.get("items") or []) for k, v in order_amounts(o).items(): g[k] += v + g["goods_total"] += goods_total(order_amounts(o)) g["total"] += order_total(o) if ch["target"] == "cafe24": oid_ = str(o.get("order_id") or "") @@ -733,5 +737,5 @@ class Cafe24Adapter(MarketplaceAdapter): "reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True), "by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True), "diag": {part: dict(sorted(v.items())) for part, v in diag.items()}, "odd_orders": odd, - "formula": "결제합계 = 상품구매금액(− 품목 상품추가할인) + 배송비 − 할인(" + ", ".join(DISCOUNT_FIELDS) + - ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} + "formula": "결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트(결제 당시). 참고식 = 상품구매금액 + 배송비 − 할인(" + + ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index d858243..e752247 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 28e5235..7dee1f8 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 91c9c30..f2f275c 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -650,39 +650,38 @@ def test_cafe24_scope_and_replace_range(): ("naver", "direct-naver-1"), ("cafe24", "sample")}, got -def test_cafe24_item_additional_discount(): - """카페24 상품구매금액 = 판매가 합계 − 품목 상품추가할인(additional_discount_price). 주문 금액에는 없다. - 실데이터: 9/23 카페24 상품구매금액 1,860,738 — 판매가 합계 1,860,800 과 62원 차이.""" +def test_cafe24_paid_total_matches_daily_report(): + """카페24 결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트(결제 당시). 상품식과 다를 수 있다. + 실데이터 9/23: 1,713,128 + 10,110 + 0 + 151,500 = 1,874,738 (상품식 1,874,800).""" from app.modules.performance.adapters.cafe24 import order_total, order_total_now - o = _c24_order("A") # 50,000 + 3,000 − 1,000 − 5,000 - o["items"][0]["additional_discount_price"] = "38.00" - o["items"][1]["additional_discount_price"] = "24.00" - assert order_total(o) == 47_000 - 62 + o = _c24_order("A", naver_point="3000.00") # 상품식 50,000 + 3,000 − 1,000 − 5,000 = 47,000 + o["initial_order_amount"].update(payment_amount="42938.00", points_spent_amount="1000.00") + assert order_total(o) == 42_938 + 1_000 + 3_000 == 46_938 ev = _FakeCafe24([]).normalize_order(o)[0] - assert ev.amount == 46_938 and ev.discount_amount == 62 + 1_000 + 5_000 + assert ev.amount == 46_938 and ev.discount_amount == 1_000 + 5_000 + o["actual_order_amount"] = {**o["initial_order_amount"], "payment_amount": "20000.00"} + assert order_total_now(o) == 20_000 + 1_000 + 3_000 + assert order_total(_c24_order("Z")) == 47_000 # 결제 필드가 모두 0이면 상품식 # 대조 진단: 원본 금액 필드 합계 + 이상 주문(개인정보 숫자 필드는 제외) import app.timezone as _tz from app.modules.performance.adapters.base import AdapterContext from app.modules.performance.adapters.cafe24 import money_fields - assert money_fields({"bank_account_no": "1234567890", "order_price_amount": "100.50", "x": {"coupon_discount_price": 3}}) == {"order_price_amount": 101, "x.coupon_discount_price": 3} + got = money_fields({"bank_account_no": "1234567890", "order_price_amount": "100.50", "x": {"coupon_discount_price": 3}}) + assert got == {"order_price_amount": 101, "x.coupon_discount_price": 3} o2 = _c24_order("B", price=10_050) o2["items"] = [{"order_item_code": "B-01", "product_price": "10000.00", "option_price": "0", "quantity": 1, - "additional_discount_price": "0.00", "order_status": "N40"}] + "order_status": "N40"}] orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29)) try: rec = _FakeCafe24([[o, o2]]).reconcile(AdapterContext(code="cafe24", credentials=None), date(2026, 9, 29)) finally: _tz.today_kst = orig - assert rec["diag"]["item"]["additional_discount_price"] == 62 + assert rec["diag"]["order"]["naver_point"] == 3_000 assert rec["diag"]["initial"]["order_price_amount"] == 60_050 and "bank_account_no" not in rec["diag"]["order"] odd = {x["order_id"]: x for x in rec["odd_orders"]} assert odd["B"]["items_gross"] == 10_000 and odd["B"]["order_price_amount"] == 10_050 - # 현재 금액: 취소된 품목의 추가할인은 빼지 않는다 - o["actual_order_amount"] = dict(o["initial_order_amount"]) - o["items"][1]["order_status"] = "C40" - assert order_total_now(o) == 47_000 - 38 def test_daily_check_db_vs_live(): diff --git a/app/static/performance.js b/app/static/performance.js index 9436234..49d8aed 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -501,19 +501,19 @@ // x[4] = 붙여넣은 카페24 일별 매출내역 열 번호(일별 비교에서 이 날짜를 눌렀을 때 차이 표시) const rows = [ ["주문수", s.orders, m.orders, "cnt", 0], ["품목수(수량 합계)", s.items, m.items, "cnt", 1], ["품목수(품목 줄 수)", s.lines, m.lines, "cnt", 1], - ["상품구매금액(− 상품추가할인)", s.order_price_amount - s.additional_discount_price, m.order_price_amount - m.additional_discount_price, "", 2], - [" · 판매가 합계", s.order_price_amount, m.order_price_amount, "sub"], - [" · 상품추가할인(품목)", s.additional_discount_price, m.additional_discount_price, "sub"], + ["상품구매금액", s.order_price_amount, m.order_price_amount, "", 2], ["배송비", s.shipping_fee, m.shipping_fee, "", 3], ["할인 합계", sum(s, disc), sum(m, disc), "", 4], ].concat(disc.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) .concat([["쿠폰 합계", sum(s, coup), sum(m, coup), "", 5]]) .concat(coup.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; })) .concat([ - ["결제합계(계산)", s.total, m.total, "key", 10], - [" 참고: 실결제금액", s.payment_amount, m.payment_amount, "sub", 6], - [" 참고: 적립금 사용", s.points_spent_amount, m.points_spent_amount, "sub", 7], - [" 참고: 예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "sub", 8], + [" 참고식: 상품구매금액 + 배송비 − 할인 − 쿠폰", s.goods_total, m.goods_total, "sub"], + ["실결제금액", s.payment_amount, m.payment_amount, "", 6], + ["적립금 사용", s.points_spent_amount, m.points_spent_amount, "", 7], + ["예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "", 8], + ["네이버포인트", s.naver_point, m.naver_point, "", 9], + ["결제합계(실결제 + 적립금 + 예치금 + 네이버포인트)", s.total, m.total, "key", 10], ["환불 건수(환불 목록)", rs.count, rm.count, "cnt"], [" · 실제 환불액", rs.actual_refund_amount, rm.actual_refund_amount, "sub"], [" · 적립금 환불", rs.used_points, rm.used_points, "sub"], diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 2ed7765..55510fc 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -42,7 +42,7 @@ | 사건 | 조회 | 금액·날짜 | |---|---|---| -| SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(상품구매금액 + 배송비 − 할인 − 쿠폰), `initial_order_amount`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) | +| SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(실결제금액 + 적립금 + 예치금 + 네이버포인트), `initial_order_amount` + 주문 `naver_point`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) | | CANCEL / RETURN(환불합계) | `GET /admin/refunds` `date_type=refund_date`, `status=T` | −(실제 환불액 + 적립금·예치금 환불), 환불완료일. 환불코드 R… = 반품, 그 밖 = 취소. 사건 ID = 환불코드 | | CANCEL / RETURN(환불 목록 없는 취소·반품) | `GET /admin/orders` `date_type=cancel_date|return_complete_date`, `embed=items` — 품목 상태 C40~43/R40~43 이고 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 없을 때 | −(판매가+옵션)×수량 − 품목 할인·쿠폰, 품목 취소일(반품은 반품완료일). 네이버페이 취소가 여기 해당 (네이버가 환불해 카페24 환불 목록에 없음). 사건 ID = `c24:{품목코드}-CL` (`unrefunded_claims`) | @@ -73,8 +73,9 @@ 저장값만 틀림 → 예전 규칙으로 받은 것([다시 가져오기] 버튼), API 값도 틀림 → 규칙 차이(결제/환불) → 날짜 클릭으로 그날 대조. 날짜를 눌러 연 대조 표에는 붙여넣은 카페24 열(주문수·품목수·상품구매금액·배송비·할인·쿠폰·실결제·적립금·예치금·결제·환불·순매출)과 열별 차이가 같이 나온다. -- 결제합계의 상품구매금액 = 판매가 합계 − **품목 상품추가할인**(`items[].additional_discount_price`). 주문 금액(initial_order_amount)에는 - 이 할인이 없다(2026-09 실데이터: 카페24 상품구매금액이 100원 단위가 아닌 날만 결제합계가 그만큼 많았음, 예 9/23 +62). +- **결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트**(initial_order_amount 의 payment_amount·points_spent_amount· + credits_spent_amount + 주문의 naver_point). "상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이가 있어 쓰지 않음 + (2026-09-23: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식 1,874,800). 네 값이 모두 0인 주문만 상품식. ### 연동 단계 체크리스트(쇼핑몰마다) From 2f86445077e3a55d4bad446cc4d27d6aed85fbeb Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 22:53:43 +0900 Subject: [PATCH 19/30] =?UTF-8?q?feat(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=8C=80=EC=A1=B0=EC=97=90=20=ED=99=98=EB=B6=88=20=EB=AA=A9?= =?UTF-8?q?=EB=A1=9D=20=EC=97=86=EB=8A=94=20=EC=B7=A8=EC=86=8C=C2=B7?= =?UTF-8?q?=EB=B0=98=ED=92=88=20=EA=B1=B4=EB=B3=84=20=ED=91=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 결제합계 공식 교체 후 남은 차이는 결제 2일(9/25 +9,900, 9/11 +24,900)과 환불 5일(9/21·9/16 +9,900, 9/11 +26,400, 9/14 −7,000, 9/4 −3,500). −3,500/−7,000 은 환불 목록에 없는 취소(네이버페이 등)의 배송비 환불을 안 넣은 것으로 보여, 그 건들을 건별로(뺀 금액·품목 결제금액·쿠폰·주문 전체취소 여부· 주문 배송비) 표시한다. Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 6 ++++++ .../performance/templates/performance/index.html | 2 +- .../performance/templates/performance/settings.html | 2 +- app/static/performance.js | 13 +++++++++++++ 4 files changed, 21 insertions(+), 2 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index cab1d3c..418f2b2 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -402,6 +402,12 @@ class Cafe24Adapter(MarketplaceAdapter): "quantity": qty, "amount": max(0, amount), "product_name": str(i.get("product_name") or "")[:40], "naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""), + # 대조용 — 주문 전체가 취소·반품됐는지, 그 주문 배송비(배송비 환불 여부 확인) + "order_all_claimed": all(str(x.get("order_status") or "") in NO_RECORD_DONE + for x in o.get("items") or []), + "order_shipping_fee": order_amounts(o)["shipping_fee"], + "item_payment_amount": _won(i.get("payment_amount")), + "coupon": _won(i.get("coupon_discount_price")), } if not found: return [] diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index e752247..7b20b56 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 7dee1f8..bd4f88e 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/static/performance.js b/app/static/performance.js index 49d8aed..bef7b38 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -582,6 +582,19 @@ '' + won(x.used_points + x.used_credits) + "" + esc((x.methods || []).join(", ") || "–") + ""; }).join("") + "" : "") + + ((r.no_record_claims || []).length + ? '

환불 목록에 없는 취소·반품 (환불합계에 넣은 건 — 네이버페이 등)

' + + '' + + '' + + "" + + r.no_record_claims.map(function (c) { + return '"; + }).join("") + "
주문번호품목채널상태반영일상품수량뺀 금액품목 결제금액쿠폰주문 전체취소주문 배송비
' + esc(c.order_id) + "" + esc(c.item_code) + "" + esc(c.place_name || c.market_id || "–") + + "" + esc(c.status + (c.naver_pay_claim_status ? " / 네이버페이 " + c.naver_pay_claim_status : "")) + "" + esc(c.day) + + "" + esc(c.product_name) + '' + fmt(c.quantity) + '' + won(c.amount) + + '' + won(c.item_payment_amount) + '' + won(c.coupon) + "" + + (c.order_all_claimed ? "예" : "아니오") + '' + won(c.order_shipping_fee) + "
" + : "") + ((r.reduced_orders || []).length ? '

그날 결제한 주문 중 금액이 줄어든 주문 (취소·반품) — "환불 기록 없음"이 환불 API 에 안 잡힌 건

' + '' + From 643ff25f2787967d5c4038e3b446b05b09f413e9 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 23:03:50 +0900 Subject: [PATCH 20/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=ED=99=98=EB=B6=88=20=E2=80=94=20=EB=84=A4=EC=9D=B4=EB=B2=84?= =?UTF-8?q?=ED=8E=98=EC=9D=B4=EB=A7=8C=C2=B7=EC=A0=84=EC=B2=B4=EC=B7=A8?= =?UTF-8?q?=EC=86=8C=20=EB=B0=B0=EC=86=A1=EB=B9=84=20=ED=8F=AC=ED=95=A8,?= =?UTF-8?q?=200=EC=9B=90=20=EA=B2=B0=EC=A0=9C=20=EC=A3=BC=EB=AC=B8?= =?UTF-8?q?=EC=9D=80=200=EC=9B=90?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/4·9/16·9/25 대조 결과: - 9/4 환불 122,100 = 환불 목록 98,700 + 네이버페이 취소 19,900 + 그 주문 배송비 3,500 (주문 전체취소) — 우리는 배송비를 빠뜨려 −3,500 (9/14 −7,000 도 같은 유형) - 9/16 환불 201,100 = 환불 목록 그대로 — 우리가 더 뺀 9,900 은 톡체크아웃 (KAKAOPAY) 환불 기록 없는 취소. 카페24 는 네이버페이만 센다 (9/21 도 같은 유형) - 9/25 결제: 실결제·적립금·네이버포인트는 카페24 와 같은데 합계만 +9,900 — 네 값이 모두 0인 주문(가상계좌·휴대폰 9,900)을 상품식으로 넣었기 때문. 카페24 는 0원 (9/11 +24,900 도 같은 유형) - unrefunded_claims: 네이버페이(NCHECKOUT) 주문만, 주문 전체가 취소·반품되면 배송비(− 배송비 할인·쿠폰)를 마지막 클레임 품목에 한 번 더함 - _paid_total: 상품식 대체 제거 - 대조 표에 품목별 배송비 포함액 표시, 테스트 갱신 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 52 ++++++++++++------- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 37 ++++++++----- app/static/performance.js | 5 +- docs/PERFORMANCE_MODULE.md | 6 ++- 6 files changed, 69 insertions(+), 35 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 418f2b2..4cedf98 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -11,7 +11,7 @@ (initial_order_amount 의 payment_amount·points_spent_amount·credits_spent_amount + 주문의 naver_point) "상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이(수십~수만 원)가 생겨 쓰지 않는다 (2026-09-23 실데이터: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식은 1,874,800). - 위 네 값이 모두 0인 주문(0원 결제 등)만 상품식으로 계산한다. + 네 값이 모두 0인 주문도 0원(카페24와 같음). 환불은 따로 빼므로 취소 후 금액(actual_order_amount)이 아니라 결제 당시 금액을 쓴다. - 환불합계(CANCEL/RETURN, −): GET /admin/refunds date_type=refund_date(환불완료일), 실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소. @@ -62,6 +62,7 @@ UNPAID_CANCEL = frozenset({"C47", "C48", "C49"}) # 환불 목록(/admin/refunds)에 없는 취소·반품(네이버페이 등) — 카페24 일별 매출 환불합계에는 들어간다(실데이터 확인) NO_RECORD_DATE_TYPES = ("cancel_date", "return_complete_date") NO_RECORD_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43"}) +NO_RECORD_CHANNEL = "ncheckout" # 네이버페이만 — 톡체크아웃·자체몰의 환불 기록 없는 취소는 카페24 환불합계에 없다 REFUND_LOOKAROUND_DAYS = 60 # 카페24 자체몰 주문 채널 — market_id 는 외부 마켓만이 아니라 주문 채널·간편결제도 담는다 @@ -150,9 +151,9 @@ def goods_total(w: dict[str, int]) -> int: def _paid_total(w: dict[str, int]) -> int: - """결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트. 모두 0이면 참고식.""" - paid = sum(w[k] for k in PAID_FIELDS) + w["naver_point"] - return paid if paid > 0 else goods_total(w) + """결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트. 넷 다 0인 주문은 카페24도 0원으로 센다 + (9/25 가상계좌·휴대폰 9,900 주문 — 상품식으로 넣으면 그만큼 많아짐).""" + return sum(w[k] for k in PAID_FIELDS) + w["naver_point"] def order_total(order: dict[str, Any]) -> int: @@ -369,9 +370,12 @@ class Cafe24Adapter(MarketplaceAdapter): return {"items": items, "errors": errors, "full_cancel_shipping": full_cancel_shipping} def unrefunded_claims(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]: - """환불 목록에 기록이 없는 취소·반품 완료 품목(네이버페이 취소 등). 날짜 = 품목 취소일(반품은 반품완료일). - 금액 = 판매가(+옵션)×수량 − 품목 할인·쿠폰. 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 있으면 제외해 - 환불 목록 쪽과 두 번 빼지 않는다.""" + """환불 목록에 기록이 없는 네이버페이 취소·반품 완료 품목. 날짜 = 품목 취소일(반품은 반품완료일). + 금액 = 판매가(+옵션)×수량 − 품목 할인·쿠폰. 주문 전체가 취소·반품되면 배송비(− 배송비 할인·쿠폰)도 환불로 + 보고 그 주문의 마지막 클레임 품목에 한 번 더한다. 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 있으면 + 제외해 환불 목록 쪽과 두 번 빼지 않는다. + 카페24 일별 매출 환불합계와 대조한 결과(2026-09): 네이버페이만 센다 — 톡체크아웃(KAKAOPAY)·자체몰의 + 환불 기록 없는 취소는 넣지 않는다(9/16 톡체크아웃 취소 9,900 제외, 9/4 네이버페이 전체취소 배송비 3,500 포함).""" from app.timezone import today_kst # noqa: WPS433 found: dict[str, dict[str, Any]] = {} @@ -380,32 +384,44 @@ class Cafe24Adapter(MarketplaceAdapter): for o in self._paged(ctx, "/admin/orders", "orders", {"start_date": s.isoformat(), "end_date": e.isoformat(), "date_type": date_type, "embed": "items"}, ORDER_LIMIT): + if NO_RECORD_CHANNEL not in (_key(o.get("market_id")), _key(o.get("order_place_id"))): + continue oid = str(o.get("order_id") or "") - for i in o.get("items") or []: + its = o.get("items") or [] + claimed: list[tuple[date, str, dict[str, Any]]] = [] + for i in its: status = str(i.get("order_status") or "") if status not in NO_RECORD_DONE: continue keys = (("cancel_date", "refund_date", "return_confirmed_date") if status[:1] == "C" else ("return_confirmed_date", "refund_date", "cancel_date")) day = next((d for d in (_day(i.get(k)) for k in keys) if d), None) - if day is None or not (start <= day <= end): + if day is not None: + claimed.append((day, str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}"), i)) + if not claimed: + continue + all_claimed = len(claimed) == len(its) + w = order_amounts(o) + ship = max(0, w["shipping_fee"] - w["coupon_shipping_fee_amount"] - w["shipping_fee_discount_amount"]) + last = max((d, k) for d, k, _ in claimed) + for day, key, i in claimed: + if not (start <= day <= end): continue - key = str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}") + status = str(i.get("order_status") or "") qty = int(i.get("quantity") or 0) - amount = ((_won(i.get("product_price")) + _won(i.get("option_price"))) * qty - - _won(i.get("additional_discount_price")) - _won(i.get("coupon_discount_price")) - - _won(i.get("app_item_discount_amount"))) + amount = max(0, (_won(i.get("product_price")) + _won(i.get("option_price"))) * qty + - _won(i.get("additional_discount_price")) - _won(i.get("coupon_discount_price")) + - _won(i.get("app_item_discount_amount"))) + ship_refund = ship if all_claimed and (day, key) == last else 0 found[key] = { "order_id": oid, "item_code": key, "status": status, "day": day, "market_id": o.get("market_id"), "place_id": o.get("order_place_id"), "place_name": o.get("order_place_name"), "order_date": _day(o.get("order_date")), - "quantity": qty, "amount": max(0, amount), + "quantity": qty, "amount": amount + ship_refund, "shipping_refund": ship_refund, "product_name": str(i.get("product_name") or "")[:40], "naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""), - # 대조용 — 주문 전체가 취소·반품됐는지, 그 주문 배송비(배송비 환불 여부 확인) - "order_all_claimed": all(str(x.get("order_status") or "") in NO_RECORD_DONE - for x in o.get("items") or []), - "order_shipping_fee": order_amounts(o)["shipping_fee"], + # 대조용 — 주문 전체가 취소·반품됐는지, 그 주문 배송비 + "order_all_claimed": all_claimed, "order_shipping_fee": w["shipping_fee"], "item_payment_amount": _won(i.get("payment_amount")), "coupon": _won(i.get("coupon_discount_price")), } diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 7b20b56..ece17db 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index bd4f88e..26de82c 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index f2f275c..f4cb766 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -407,11 +407,12 @@ def test_not_implemented_and_mock(): # ════════════════════════════════════════════════════════════ def _c24_order(oid, market="self", paid="T", price=50_000, ship=3_000, coupon=5_000, member=1_000, items=2, **kw): amt = {"order_price_amount": f"{price}.00", "shipping_fee": f"{ship}.00", "coupon_discount_price": f"{coupon}.00", - "membership_discount_amount": f"{member}.00", "points_spent_amount": "0.00", "payment_amount": "0.00"} + "membership_discount_amount": f"{member}.00", "points_spent_amount": "0.00", + "payment_amount": f"{price + ship - coupon - member}.00"} return {"order_id": oid, "market_id": market, "paid": paid, "order_date": "2026-09-28T10:00:00+09:00", "payment_date": "2026-09-29T11:21:35+09:00", "buyer_name": "홍길동", "receiver_address": "서울시", "bank_account_no": "1234567890", "initial_order_amount": amt, - "actual_order_amount": {**amt, "order_price_amount": "0.00"}, # 취소 후 금액은 쓰지 않는다 + "actual_order_amount": {**amt, "order_price_amount": "0.00", "payment_amount": "0.00"}, # 취소 후 금액은 쓰지 않는다 "items": [{"order_item_code": f"{oid}-{i:02d}", "product_name": f"상품{i}", "quantity": 1} for i in range(1, items + 1)], **kw} @@ -483,8 +484,10 @@ def test_cafe24_normalize_matches_daily_report(): assert by[("CANCEL", "c24:C20260929-01")].event_date == date(2026, 9, 29) for e in events: assert "buyer_name" not in str(e.raw) and "1234567890" not in str(e.raw) # 개인정보 미저장 - assert order_total({"initial_order_amount": {"order_price_amount": "1578300.00", "shipping_fee": "45500.00", - "coupon_discount_price": "57000.00"}}) == 1_566_800 # 9/29 화면값 + assert order_total({"naver_point": "151500.00", # 9/23 화면값 + "initial_order_amount": {"order_price_amount": "1860800.00", "shipping_fee": "35000.00", + "coupon_discount_price": "21000.00", "payment_amount": "1713128.00", + "points_spent_amount": "10110.00"}}) == 1_874_738 assert target_code("self") == "cafe24" and target_code("SK11ST") == "elevenst" assert target_code("unknown", "coupang") == "coupang" and target_code("unknown") == "cafe24" assert target_code("NCHECKOUT", "NCHECKOUT") == "cafe24" and target_code("KAKAOPAY") == "cafe24" @@ -513,7 +516,7 @@ def test_cafe24_normalize_matches_daily_report(): # 결제일 기준: 그날 결제된 카페24 열 주문(A,D,E,F,G)의 환불만 — X(결제 없음)·M(스마트스토어)·미완료 제외 bp = rec["refund_basis"]["by_pay_date"] assert bp["count"] == 1 and bp["actual_refund_amount"] == 12_610 - assert bp["amount_diff"] == 5 * 50_000 # 결제 당시 − 현재(가짜 현재 상품금액 0) + assert bp["amount_diff"] == 5 * 47_000 # 결제 당시 − 현재(가짜 현재 상품금액 0) red = {x["order_id"]: x for x in rec["reduced_orders"]} assert set(red) == {"A", "D", "E", "F", "G"} and red["A"]["refunded"] == 12_610 and red["D"]["refunded"] == 0 assert rec["reduced_orders"][-1]["order_id"] == "A" # 환불 기록으로 설명 안 되는 금액이 큰 순 @@ -586,8 +589,14 @@ def test_cafe24_refund_total_includes_points_and_naverpay_cancels(): coupon_discount_price="1000.00")]}, {**_c24_order("NP3", market="NCHECKOUT"), "items": [item("NP3-01", "C40", 5_000, day="2026-09-27 01:00:00")]}, {**_c24_order("NP4", market="NCHECKOUT"), "items": [item("NP4-01", "C00", 5_000)]}, # 취소신청만 → 제외 + # 전체취소 두 품목 — 배송비(3,000)는 마지막 품목(NP5-02)에 한 번만. 앞 품목은 전날 취소(기간 밖) + {**_c24_order("NP5", market="NCHECKOUT"), "items": [item("NP5-01", "C40", 7_000, day="2026-09-25 10:00:00"), + item("NP5-02", "C40", 8_000)]}, + {**_c24_order("KP1", market="KAKAOPAY"), "items": [item("KP1-01", "C40", 9_900)]}, # 톡체크아웃 → 제외 + {**_c24_order("S1"), "items": [item("S1-01", "R40", 9_900)]}, # 자체몰 → 제외 ], - "return_complete_date": [{**_c24_order("NP1", market="NCHECKOUT"), "items": [item("NP1-01", "C40", 55_800)]}], + "return_complete_date": [{**_c24_order("NP1", market="NCHECKOUT"), + "items": [item("NP1-01", "C40", 55_800), item("NP1-02", "N40", 9_000)]}], }) orig, _tz.today_kst = _tz.today_kst, (lambda: date(2026, 9, 29)) try: @@ -599,14 +608,16 @@ def test_cafe24_refund_total_includes_points_and_naverpay_cancels(): assert by["c24:C20260926-01"].amount == -(63_720 + 1_080) # 적립금 환불 포함 assert by["c24:NP1-01-CL"].amount == -55_800 and by["c24:NP1-01-CL"].event_type == "CANCEL" assert by["c24:NP1-01-CL"].event_date == date(2026, 9, 26) and by["c24:NP1-01-CL"].marketplace_code == "cafe24" - assert by["c24:NP2-01-CL"].amount == -(40_000 - 1_000) # 판매가×수량 − 품목 쿠폰 - assert set(by) == {"c24:C20260926-01", "c24:NP1-01-CL", "c24:NP2-01-CL"} # 다른 날·신청·환불 기록 있는 주문 제외 + assert by["c24:NP2-01-CL"].amount == -(40_000 - 1_000 + 3_000) # 판매가×수량 − 품목 쿠폰 + 전체취소 배송비 + assert by["c24:NP5-02-CL"].amount == -(8_000 + 3_000) # 배송비는 마지막 품목에 한 번 + # 다른 날·신청·환불 기록 있는 주문·톡체크아웃·자체몰 제외 + assert set(by) == {"c24:C20260926-01", "c24:NP1-01-CL", "c24:NP2-01-CL", "c24:NP5-02-CL"} rs = rec["refunds"]["self"] - assert rs["no_record_count"] == 2 and rs["no_record"] == 55_800 + 39_000 - assert rs["total"] == 63_720 + 1_080 + 55_800 + 39_000 + assert rs["no_record_count"] == 3 and rs["no_record"] == 55_800 + 42_000 + 11_000 + assert rs["total"] == 63_720 + 1_080 + 55_800 + 42_000 + 11_000 cand = {c["key"]: c["amount"] for c in rec["refund_candidates"]} assert cand["applied"] == rs["total"] - assert {c["item_code"] for c in rec["no_record_claims"]} == {"NP1-01", "NP2-01"} + assert {c["item_code"] for c in rec["no_record_claims"]} == {"NP1-01", "NP2-01", "NP5-02"} def test_cafe24_scope_and_replace_range(): @@ -662,7 +673,9 @@ def test_cafe24_paid_total_matches_daily_report(): assert ev.amount == 46_938 and ev.discount_amount == 1_000 + 5_000 o["actual_order_amount"] = {**o["initial_order_amount"], "payment_amount": "20000.00"} assert order_total_now(o) == 20_000 + 1_000 + 3_000 - assert order_total(_c24_order("Z")) == 47_000 # 결제 필드가 모두 0이면 상품식 + z = _c24_order("Z") + z["initial_order_amount"]["payment_amount"] = "0.00" + assert order_total(z) == 0 # 결제 필드가 모두 0이면 카페24도 0원 # 대조 진단: 원본 금액 필드 합계 + 이상 주문(개인정보 숫자 필드는 제외) import app.timezone as _tz from app.modules.performance.adapters.base import AdapterContext diff --git a/app/static/performance.js b/app/static/performance.js index bef7b38..dc19c62 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -518,7 +518,7 @@ [" · 실제 환불액", rs.actual_refund_amount, rm.actual_refund_amount, "sub"], [" · 적립금 환불", rs.used_points, rm.used_points, "sub"], [" · 예치금 환불", rs.used_credits, rm.used_credits, "sub"], - ["환불 목록 없는 취소·반품 품목 수(네이버페이 등)", rs.no_record_count, rm.no_record_count, "cnt"], + ["환불 목록 없는 네이버페이 취소·반품 품목 수", rs.no_record_count, rm.no_record_count, "cnt"], [" · 취소·반품 금액", rs.no_record, rm.no_record, "sub"], ["환불합계", rs.total, rm.total, "key", 11], ["순매출(결제합계 − 환불합계)", s.total - rs.total, m.total - rm.total, "key", 12], @@ -583,7 +583,7 @@ }).join("") + "
주문번호채널
" : "") + ((r.no_record_claims || []).length - ? '

환불 목록에 없는 취소·반품 (환불합계에 넣은 건 — 네이버페이 등)

' + + ? '

환불 목록에 없는 네이버페이 취소·반품 (환불합계에 넣은 건 — 주문 전체취소면 배송비 포함)

' + '' + '' + "" + @@ -591,6 +591,7 @@ return '"; }).join("") + "
주문번호품목채널상태반영일상품수량뺀 금액품목 결제금액쿠폰주문 전체취소주문 배송비
' + esc(c.order_id) + "" + esc(c.item_code) + "" + esc(c.place_name || c.market_id || "–") + "" + esc(c.status + (c.naver_pay_claim_status ? " / 네이버페이 " + c.naver_pay_claim_status : "")) + "" + esc(c.day) + "" + esc(c.product_name) + '' + fmt(c.quantity) + '' + won(c.amount) + + (c.shipping_refund ? ' (배송비 ' + fmt(c.shipping_refund) + ")" : "") + '' + won(c.item_payment_amount) + '' + won(c.coupon) + "" + (c.order_all_claimed ? "예" : "아니오") + '' + won(c.order_shipping_fee) + "
" diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 55510fc..281a0ee 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -75,7 +75,11 @@ 열별 차이가 같이 나온다. - **결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트**(initial_order_amount 의 payment_amount·points_spent_amount· credits_spent_amount + 주문의 naver_point). "상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이가 있어 쓰지 않음 - (2026-09-23: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식 1,874,800). 네 값이 모두 0인 주문만 상품식. + (2026-09-23: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식 1,874,800). 네 값이 모두 0인 주문도 0원 + (9/25 가상계좌·휴대폰 9,900 — 카페24도 0원). +- **환불 목록 없는 취소는 네이버페이(NCHECKOUT)만** 환불합계에 넣는다. 주문 전체가 취소·반품되면 배송비(− 배송비 할인·쿠폰)도 + 그 주문의 마지막 클레임 품목에 한 번 더한다. 톡체크아웃·자체몰의 환불 기록 없는 취소는 카페24 환불합계에 없음 + (9/4: 98,700 + 네이버페이 19,900 + 배송비 3,500 = 122,100 / 9/16: 톡체크아웃 취소 9,900 제외 → 201,100). ### 연동 단계 체크리스트(쇼핑몰마다) From bfa55bf367e2aaf38807d4bca12a363bc4b215b2 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 23:52:29 +0900 Subject: [PATCH 21/30] =?UTF-8?q?feat(performance):=20=EC=9D=BC=EC=9E=90?= =?UTF-8?q?=EB=B3=84=20=ED=91=9C=20=EB=82=A0=EC=A7=9C=20mm/dd(=EC=9A=94?= =?UTF-8?q?=EC=9D=BC)=C2=B7=ED=8F=AD=20210px,=20=EC=A3=BC=EB=AC=B8=20?= =?UTF-8?q?=EB=82=B4=EC=97=AD=20=EC=B0=BD=20=EC=97=B4=20=EC=A0=9C=EB=AA=A9?= =?UTF-8?q?=20=EA=B3=A0=EC=A0=95=C2=B7=EC=B7=A8=EC=86=8C=20=ED=91=9C?= =?UTF-8?q?=EC=8B=9C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 일자별 × 쇼핑몰: 날짜 "09/01(화)" 형식, 공휴일 이름은 날짜 바로 오른쪽, 날짜 열 너비 210px 고정 - 주문 내역 창: 열 제목 가운데·굵게·150%(18px), 창을 스크롤해도 위에 고정 - 구분 "취소"는 기울임 + 취소선 + 회색 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/calc.py | 3 ++- .../performance/templates/performance/index.html | 4 ++-- .../performance/templates/performance/settings.html | 4 ++-- app/modules/performance/tests/test_performance.py | 2 +- app/static/performance.css | 13 +++++++++++-- app/static/performance.js | 5 +++-- 6 files changed, 21 insertions(+), 10 deletions(-) diff --git a/app/modules/performance/calc.py b/app/modules/performance/calc.py index 16d5617..c430e3e 100644 --- a/app/modules/performance/calc.py +++ b/app/modules/performance/calc.py @@ -110,7 +110,8 @@ def fmt_md(d: date) -> str: def day_label(d: date) -> str: - return f"{WEEKDAYS_KO[d.weekday()]} {fmt_md(d)}" + """일자별 표 날짜 — mm/dd(요일), 예: 09/01(화).""" + return f"{d.month:02d}/{d.day:02d}({WEEKDAYS_KO[d.weekday()]})" @dataclass diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index ece17db..a7e0148 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro won(v) -%} {%- if v is none -%} @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 26de82c..99e7a08 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index f4cb766..bd9389b 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -172,7 +172,7 @@ def test_main_table_week(): cells = _cells_for(days, ["a", "b"]) rows = calc.main_table(p, ["a", "b"], cells, today=date(2026, 9, 30), holidays={"2026-10-03": "개천절"}) assert [r["kind"] for r in rows] == ["day"] * 7 + ["week"] - assert rows[0]["label"] == "월 9/28" and rows[6]["label"] == "일 10/4" + assert rows[0]["label"] == "09/28(월)" and rows[6]["label"] == "10/04(일)" assert rows[5]["holiday"] == "개천절" and rows[2]["today"] and rows[3]["future"] week = rows[-1] assert week["cells"]["a"] == {"gross": 70_000, "commission": 7_000, "net": 63_000} diff --git a/app/static/performance.css b/app/static/performance.css index 2bf3cfb..d6ed4bc 100644 --- a/app/static/performance.css +++ b/app/static/performance.css @@ -109,12 +109,13 @@ a.perf-seg.is-active, a.perf-seg.is-active:link, a.perf-seg.is-active:visited { .perf-zero { color: #c9c9c9; } .perf-na::before { content: ""; } .perf-th-total, .perf-td-total { background: #f6f6f6; font-weight: 600; } -.perf-main .perf-td-label { min-width: 88px; } +/* 날짜 열 너비 고정(210px) — 공휴일 이름이 날짜 오른쪽에 붙는다 */ +.perf-main thead th.perf-th-label, .perf-main .perf-td-label { width: 210px; min-width: 210px; max-width: 210px; box-sizing: border-box; overflow: hidden; text-overflow: ellipsis; } .perf-row-day.is-sat .perf-td-label { color: var(--perf-sat); } .perf-row-day.is-sun .perf-td-label { color: var(--perf-sun); } .perf-row-day.is-today .perf-td-label::after { content: "오늘"; margin-left: 6px; font-size: 10px; padding: 0 5px; border-radius: 999px; background: var(--color-deep-black); color: #fff; vertical-align: 1px; } .perf-row-day.is-future td, .perf-row-month.is-future td, .perf-year tr.is-future td { color: #c9c9c9; } -.perf-hol { display: block; font-size: 10.5px; font-weight: 400; } +.perf-hol { display: inline; margin-left: 6px; font-size: 11px; font-weight: 400; } .perf-row-week th, .perf-row-week td { background: #f3f3f3; font-weight: 600; border-bottom: 1px solid var(--perf-line); } .perf-row-week .perf-td-total { background: #e9e9e9; } .perf-row-total th, .perf-row-total td { background: var(--color-deep-black); color: #fff; font-weight: 600; border-bottom: 0; } @@ -215,3 +216,11 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; } .perf-diff-bad { color: var(--perf-down); font-weight: 600; } .perf-diff-ok { color: #0f8a3a; } .perf-link { background: none; border: 0; padding: 0; color: inherit; font: inherit; text-decoration: underline dotted; cursor: pointer; } + +/* 주문 내역 창 — 열 제목은 가운데·굵게·150%, 창을 스크롤해도 위에 고정 */ +.perf-ev-wrap { overflow: visible; } +.perf-ev-table thead th, .perf-ev-table thead th.perf-th-label { + text-align: center; font-weight: 700; font-size: 18px; color: var(--color-deep-black, #111); + position: sticky; top: -12px; z-index: 2; +} +.perf-ev-table td.perf-ev-kind-cancel { font-style: italic; text-decoration: line-through; color: #9a9a9a; } diff --git a/app/static/performance.js b/app/static/performance.js index dc19c62..2a74e43 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -188,7 +188,8 @@ sum += r.amount; if (r.amount >= 0) sales += r.amount; else minus += r.amount; return '' + - "" + esc(r.sales_date) + "" + esc(KIND[r.event_type] || r.event_type) + + "" + esc(r.sales_date) + "" + + esc(KIND[r.event_type] || r.event_type) + (r.is_sample ? ' 테스트' : "") + "" + "" + esc(r.external_order_id) + "" + "" + esc(r.product_name) + (r.option_name ? " " + esc(r.option_name) + "" : "") + "" + @@ -198,7 +199,7 @@ "" + esc(r.order_status) + ""; }).join(""); m.body.innerHTML = - '
' + + '
' + '' + '' + '' + body + From 1129db9e2152b90615b2d5d1a1e77af6a0b33382 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 23:55:53 +0900 Subject: [PATCH 22/30] =?UTF-8?q?fix(performance):=20=EC=A3=BC=EB=AC=B8=20?= =?UTF-8?q?=EB=82=B4=EC=97=AD=20=EC=B0=BD=20=EA=B3=A0=EC=A0=95=20=EC=97=B4?= =?UTF-8?q?=20=EC=A0=9C=EB=AA=A9=20=EB=B0=B0=EA=B2=BD=20=ED=88=AC=EB=AA=85?= =?UTF-8?q?=20=EB=AC=B8=EC=A0=9C=20+=20=EC=B7=A8=EC=86=8C=20=ED=96=89=20?= =?UTF-8?q?=EC=A0=84=EC=B2=B4=20=EC=84=9C=EC=8B=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 창(.perf-modal)은 document.body 에 붙어 .perf 밖이라 --perf-soft 등 색 변수가 없어 고정된 열 제목 배경이 투명 → 내용이 겹쳐 보였다. 색 변수를 .perf-modal 에도 정의하고 열 제목 배경·아래 줄을 명시 - 취소 행은 행 전체를 기울임 + 취소선 + 회색 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/templates/performance/index.html | 4 ++-- .../performance/templates/performance/settings.html | 4 ++-- app/static/performance.css | 9 +++++++-- app/static/performance.js | 5 ++--- 4 files changed, 13 insertions(+), 9 deletions(-) diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index a7e0148..acad170 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro won(v) -%} {%- if v is none -%} @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 99e7a08..06da1de 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -1,6 +1,6 @@ {% extends "erp_base.html" %} -{% block head_extra %}{% endblock %} +{% block head_extra %}{% endblock %} {%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%} @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/static/performance.css b/app/static/performance.css index d6ed4bc..1231438 100644 --- a/app/static/performance.css +++ b/app/static/performance.css @@ -2,13 +2,16 @@ 실적(쇼핑몰 통합 매출) — 정보 밀도 높은 관리자 대시보드. 기존 ERP 토큰(erp.css :root) 위에서만 쓴다. 색은 증감·상태·주말에만. ════════════════════════════════════════════════════ */ -.perf { +/* 색 변수 — 창(.perf-modal)은 document.body 에 붙어 .perf 밖이라 같이 정의한다 */ +.perf, .perf-modal { --perf-line: var(--color-subtle-ash); --perf-soft: #fafafa; --perf-up: #0f8a3a; --perf-down: var(--color-callout-red); --perf-sat: #1d4ed8; --perf-sun: var(--color-callout-red); +} +.perf { display: flex; flex-direction: column; gap: 12px; font-variant-numeric: tabular-nums; } @@ -223,4 +226,6 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; } text-align: center; font-weight: 700; font-size: 18px; color: var(--color-deep-black, #111); position: sticky; top: -12px; z-index: 2; } -.perf-ev-table td.perf-ev-kind-cancel { font-style: italic; text-decoration: line-through; color: #9a9a9a; } +.perf-ev-table thead th { background: var(--perf-soft, #fafafa); box-shadow: 0 1px 0 var(--perf-line, #e5e5e5); } +/* 취소 행 — 행 전체를 기울임 + 취소선 + 회색 */ +.perf-ev-table tr.is-cancel td { font-style: italic; text-decoration: line-through; color: #9a9a9a; } diff --git a/app/static/performance.js b/app/static/performance.js index 2a74e43..7bc5037 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -187,9 +187,8 @@ const body = rows.map(function (r) { sum += r.amount; if (r.amount >= 0) sales += r.amount; else minus += r.amount; - return '' + - "" + - esc(KIND[r.event_type] || r.event_type) + + return '' + + "" + "" + "" + From b52b182d471cd2ef7239c3fb8d663caea99d12f5 Mon Sep 17 00:00:00 2001 From: king Date: Tue, 29 Sep 2026 23:59:06 +0900 Subject: [PATCH 23/30] =?UTF-8?q?fix(performance):=20=EC=B9=B4=ED=8E=9824?= =?UTF-8?q?=20=EB=A7=88=EC=BC=93=20=ED=86=B5=ED=95=A9=EA=B4=80=EB=A6=AC=20?= =?UTF-8?q?=EB=AF=B8=EC=82=AC=EC=9A=A9=20=E2=80=94=20MARKET=5FMAP=20?= =?UTF-8?q?=EB=B9=84=EC=9A=B0=EA=B8=B0,=20"=EC=B9=B4=ED=8E=9824=20?= =?UTF-8?q?=EA=B2=BD=EC=9C=A0"=20=ED=91=9C=EC=8B=9C=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 이 쇼핑몰은 카페24 마켓 통합관리로 들어오는 매출이 없다(사용자 확인). 설정 화면에 네이버·쿠팡 등 9개 쇼핑몰이 "카페24 경유"로 표시돼 카페24 수집분이 그 열로 가는 것처럼 보였다. - MARKET_MAP = {} — 카페24로 들어온 주문은 market_id 와 관계없이 카페24 열 (경로 기능은 남겨 두고, 쓰게 되면 매핑만 넣으면 됨) - 경로 시험은 테스트용 매핑 주입(_with_markets)으로 유지 + 기본값 비어 있음 테스트 - 문서·대조 안내 문구 갱신 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/cafe24.py | 19 +++--------- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 2 +- .../performance/tests/test_performance.py | 31 +++++++++++++++++++ app/static/performance.js | 2 +- docs/PERFORMANCE_MODULE.md | 2 ++ 6 files changed, 41 insertions(+), 17 deletions(-) diff --git a/app/modules/performance/adapters/cafe24.py b/app/modules/performance/adapters/cafe24.py index 4cedf98..cc1af94 100644 --- a/app/modules/performance/adapters/cafe24.py +++ b/app/modules/performance/adapters/cafe24.py @@ -19,6 +19,7 @@ 그 기간의 카페24 실데이터를 지우고 새로 넣는다. 규칙이 바뀌거나 주문이 사라져도 이중 집계 없음. - 자체몰 주문(market_id 가 self/빈값)은 카페24 열. 카페24 마켓 통합관리로 들어온 다른 마켓 주문 (스마트스토어·쿠팡 등)은 MARKET_MAP 으로 해당 쇼핑몰 열에 넣는다(환불도 원 주문으로 판단). + 현재 이 쇼핑몰은 마켓 통합관리를 쓰지 않아 MARKET_MAP 이 비어 있다 — 모두 카페24 열. MARKET_MAP 에 없는 마켓은 카페24 열 — 전체 합계는 항상 카페24 일별 매출내역과 같다. 네이버페이 결제(order_place_id=NCHECKOUT)는 자체몰 주문이라 카페24 열. 카페24 가 만든 사건은 모두 외부 사건 ID 앞에 "c24:" — 다시 받을 때 이것만 골라 교체하므로 @@ -75,20 +76,10 @@ SELF_CHANNELS: dict[str, str] = { } # 카페24 마켓 통합관리가 가져온 외부 마켓 주문의 market_id(또는 order_place_id) → 우리 쇼핑몰 열. -# 여기에도 SELF_CHANNELS 에도 없는 채널은 "알 수 없는 채널"로 카페24 열에 남긴다 — 전체 합계는 항상 -# 카페24 화면과 같다. 결제수단(네이버페이·카카오페이)과 헷갈릴 수 있는 일반 이름(naver, kakao)은 넣지 않는다. -# 실제 값은 설정 → "카페24 매출 대조"의 주문 채널별 표로 확인해 보탠다. -MARKET_MAP: dict[str, str] = { - "shopn": "naver", "smartstore": "naver", "storefarm": "naver", - "coupang": "coupang", - "sk11st": "elevenst", "11st": "elevenst", "elevenst": "elevenst", - "gmarket": "gmarket", - "lotteon": "lotteon", - "gsshop": "gsshop", - "kakaotalkstore": "kakao", "talkstore": "kakao", "kakaostyle": "kakao", - "ohouse": "ohouse", "todayhouse": "ohouse", "bucketplace": "ohouse", - "tossshopping": "toss", -} +# 이 쇼핑몰은 카페24 마켓 통합관리를 쓰지 않는다(2026-09 사용자 확인) — 비워 두어 카페24로 들어온 주문은 모두 +# 카페24 열. 나중에 쓰게 되면 대조 화면 "주문 채널별" 표의 market_id 로 확인해 예: {"shopn": "naver"} 처럼 넣는다 +# (그 쇼핑몰을 직접 연동한다면 넣지 않는다 — 같은 주문을 두 번 받게 됨). 결제수단과 헷갈리는 이름(naver, kakao) 금지. +MARKET_MAP: dict[str, str] = {} def _key(value: Any) -> str: diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index acad170..ac3c821 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 06da1de..df7fc22 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index bd9389b..1116f9d 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -405,6 +405,26 @@ def test_not_implemented_and_mock(): # ════════════════════════════════════════════════════════════ # 카페24 어댑터(가짜 API 응답) — 카페24 "일별 매출내역" 기준 # ════════════════════════════════════════════════════════════ +# 마켓 통합관리 경로 시험용 매핑 — 실제 MARKET_MAP 은 비어 있다(이 쇼핑몰은 마켓 통합관리 미사용) +TEST_MARKET_MAP = {"shopn": "naver", "sk11st": "elevenst", "coupang": "coupang"} + + +def _with_markets(fn): + import functools + + @functools.wraps(fn) + def run(): + from app.modules.performance.adapters import cafe24 as c24 + saved = dict(c24.MARKET_MAP) + c24.MARKET_MAP.update(TEST_MARKET_MAP) + try: + fn() + finally: + c24.MARKET_MAP.clear() + c24.MARKET_MAP.update(saved) + return run + + def _c24_order(oid, market="self", paid="T", price=50_000, ship=3_000, coupon=5_000, member=1_000, items=2, **kw): amt = {"order_price_amount": f"{price}.00", "shipping_fee": f"{ship}.00", "coupon_discount_price": f"{coupon}.00", "membership_discount_amount": f"{member}.00", "points_spent_amount": "0.00", @@ -447,6 +467,7 @@ class _FakeCafe24(__import__("app.modules.performance.adapters.cafe24", fromlist return {"orders": self.orders_pages[idx] if idx < len(self.orders_pages) else []} +@_with_markets def test_cafe24_normalize_matches_daily_report(): from app.modules.performance.adapters.base import AdapterContext from app.modules.performance.adapters.cafe24 import order_total, target_code @@ -620,6 +641,7 @@ def test_cafe24_refund_total_includes_points_and_naverpay_cancels(): assert {c["item_code"] for c in rec["no_record_claims"]} == {"NP1-01", "NP2-01", "NP5-02"} +@_with_markets def test_cafe24_scope_and_replace_range(): import app.modules.performance.sync as syncmod from app.modules.performance.adapters.base import AdapterContext @@ -697,6 +719,7 @@ def test_cafe24_paid_total_matches_daily_report(): assert odd["B"]["items_gross"] == 10_000 and odd["B"]["order_price_amount"] == 10_050 +@_with_markets def test_daily_check_db_vs_live(): """일별 비교: 저장값(카페24 경유 다른 마켓 열 포함) + 지금 API 값(저장 안 함).""" import app.modules.performance.sync as syncmod @@ -723,6 +746,14 @@ def test_daily_check_db_vs_live(): assert len(st.events) == 4 # 저장값은 바뀌지 않음 +def test_cafe24_market_map_empty_by_default(): + """마켓 통합관리 미사용 — 카페24로 들어온 주문은 market_id 가 무엇이든 카페24 열.""" + from app.modules.performance.adapters.cafe24 import MARKET_MAP, target_code + + assert MARKET_MAP == {} + assert target_code("shopn") == target_code("coupang", "coupang") == target_code("NCHECKOUT") == "cafe24" + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 diff --git a/app/static/performance.js b/app/static/performance.js index 7bc5037..14fbeb3 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -796,7 +796,7 @@ (stale ? '
" : "") + '
매출일구분주문번호상품명수량금액주문일결제일상태
" + esc(r.sales_date) + "
" + esc(r.sales_date) + "" + esc(KIND[r.event_type] || r.event_type) + (r.is_sample ? ' 테스트' : "") + "" + esc(r.external_order_id) + "" + esc(r.product_name) + (r.option_name ? " " + esc(r.option_name) + "" : "") + "
' + head + "" + body + "" + foot + "
" + - '

차이 = 우리 값 − 카페24 값. 저장값은 카페24 열과 카페24 경유 다른 마켓 열을 합친 금액(카페24 화면과 같은 범위)입니다.

'; + '

차이 = 우리 값 − 카페24 값. 저장값은 카페24 수집분 전체(카페24 화면과 같은 범위)입니다.

'; } catch (err) { out.innerHTML = '

' + esc(err.message) + "

"; } finally { dailyBtn.disabled = false; } diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 281a0ee..7815cac 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -54,6 +54,8 @@ `mobile`=모바일웹, `NCHECKOUT`=네이버페이, `KAKAOPAY`=톡체크아웃). 이들은 `SELF_CHANNELS` 로 카페24 열. 대조 도구의 "주문 채널별" 표가 채널마다 자체몰 채널 / 외부 마켓 / 알 수 없는 채널(→ 카페24 열)을 보여 준다. `MARKET_MAP` 에는 결제수단과 헷갈릴 수 있는 일반 이름(naver, kakao)을 넣지 않는다. +- **현재 `MARKET_MAP` 은 비어 있다** — 이 쇼핑몰은 카페24 마켓 통합관리를 쓰지 않는다(2026-09 사용자 확인). 카페24로 들어온 + 주문은 모두 카페24 열이고 설정 화면의 "카페24 경유" 표시도 나오지 않는다. 아래는 나중에 마켓 통합관리를 쓸 때의 동작. - **마켓 연동 주문은 해당 쇼핑몰 열로**: 자체몰 채널은 카페24 열. 카페24 마켓 통합관리가 가져온 다른 마켓 주문은 `MARKET_MAP`(market_id 또는 order_place_id → 우리 쇼핑몰 코드)으로 네이버·쿠팡·11번가 등 열에 넣는다 (`SaleEvent.marketplace_code`). 연결표에 없는 마켓은 카페24 열 — **전체 합계는 항상 카페24 일별 매출내역과 같다** From dd6a849fbd4af1fbe7265c18d7b78f53051e3868 Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 00:14:06 +0900 Subject: [PATCH 24/30] =?UTF-8?q?feat(performance):=20=EC=BF=A0=ED=8C=A1?= =?UTF-8?q?=20=EC=97=B0=EA=B2=B0=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=E2=80=94?= =?UTF-8?q?=20HMAC(CEA)=20=EC=84=9C=EB=AA=85=EC=9C=BC=EB=A1=9C=20=EB=B0=9C?= =?UTF-8?q?=EC=A3=BC=EC=84=9C=20=EC=8B=A4=EC=A0=9C=20=EC=A1=B0=ED=9A=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 쿠팡 OPEN API 키를 입력했지만 연결 테스트가 "다음 단계에서 구현"만 돌려줘 키가 이 서버에서 통하는지 알 수 없었다. 키는 판매자당 1개이고 사방넷용 (연동업체 선택)으로 발급한 키는 이 서버 IP 에서 막힐 수 있어 먼저 확인이 필요. - CEA HMAC-SHA256 서명(signed-date + METHOD + path + query, 공식 예제 방식), 쿠팡 예시와 같은 쿼리 인코딩(+ → %2B, : 유지) - test_connection: 오늘 결제완료 발주서(v5 ordersheets) 1건 조회 - 401/403 → 인증 실패 + "연동업체 키면 자체개발로 바꾸고 이 서버 IP 허용" 안내 - 매출 수집은 아직 — 맞출 WING 화면을 정한 뒤 구현(주석에 API 조사 결과) - 테스트: 서명 형식·쿼리 인코딩·403 메시지·비밀값 미노출 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/coupang.py | 92 ++++++++++++++++++- .../performance/tests/test_performance.py | 49 ++++++++++ 2 files changed, 139 insertions(+), 2 deletions(-) diff --git a/app/modules/performance/adapters/coupang.py b/app/modules/performance/adapters/coupang.py index b6725e2..825b39d 100644 --- a/app/modules/performance/adapters/coupang.py +++ b/app/modules/performance/adapters/coupang.py @@ -1,12 +1,57 @@ """쿠팡 — 쿠팡 윙(마켓플레이스) 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 를 넣어야 한다. +연결 테스트는 오늘 결제완료 발주서 1건을 실제로 조회해 키·IP 가 통하는지 확인한다. + +매출 수집(fetch_orders)은 아직 — 어느 WING 화면과 맞출지 정한 뒤 구현한다. + · 발주서 목록(v5 ordersheets, 주문일 기준, 상태별 조회) + 반품/취소 요청(v6 returnRequests, 접수일 기준, 금액 없음) + · 매출내역(v1 revenue-history)은 매출인식일(구매확정 또는 배송완료+7일) 기준이라 결제일 기준 일별 매출과 다르다. 로켓(공급) 매출은 기존 쿠팡 밀크런 모듈의 cupang_sales 에 있다 — 필요 시 별도 연계. """ from __future__ import annotations -from .base import CredentialField, MarketplaceAdapter +import hashlib +import hmac +import time +from typing import Any +from urllib.parse import quote, urlencode + +from .base import ( + AdapterContext, + ApiError, + AuthFailed, + CredentialField, + MarketplaceAdapter, + NotConfigured, +) + +HOST = "https://api-gateway.coupang.com" + + +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=":") class CoupangAdapter(MarketplaceAdapter): @@ -14,7 +59,9 @@ class CoupangAdapter(MarketplaceAdapter): name = "쿠팡" auth_type = "api_key" docs_url = "https://developers.coupangcorp.com/" - note = "쿠팡 윙 → 판매자정보 → 추가판매정보 → OPEN API 키 발급에서 확인합니다." + note = ("쿠팡 윙 → 판매자정보 → 추가판매정보 → OPEN API 키 발급에서 확인합니다. 키는 판매자당 1개이며, " + "'연동업체(사방넷 등)'로 발급한 키는 이 서버에서 막힐 수 있습니다 — 그때는 '자체개발'로 바꾸고 " + "이 서버 IP 를 허용 IP 에 넣어야 합니다(연결 테스트로 확인).") def credential_fields(self) -> list[CredentialField]: return [ @@ -22,3 +69,44 @@ class CoupangAdapter(MarketplaceAdapter): CredentialField("access_key", "Access Key", secret=True), CredentialField("secret_key", "Secret Key", secret=True), ] + + # ── 호출 ────────────────────────────────────────────── + def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]: + 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) + 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.HTTPError as exc: + raise ApiError(f"쿠팡 API 연결 실패: {type(exc).__name__}") from None + try: + body = res.json() + except ValueError: + body = {} + msg = str(body.get("message") or body.get("error") or res.text[:200] or "").strip() + if res.status_code in (401, 403): + raise AuthFailed( + f"쿠팡 인증 거부({res.status_code}): {msg}. Vendor ID·키가 맞는지 확인하세요. 키를 '연동업체(사방넷 등)'로 " + "발급했다면 이 서버에서 쓸 수 없을 수 있습니다 — WING 에서 '자체개발'로 바꾸고 이 서버 IP 를 허용 IP 에 " + "넣어야 합니다(사방넷 IP 도 함께 넣어야 사방넷이 계속 동작).") + if res.status_code >= 400: + raise ApiError(f"쿠팡 API 오류({res.status_code}): {msg}") + return body + + def test_connection(self, ctx: AdapterContext) -> str: + from app.timezone import today_kst # noqa: WPS433 + + self.authenticate(ctx) + vendor = ctx.credentials.get("vendor_id").strip() + today = today_kst().isoformat() + body = self._get(ctx, f"/v2/providers/openapi/apis/api/v5/vendors/{vendor}/ordersheets", + {"createdAtFrom": f"{today}+09:00", "createdAtTo": f"{today}+09:00", + "status": "ACCEPT", "maxPerPage": 1}) + n = len(body.get("data") or []) + return (f"쿠팡 연결 정상(발주서 조회 권한 확인, 오늘 결제완료 {'있음' if n else '없음'}). " + "매출 수집은 다음 단계에서 구현됩니다.") diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 1116f9d..fce4c7c 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -754,6 +754,55 @@ def test_cafe24_market_map_empty_by_default(): assert target_code("shopn") == target_code("coupang", "coupang") == target_code("NCHECKOUT") == "cafe24" +def test_coupang_hmac_and_connection_errors(): + """쿠팡 CEA HMAC 서명(공식 예제 방식) + 연결 테스트 오류 구분. 비밀값은 메시지에 없다.""" + import hashlib + import hmac as _hmac + + import httpx + + from app.modules.performance.adapters import coupang as cp + from app.modules.performance.adapters.base import AdapterContext + + q = cp.build_query({"createdAtFrom": "2026-09-30+09:00", "status": "ACCEPT", "maxPerPage": 1}) + assert q == "createdAtFrom=2026-09-30%2B09:00&status=ACCEPT&maxPerPage=1" + now = 1_790_000_000 # 2026-09-21 14:13:20 UTC + h = cp.authorization("GET", "/p", q, "AK", "SK", now=now) + dt = "260921T141320Z" + sig = _hmac.new(b"SK", f"{dt}GET/p{q}".encode(), hashlib.sha256).hexdigest() + assert h == f"CEA algorithm=HmacSHA256, access-key=AK, signed-date={dt}, signature={sig}" + + class Creds(dict): + def get(self, k, default=""): + return dict.get(self, k, default) + + def has(self, k): + return bool(dict.get(self, k)) + + ctx = AdapterContext(code="coupang", credentials=Creds(vendor_id="A00012345", access_key="AK-1", secret_key="SK-SECRET")) + seen = {} + + def fake_get(url, headers=None, timeout=None, status=200, body=None): + seen["url"], seen["auth"] = url, headers["Authorization"] + return httpx.Response(status, json=body if body is not None else {"code": 200, "data": []}) + + orig = httpx.get + try: + httpx.get = fake_get + msg = cp.CoupangAdapter().test_connection(ctx) + assert "연결 정상" in msg and "/vendors/A00012345/ordersheets?createdAtFrom=" in seen["url"] + assert "%2B09:00" in seen["url"] and "SK-SECRET" not in seen["auth"] + httpx.get = lambda url, headers=None, timeout=None: fake_get(url, headers, timeout, 403, {"message": "Access Denied"}) + try: + cp.CoupangAdapter().test_connection(ctx) + except AuthFailed as exc: + assert "403" in exc.message and "자체개발" in exc.message and "SK-SECRET" not in exc.message + else: + raise AssertionError("403 이면 인증 실패여야 합니다") + finally: + httpx.get = orig + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 From c93ab2fbd8ecfba5109c2b90df9da904aac94d5f Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 00:31:57 +0900 Subject: [PATCH 25/30] =?UTF-8?q?feat(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EC=97=B0=EA=B2=B0=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=E2=80=94?= =?UTF-8?q?=20openapikey=20=EB=A1=9C=20=EA=B2=B0=EC=A0=9C=EC=99=84?= =?UTF-8?q?=EB=A3=8C=20=EC=A3=BC=EB=AC=B8=20=EC=8B=A4=EC=A0=9C=20=EC=A1=B0?= =?UTF-8?q?=ED=9A=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 11번가 셀러 API 키 입력·IP 등록을 마쳤는데 연결 테스트가 "다음 단계에서 구현"만 돌려줘 이 서버에서 통하는지 알 수 없었다. - test_connection: GET /rest/ordservices/complete/{오늘0000}/{오늘2359}, 헤더 openapikey (공식 이용방법 문서). 셀러 API 는 등록 IP 에서만 호출됨 - XML 응답(euc-kr 선언) 직접 디코딩 후 파싱, result_code 오류·401/403 구분, 연결 실패 시 등록 IP 확인 안내 - 기존 테스트가 실제 11번가를 부르지 않게 httpx 대체 + 11번가 테스트 추가 - 매출 수집은 아직(맞출 셀러오피스 화면 정한 뒤) Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 78 ++++++++++++++++++- .../performance/tests/test_performance.py | 54 ++++++++++++- 2 files changed, 128 insertions(+), 4 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index 2eb8b3b..f1eea47 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -1,11 +1,54 @@ """11번가 — 11번가 셀러 오픈API. -인증: 셀러오피스에서 발급한 Open API Key 를 요청 헤더(openapikey)에 넣는다. +인증: 셀러오피스(openapi.11st.co.kr → 서비스등록·확인)에서 발급한 Open API Key 를 요청 헤더 `openapikey` 에 넣는다. +셀러 API 는 등록한 IP 에서만 호출된다("Seller API 정보 수정"에서 서버 IP 등록, 셀링툴(사방넷 등)과 함께 쓸 수 있음). +(공식 이용방법 openapi.11st.co.kr → OpenApiOperationGuide SERVICE_METHOD, 2026-09-30 확인) + +연결 테스트는 결제완료(발주확인할) 주문 목록을 오늘 하루로 조회한다 — GET /rest/ordservices/complete/{시작}/{끝} +(yyyyMMddHHmm). 엔드포인트 상세 문서는 로그인 뒤에만 보여 널리 쓰이는 경로를 쓰고, 실제 호출 결과로 확인한다. +응답은 XML. 매출 수집(fetch_orders)은 맞출 셀러오피스 화면을 정한 뒤 구현한다. """ from __future__ import annotations -from .base import CredentialField, MarketplaceAdapter +import re +import xml.etree.ElementTree as ET +from typing import Any + +from .base import AdapterContext, ApiError, AuthFailed, CredentialField, MarketplaceAdapter + +HOST = "https://api.11st.co.kr" + + +def _xml_text(content: bytes) -> str: + """11번가 XML 은 euc-kr 선언이 많다 — 파이썬 XML 파서가 다바이트 인코딩 선언을 못 읽어 직접 풀고 선언을 뗀다.""" + head = content[:200].decode("ascii", "ignore") + m = re.search(r"encoding=[\"']([\w-]+)", head) + enc = (m.group(1) if m else "utf-8").lower() + try: + text = content.decode("cp949" if enc in ("euc-kr", "euckr", "ks_c_5601-1987") else enc) + except (LookupError, UnicodeDecodeError): + text = content.decode("utf-8", "replace") + return re.sub(r"^\s*<\?xml[^>]*\?>", "", text) + + +def xml_result(content: bytes) -> tuple[str, str, int]: + """(결과코드, 결과문구, 주문 수). 네임스페이스와 무관하게 태그 끝 이름으로 찾는다.""" + try: + root = ET.fromstring(_xml_text(content)) + except ET.ParseError: + return "", "", 0 + code = text = "" + orders = 0 + for el in root.iter(): + tag = el.tag.rsplit("}", 1)[-1].lower() + if tag in ("result_code", "resultcode") and not code: + code = (el.text or "").strip() + elif tag in ("result_text", "resulttext", "result_message", "message") and not text: + text = (el.text or "").strip() + elif tag == "order": + orders += 1 + return code, text, orders class ElevenstAdapter(MarketplaceAdapter): @@ -13,9 +56,38 @@ class ElevenstAdapter(MarketplaceAdapter): name = "11번가" auth_type = "api_key" docs_url = "https://openapi.11st.co.kr/" - note = "11번가 셀러오피스 → 오픈API 에서 발급한 키를 입력합니다." + note = ("11번가 셀러오피스 → 오픈API 에서 발급한 키를 입력합니다. 셀러 API 는 등록한 IP 에서만 호출되므로 " + "'Seller API 정보 수정 → IP 직접 입력'에 이 서버의 외부 IP 를 넣어야 합니다.") def credential_fields(self) -> list[CredentialField]: return [ CredentialField("api_key", "Open API Key", secret=True), ] + + def _get(self, ctx: AdapterContext, path: str) -> bytes: + import httpx # 지연 import + + headers = {"openapikey": ctx.credentials.get("api_key").strip(), "Accept": "application/xml"} + try: + res = httpx.get(f"{HOST}{path}", headers=headers, timeout=ctx.timeout_sec) + except httpx.HTTPError as exc: + raise ApiError(f"11번가 API 연결 실패: {type(exc).__name__} — 등록한 IP 가 이 서버 IP 인지 확인하세요.") from None + code, text, _ = xml_result(res.content) + detail = text or res.text[:200].strip() + if res.status_code in (401, 403): + raise AuthFailed(f"11번가 인증 거부({res.status_code}): {detail}. 키와 등록 IP(이 서버 외부 IP)를 확인하세요.") + if res.status_code >= 400: + raise ApiError(f"11번가 API 오류({res.status_code}): {detail}") + if code and code not in ("0", "200", "00"): + raise ApiError(f"11번가 API 오류(코드 {code}): {detail}") + return res.content + + def test_connection(self, ctx: AdapterContext) -> str: + from app.timezone import today_kst # noqa: WPS433 + + self.authenticate(ctx) + d = today_kst().strftime("%Y%m%d") + body = self._get(ctx, f"/rest/ordservices/complete/{d}0000/{d}2359") + _, _, orders = xml_result(body) + return (f"11번가 연결 정상(주문 조회 권한 확인, 오늘 결제완료 {orders}건). " + "매출 수집은 다음 단계에서 구현됩니다.") diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index fce4c7c..ec5ce5b 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -13,6 +13,7 @@ from decimal import Decimal from app.modules.performance import calc from app.modules.performance.adapters import mock from app.modules.performance.adapters.base import ( + ApiError, AuthFailed, CredentialField, MarketplaceAdapter, @@ -387,7 +388,12 @@ def test_not_implemented_and_mock(): creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "k-123456"}) r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29)) assert r["status"] == "not_implemented" and "k-123456" not in r["message"] - t = svc.test_connection("elevenst", values={"api_key": "typed-only"}) + import httpx + orig_get, httpx.get = httpx.get, (lambda url, headers=None, timeout=None: httpx.Response(200, content=b"")) + try: + t = svc.test_connection("elevenst", values={"api_key": "typed-only"}) + finally: + httpx.get = orig_get assert t["unsaved"] and "test" not in st.status.get("elevenst", {}) # 저장 안 한 값 시험은 상태 기록 안 함 a = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30)) b = mock.generate("naver", date(2026, 9, 1), date(2026, 9, 30)) @@ -803,6 +809,52 @@ def test_coupang_hmac_and_connection_errors(): httpx.get = orig +def test_elevenst_connection(): + """11번가: openapikey 헤더 + 결제완료 주문 조회(XML). 오류 코드·403 구분, 키는 메시지에 없음.""" + import httpx + + from app.modules.performance.adapters import elevenst as ev + from app.modules.performance.adapters.base import AdapterContext + + class Creds(dict): + def get(self, k, default=""): + return dict.get(self, k, default) + + def has(self, k): + return bool(dict.get(self, k)) + + ctx = AdapterContext(code="elevenst", credentials=Creds(api_key="KEY-11ST-SECRET")) + seen = {} + ok_xml = ('12' + '').encode("euc-kr") + + def fake(status, content): + def get(url, headers=None, timeout=None): + seen["url"], seen["key"] = url, headers["openapikey"] + return httpx.Response(status, content=content) + return get + + orig = httpx.get + try: + httpx.get = fake(200, ok_xml) + msg = ev.ElevenstAdapter().test_connection(ctx) + assert "연결 정상" in msg and "2건" in msg and seen["key"] == "KEY-11ST-SECRET" + assert "/rest/ordservices/complete/" in seen["url"] + err = '-1허용되지 않은 IP' + for status, body, kind in ((200, err.encode(), ApiError), (403, b"Forbidden", AuthFailed)): + httpx.get = fake(status, body) + try: + ev.ElevenstAdapter().test_connection(ctx) + except kind as exc: + assert "KEY-11ST-SECRET" not in exc.message + assert status == 403 or "허용되지 않은 IP" in exc.message + else: + raise AssertionError("오류여야 합니다") + finally: + httpx.get = orig + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 From 6376092bb7927e4f6eb721c0902ba29209b205dc Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 00:40:40 +0900 Subject: [PATCH 26/30] =?UTF-8?q?fix(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EC=97=B0=EA=B2=B0=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=E2=80=94?= =?UTF-8?q?=20XML=20=EC=95=84=EB=8B=8C=20=EC=9D=91=EB=8B=B5=EC=9D=80=20?= =?UTF-8?q?=EC=8B=A4=ED=8C=A8,=20=EC=84=B1=EA=B3=B5=20=EC=95=8C=EB=A6=BC?= =?UTF-8?q?=EC=9D=80=20=EC=B4=88=EB=A1=9D=20=EC=B2=B4=ED=81=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 11번가가 200 으로 웹페이지(IP 차단 안내 등)나 XML 아닌 응답을 주면 "0건 정상"으로 오판할 수 있어 실패로 처리 - 공용 알림 창 erpAlert(msg, { tone: "ok" }) — 경고 삼각형 대신 초록 체크. 기존 호출은 그대로. 실적 연결 테스트 성공 알림에 적용 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 8 ++++++-- .../performance/templates/performance/index.html | 2 +- .../performance/templates/performance/settings.html | 2 +- app/modules/performance/tests/test_performance.py | 5 +++-- app/static/erp-dialog.css | 5 +++++ app/static/erp-dialog.js | 13 +++++++++++-- app/static/performance.js | 4 ++-- app/templates/erp_base.html | 4 ++-- 8 files changed, 31 insertions(+), 12 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index f1eea47..43bb46d 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -33,11 +33,13 @@ def _xml_text(content: bytes) -> str: def xml_result(content: bytes) -> tuple[str, str, int]: - """(결과코드, 결과문구, 주문 수). 네임스페이스와 무관하게 태그 끝 이름으로 찾는다.""" + """(결과코드, 결과문구, 주문 수). 네임스페이스와 무관하게 태그 끝 이름으로 찾는다. XML 이 아니면 코드 "not-xml".""" try: root = ET.fromstring(_xml_text(content)) except ET.ParseError: - return "", "", 0 + return "not-xml", "", 0 + if root.tag.rsplit("}", 1)[-1].lower() == "html": # 오류 안내 웹페이지(IP 차단 등) + return "not-xml", "", 0 code = text = "" orders = 0 for el in root.iter(): @@ -78,6 +80,8 @@ class ElevenstAdapter(MarketplaceAdapter): raise AuthFailed(f"11번가 인증 거부({res.status_code}): {detail}. 키와 등록 IP(이 서버 외부 IP)를 확인하세요.") if res.status_code >= 400: raise ApiError(f"11번가 API 오류({res.status_code}): {detail}") + if code == "not-xml": + raise ApiError(f"11번가가 예상하지 못한 응답을 돌려줬습니다(XML 아님): {res.text[:120].strip()}") if code and code not in ("0", "200", "00"): raise ApiError(f"11번가 API 오류(코드 {code}): {detail}") return res.content diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index ac3c821..0fc29ca 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index df7fc22..71a95e3 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -155,4 +155,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index ec5ce5b..618f950 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -842,13 +842,14 @@ def test_elevenst_connection(): assert "연결 정상" in msg and "2건" in msg and seen["key"] == "KEY-11ST-SECRET" assert "/rest/ordservices/complete/" in seen["url"] err = '-1허용되지 않은 IP' - for status, body, kind in ((200, err.encode(), ApiError), (403, b"Forbidden", AuthFailed)): + for status, body, kind in ((200, err.encode(), ApiError), (403, b"Forbidden", AuthFailed), + (200, b"IP not allowed", ApiError)): httpx.get = fake(status, body) try: ev.ElevenstAdapter().test_connection(ctx) except kind as exc: assert "KEY-11ST-SECRET" not in exc.message - assert status == 403 or "허용되지 않은 IP" in exc.message + assert status == 403 or "허용되지 않은 IP" in exc.message or "XML 아님" in exc.message else: raise AssertionError("오류여야 합니다") finally: diff --git a/app/static/erp-dialog.css b/app/static/erp-dialog.css index 8c3debb..5bdfb42 100644 --- a/app/static/erp-dialog.css +++ b/app/static/erp-dialog.css @@ -54,6 +54,11 @@ color: var(--color-callout-red, #c22b10); } +/* 성공 알림(erpAlert(msg, { tone: "ok" })) — 초록 체크 */ +.erp-dialog-icon.is-ok { + color: #0f8a3a; +} + /* 확인(질문)용은 붉은 경고색 대신 차분한 검정으로 */ .erp-dialog-ask .erp-dialog-icon { color: var(--color-rich-black, #0a0a0a); diff --git a/app/static/erp-dialog.js b/app/static/erp-dialog.js index 57ef137..bebf855 100644 --- a/app/static/erp-dialog.js +++ b/app/static/erp-dialog.js @@ -8,6 +8,7 @@ erpConfirm("지울까요?").then(function (ok) { if (ok) ... }); erpAlert("실패했습니다.").then(...) erpPrompt("주소를 입력하세요", "https://").then(function (v) { if (v) ... }); // 취소면 null + erpAlert("저장했습니다.", { tone: "ok" }) // 성공 알림 — 경고 삼각형 대신 초록 체크 창 제목은 기본 "No.1 King ERP 프로그램". 화면마다 바꾸려면 그 화면 스크립트에서 window.ERP_DIALOG_TITLE = "..." 를 두거나, 한 번만 options.title 로 넘긴다. @@ -31,6 +32,14 @@ '' + ""; + // 성공(tone: "ok") — 원 안의 체크. + var ICON_OK = + '"; + function titleOf(options) { return options.title || window.ERP_DIALOG_TITLE || TITLE; } @@ -54,8 +63,8 @@ body.className = "erp-dialog-body"; var icon = document.createElement("span"); - icon.className = "erp-dialog-icon"; - icon.innerHTML = ICON; + icon.className = "erp-dialog-icon" + (options.tone === "ok" ? " is-ok" : ""); + icon.innerHTML = options.tone === "ok" ? ICON_OK : ICON; var text = document.createElement("p"); text.className = "erp-dialog-message"; diff --git a/app/static/performance.js b/app/static/performance.js index 14fbeb3..94fcfc4 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -31,7 +31,7 @@ if (a >= 10000) return s + Math.round(a / 10000).toLocaleString("ko-KR") + "만"; return s + fmt(a); } - function alertMsg(msg) { return window.erpAlert ? window.erpAlert(msg) : Promise.resolve(window.alert(msg)); } + function alertMsg(msg, opts) { return window.erpAlert ? window.erpAlert(msg, opts) : Promise.resolve(window.alert(msg)); } function confirmMsg(msg) { return window.erpConfirm ? window.erpConfirm(msg) : Promise.resolve(window.confirm(msg)); } async function api(method, url, body) { @@ -466,7 +466,7 @@ btn.textContent = "확인 중…"; try { const res = await api("POST", "/performance/api/marketplaces/" + code + "/test", {}); - await alertMsg(name + " — " + (res.ok ? "정상 연결\n" : res.label + "\n") + res.message); + await alertMsg(name + " — " + (res.ok ? "정상 연결\n" : res.label + "\n") + res.message, res.ok ? { tone: "ok" } : undefined); location.reload(); } catch (err) { alertMsg(err.message); diff --git a/app/templates/erp_base.html b/app/templates/erp_base.html index 6c4ce15..e657643 100644 --- a/app/templates/erp_base.html +++ b/app/templates/erp_base.html @@ -7,7 +7,7 @@ - + {% block head_extra %}{% endblock %} @@ -177,7 +177,7 @@ {# 공용 확인/경고 창. defer 를 쓰지 않는다 — 아래 {% block scripts %} 의 인라인 스크립트가 곧바로 erpConfirm/erpAlert 을 쓸 수 있어야 한다. #} - + {% block scripts %}{% endblock %} From 1952e4f0b117529bec7ee4a9e3252ef1b354e2c9 Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 00:47:55 +0900 Subject: [PATCH 27/30] =?UTF-8?q?feat(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EC=9B=90=EB=B3=B8=20=EB=8D=B0=EC=9D=B4=ED=84=B0=20=ED=99=95?= =?UTF-8?q?=EC=9D=B8=20=EB=8F=84=EA=B5=AC=20=E2=80=94=20=ED=9B=84=EB=B3=B4?= =?UTF-8?q?=20=EC=A1=B0=ED=9A=8C=20=EC=A3=BC=EC=86=8C=EB=B3=84=20=EB=8F=99?= =?UTF-8?q?=EC=9E=91=C2=B7=ED=95=AD=EB=AA=A9=20=ED=95=A9=EA=B3=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 11번가 셀러 API 의 주문·클레임 상세 문서는 로그인 뒤에만 있어 조회 주소와 금액 항목 이름을 공개 자료로 확정할 수 없다. 추측으로 매출 수집을 짜지 않고 실데이터로 확정하기 위해: - ElevenstAdapter.reconcile(day): 결제완료·발송대상·배송중·배송완료·취소신청· 취소완료·반품신청·반품완료·정산 후보 주소를 그날로 호출 → 동작 여부(404 등 오류), 건수, 항목별 채워진 줄·숫자 합계·예시 값. 개인정보 항목은 이름만(값 숨김) - 설정 화면 "11번가 원본 데이터 확인" 카드 - 테스트 추가 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 79 ++++++++++++++++++- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 14 +++- .../performance/tests/test_performance.py | 20 +++++ app/static/performance.js | 33 ++++++++ 5 files changed, 145 insertions(+), 3 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index 43bb46d..7416777 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -13,9 +13,10 @@ from __future__ import annotations import re import xml.etree.ElementTree as ET +from datetime import date from typing import Any -from .base import AdapterContext, ApiError, AuthFailed, CredentialField, MarketplaceAdapter +from .base import AdapterContext, AdapterError, ApiError, AuthFailed, CredentialField, MarketplaceAdapter HOST = "https://api.11st.co.kr" @@ -53,6 +54,62 @@ def xml_result(content: bytes) -> tuple[str, str, int]: return code, text, orders +# 원본 데이터 확인용 후보 주소 — {s}/{e} = yyyyMMddHHmm, {d} = yyyyMMdd. 문서 미확인 경로가 섞여 있어 +# 404 등 실패도 그대로 보여 준다(어느 주소가 살아 있는지 확인하는 것이 목적). +PROBE_PATHS: tuple[tuple[str, str, str], ...] = ( + ("complete", "결제완료(발주확인 전)", "/rest/ordservices/complete/{s}/{e}"), + ("packaging", "발송처리 대상(발주확인 후)", "/rest/ordservices/packaging/{s}/{e}"), + ("shipping", "배송중", "/rest/ordservices/shipping/{s}/{e}"), + ("completed", "배송완료", "/rest/ordservices/completed/{s}/{e}"), + ("cancelorders", "취소신청", "/rest/claimservice/cancelorders/{s}/{e}"), + ("canceledorders", "취소완료", "/rest/claimservice/canceledorders/{s}/{e}"), + ("returnorders", "반품신청", "/rest/claimservice/returnorders/{s}/{e}"), + ("returnedorders", "반품완료", "/rest/claimservice/returnedorders/{s}/{e}"), + ("settlement", "정산 내역", "/rest/settlement/settlementList/{d}/{d}"), +) + +# 개인정보로 보이는 항목 — 값은 보이지 않고 이름만(이름·연락처·주소·우편번호·아이디·메일·메모) +PERSONAL = re.compile(r"(nm|name|tel|tlphn|phone|hp|addr|zip|mail|id|memo|msg|pcc|clearance|birth)$|rcvr|ordnm|buyer", + re.IGNORECASE) +NUMBER = re.compile(r"^-?\d+(\.\d+)?$") +SAFE = re.compile(r"^(prd|opt|slct|dlvEtprs|dlvMthd|clm|reason|stl|sel)", re.IGNORECASE) # 상품·옵션·클레임 사유 등은 보임 + + +def xml_records(content: bytes) -> list[dict[str, str]]: + """응답에서 주문(또는 클레임·정산) 한 줄씩 — 자식이 모두 글자 항목인 요소를 한 줄로 본다(태그 끝 이름 → 값).""" + try: + root = ET.fromstring(_xml_text(content)) + except ET.ParseError: + return [] + out: list[dict[str, str]] = [] + for el in root.iter(): + kids = list(el) + if len(kids) >= 3 and all(len(k) == 0 for k in kids): + out.append({k.tag.rsplit("}", 1)[-1]: (k.text or "").strip() for k in kids}) + return out + + +def field_summary(records: list[dict[str, str]]) -> list[dict[str, Any]]: + """항목별: 채워진 줄 수, 숫자면 합계, 개인정보 아니면 예시 값 하나.""" + names: dict[str, dict[str, Any]] = {} + for r in records: + for k, v in r.items(): + f = names.setdefault(k, {"name": k, "filled": 0, "numeric": True, "sum": 0.0, "sample": "", + "personal": bool(PERSONAL.search(k)) and not SAFE.match(k)}) + if not v: + continue + f["filled"] += 1 + if NUMBER.match(v) and f["numeric"]: + f["sum"] += float(v) + else: + f["numeric"] = False + if not f["sample"] and not f["personal"]: + f["sample"] = v[:40] + for f in names.values(): + f["sum"] = int(round(f["sum"])) if f["numeric"] and f["filled"] else None + return list(names.values()) + + class ElevenstAdapter(MarketplaceAdapter): code = "elevenst" name = "11번가" @@ -86,6 +143,26 @@ class ElevenstAdapter(MarketplaceAdapter): raise ApiError(f"11번가 API 오류(코드 {code}): {detail}") return res.content + # ── 원본 데이터 확인(설정 화면 "11번가 원본 데이터 확인") ───────── + def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]: + """후보 조회 주소마다 그날(00:00~23:59) 실제로 불러 동작 여부·주문 수·항목별 합계를 돌려준다. + 셀러 API 상세 문서가 로그인 뒤에만 있어, 어느 주소·항목이 셀러오피스 화면 매출과 맞는지 실데이터로 확정하는 용도. + 개인정보 항목(이름·연락처·주소·아이디 등)은 값 없이 이름만.""" + self.authenticate(ctx) + d = day.strftime("%Y%m%d") + out = [] + for key, label, tmpl in PROBE_PATHS: + path = tmpl.format(s=f"{d}0000", e=f"{d}2359", d=d) + row: dict[str, Any] = {"key": key, "label": label, "path": path.split("/" + d)[0] + "/…"} + try: + body = self._get(ctx, path) + except AdapterError as exc: + out.append({**row, "ok": False, "error": exc.message[:200]}) + continue + records = xml_records(body) + out.append({**row, "ok": True, "count": len(records), "fields": field_summary(records)}) + return {"date": day.isoformat(), "probes": out} + def test_connection(self, ctx: AdapterContext) -> str: from app.timezone import today_kst # noqa: WPS433 diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index 0fc29ca..eb8094b 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 71a95e3..98537f4 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -116,6 +116,18 @@
+
+

11번가 원본 데이터 확인

+

11번가 셀러 API 의 주문·클레임 조회 주소를 그날(00:00~23:59)로 실제 불러, 어느 주소가 동작하는지와 + 받은 항목·금액 합계를 보여 줍니다(저장하지 않음). 셀러오피스에서 매출이 있던 날을 넣고 결과를 알려 주시면 그 항목으로 + 매출 수집을 맞춥니다. 이름·연락처·주소 같은 개인정보는 값을 보이지 않습니다.

+
+ + +
+
+
+

카페24 매출 대조

카페24 관리자 → 통계 → 일별 매출내역과 같은 날짜를 비교합니다. 그날 결제 주문과 환불을 카페24 API 에서 @@ -155,4 +167,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 618f950..4989d20 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -852,6 +852,26 @@ def test_elevenst_connection(): assert status == 403 or "허용되지 않은 IP" in exc.message or "XML 아님" in exc.message else: raise AssertionError("오류여야 합니다") + # 원본 데이터 확인: 살아 있는 주소는 항목 합계, 없는 주소(404)는 실패로. 개인정보 값은 숨김 + rows = ("" + "".join( + f"{n}{a}홍길동상품{n}" + f"2026-09-29 10:00:00" for n, a in ((1, 10000), (2, 5500))) + + "").encode() + + def route(url, headers=None, timeout=None): + if "/ordservices/complete/" in url: + return httpx.Response(200, content=rows) + if "/ordservices/" in url: + return httpx.Response(200, content=b"") + return httpx.Response(404, content=b"not found") + httpx.get = route + rec = ev.ElevenstAdapter().reconcile(ctx, date(2026, 9, 29)) + by = {p["key"]: p for p in rec["probes"]} + assert by["complete"]["ok"] and by["complete"]["count"] == 2 and by["shipping"]["count"] == 0 + assert not by["canceledorders"]["ok"] and "404" in by["canceledorders"]["error"] + f = {x["name"]: x for x in by["complete"]["fields"]} + assert f["ordPayAmt"]["sum"] == 15_500 and f["rcvrNm"]["personal"] and f["rcvrNm"]["sample"] == "" + assert f["prdNm"]["sample"] == "상품1" and "홍길동" not in repr(rec) finally: httpx.get = orig diff --git a/app/static/performance.js b/app/static/performance.js index 94fcfc4..841c81a 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -826,6 +826,39 @@ } }); + // ── 11번가 원본 데이터 확인 — 후보 조회 주소별 동작 여부·항목 합계 ── + const probe = document.getElementById("perf-probe"); + if (probe) probe.addEventListener("click", async function () { + const day = document.getElementById("perf-probe-date").value; + const out = document.getElementById("perf-probe-result"); + if (!day) return; + probe.disabled = true; + out.innerHTML = '

11번가에서 불러오는 중… (주소 9개)

'; + try { + const r = await api("GET", "/performance/api/marketplaces/" + probe.dataset.code + "/reconcile?date=" + encodeURIComponent(day)); + if (!r.ok) { out.innerHTML = '

' + esc((r.label ? r.label + " — " : "") + r.message) + "

"; return; } + const summary = '' + + '' + + r.probes.map(function (p) { + return '"; + }).join("") + "
조회주소결과건수
' + esc(p.label) + '' + esc(p.path) + "" + + (p.ok ? '동작' : '실패 ' + esc(p.error) + "") + + '' + (p.ok ? fmt(p.count) : "") + "
"; + const details = r.probes.filter(function (p) { return p.ok && p.count; }).map(function (p) { + return '

' + esc(p.label) + " — " + fmt(p.count) + "줄

" + + '' + + '' + + p.fields.map(function (f) { + return '"; + }).join("") + "
항목채워진 줄숫자 합계예시 값
' + esc(f.name) + '' + fmt(f.filled) + '' + + (f.sum == null ? "" : fmt(f.sum)) + "" + (f.personal ? '개인정보(숨김)' : esc(f.sample)) + "
"; + }).join(""); + out.innerHTML = summary + (details || '

그날 조회된 주문이 없습니다. 셀러오피스에서 매출이 있던 날로 다시 해 보세요.

'); + } catch (err) { + out.innerHTML = '

' + esc(err.message) + "

"; + } finally { probe.disabled = false; } + }); + // ── 과거 매출 가져오기(기간 지정 수집, 관리자) ── const backfill = document.getElementById("perf-backfill"); if (backfill) backfill.addEventListener("click", async function () { From 7d96f2e738c120a54a2cf0c317e4e5879c01a55a Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 01:14:32 +0900 Subject: [PATCH 28/30] =?UTF-8?q?fix(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EC=9B=90=EB=B3=B8=20=EB=8D=B0=EC=9D=B4=ED=84=B0=20=ED=99=95?= =?UTF-8?q?=EC=9D=B8=20=E2=80=94=20"=ED=95=B4=EB=8B=B9=20=EA=B1=B4=20?= =?UTF-8?q?=EC=97=86=EC=9D=8C"=EC=9D=80=200=EA=B1=B4,=20=EA=B8=B0=EA=B0=84?= =?UTF-8?q?=20=EC=A1=B0=ED=9A=8C=C2=B7=EA=B5=AC=EB=A7=A4=ED=99=95=EC=A0=95?= =?UTF-8?q?=20=ED=9B=84=EB=B3=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 9/9 확인 결과: 취소·반품 주소는 코드 -1 "해당 건이 없습니다"(= 0건)인데 실패로 표시했고, 주문 목록 4개는 지금 그 상태인 주문만 주는 듯해 이미 구매확정된 9/9 주문이 어디에도 없었다. 정산 내역은 정산확정일 기준일 가능성이 있다. - 결과 문구가 "해당 건이 없습니다" 류면 오류가 아니라 0건 - 기간 조회(최대 31일, 7일씩 나눠 호출) — 매출일부터 정산확정일까지 넓게 확인 - 구매확정 목록 후보 주소 추가 - 테스트 갱신 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 47 ++++++++++++------- app/modules/performance/router.py | 4 +- app/modules/performance/sync.py | 4 +- .../templates/performance/index.html | 2 +- .../templates/performance/settings.html | 9 ++-- .../performance/tests/test_performance.py | 10 +++- app/static/performance.js | 6 ++- 7 files changed, 55 insertions(+), 27 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index 7416777..c3cabf9 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -13,7 +13,7 @@ from __future__ import annotations import re import xml.etree.ElementTree as ET -from datetime import date +from datetime import date, timedelta from typing import Any from .base import AdapterContext, AdapterError, ApiError, AuthFailed, CredentialField, MarketplaceAdapter @@ -65,8 +65,12 @@ PROBE_PATHS: tuple[tuple[str, str, str], ...] = ( ("canceledorders", "취소완료", "/rest/claimservice/canceledorders/{s}/{e}"), ("returnorders", "반품신청", "/rest/claimservice/returnorders/{s}/{e}"), ("returnedorders", "반품완료", "/rest/claimservice/returnedorders/{s}/{e}"), - ("settlement", "정산 내역", "/rest/settlement/settlementList/{d}/{d}"), + ("purchaseconfirm", "구매확정(후보)", "/rest/ordservices/purchaseconfirm/{s}/{e}"), + ("settlement", "정산 내역", "/rest/settlement/settlementList/{ds}/{de}"), ) +NO_DATA = re.compile(r"해당\s*건이\s*없|조회된?\s*(내역|건|데이터)이?\s*없") # 코드 -1 이어도 "0건" +PROBE_CHUNK_DAYS = 7 +PROBE_MAX_DAYS = 31 # 개인정보로 보이는 항목 — 값은 보이지 않고 이름만(이름·연락처·주소·우편번호·아이디·메일·메모) PERSONAL = re.compile(r"(nm|name|tel|tlphn|phone|hp|addr|zip|mail|id|memo|msg|pcc|clearance|birth)$|rcvr|ordnm|buyer", @@ -139,29 +143,40 @@ class ElevenstAdapter(MarketplaceAdapter): raise ApiError(f"11번가 API 오류({res.status_code}): {detail}") if code == "not-xml": raise ApiError(f"11번가가 예상하지 못한 응답을 돌려줬습니다(XML 아님): {res.text[:120].strip()}") - if code and code not in ("0", "200", "00"): + if code and code not in ("0", "200", "00") and not NO_DATA.search(text): raise ApiError(f"11번가 API 오류(코드 {code}): {detail}") return res.content # ── 원본 데이터 확인(설정 화면 "11번가 원본 데이터 확인") ───────── - def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]: - """후보 조회 주소마다 그날(00:00~23:59) 실제로 불러 동작 여부·주문 수·항목별 합계를 돌려준다. + def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]: + """후보 조회 주소마다 기간(day~to, 최대 31일, 7일씩 나눠)을 실제로 불러 동작 여부·줄 수·항목별 합계를 돌려준다. 셀러 API 상세 문서가 로그인 뒤에만 있어, 어느 주소·항목이 셀러오피스 화면 매출과 맞는지 실데이터로 확정하는 용도. 개인정보 항목(이름·연락처·주소·아이디 등)은 값 없이 이름만.""" self.authenticate(ctx) - d = day.strftime("%Y%m%d") + to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1)) + chunks = [] + s = day + while s <= to: + e = min(to, s + timedelta(days=PROBE_CHUNK_DAYS - 1)) + chunks.append((s, e)) + s = e + timedelta(days=1) out = [] for key, label, tmpl in PROBE_PATHS: - path = tmpl.format(s=f"{d}0000", e=f"{d}2359", d=d) - row: dict[str, Any] = {"key": key, "label": label, "path": path.split("/" + d)[0] + "/…"} - try: - body = self._get(ctx, path) - except AdapterError as exc: - out.append({**row, "ok": False, "error": exc.message[:200]}) - continue - records = xml_records(body) - out.append({**row, "ok": True, "count": len(records), "fields": field_summary(records)}) - return {"date": day.isoformat(), "probes": out} + row: dict[str, Any] = {"key": key, "label": label, "path": tmpl.split("/{")[0] + "/…"} + records: list[dict[str, str]] = [] + error = "" + for s, e in chunks: + ds, de = s.strftime("%Y%m%d"), e.strftime("%Y%m%d") + try: + records += xml_records(self._get(ctx, tmpl.format(s=f"{ds}0000", e=f"{de}2359", ds=ds, de=de))) + except AdapterError as exc: + error = exc.message[:200] + break + if error: + out.append({**row, "ok": False, "error": error}) + else: + out.append({**row, "ok": True, "count": len(records), "fields": field_summary(records)}) + return {"date": day.isoformat(), "to": to.isoformat(), "probes": out} def test_connection(self, ctx: AdapterContext) -> str: from app.timezone import today_kst # noqa: WPS433 diff --git a/app/modules/performance/router.py b/app/modules/performance/router.py index e7e408c..cbec390 100644 --- a/app/modules/performance/router.py +++ b/app/modules/performance/router.py @@ -279,13 +279,13 @@ def api_test_connection(request: Request, code: str, payload: dict[str, Any] = B @router.get("/api/marketplaces/{code}/reconcile") -def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="date")) -> JSONResponse: +def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="date"), to: str | None = None) -> JSONResponse: """쇼핑몰 화면(예: 카페24 일별 매출내역)과 비교용 — 그날 원천 금액 항목별 합계. DB 는 바꾸지 않는다.""" store, user = common.require_store(request, admin=True) _code_or_404(store, code) day = _parse_date(date_) _, sync = common.services(request, store) - return JSONResponse(sync.reconcile(code, day, user=user["email"])) + return JSONResponse(sync.reconcile(code, day, to=_parse_date(to, field="종료일"), user=user["email"])) @router.get("/api/marketplaces/{code}/daily-check") diff --git a/app/modules/performance/sync.py b/app/modules/performance/sync.py index b0c1792..12f01d8 100644 --- a/app/modules/performance/sync.py +++ b/app/modules/performance/sync.py @@ -139,7 +139,7 @@ class SyncService: 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]: + def reconcile(self, code: str, day: date, *, to: date | None = None, user: str = "") -> dict[str, Any]: """어댑터가 지원하면(reconcile) 그날 원천 금액을 항목별로 합산해 돌려준다. DB 는 바꾸지 않는다.""" adapter = get_adapter(code) if adapter is None or not hasattr(adapter, "reconcile"): @@ -147,7 +147,7 @@ class SyncService: ctx = None try: ctx = self._ctx(adapter, user=user) - return {"ok": True, **adapter.reconcile(ctx, day)} + return {"ok": True, **(adapter.reconcile(ctx, day, to=to) if to else 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} diff --git a/app/modules/performance/templates/performance/index.html b/app/modules/performance/templates/performance/index.html index eb8094b..d5bc6c3 100644 --- a/app/modules/performance/templates/performance/index.html +++ b/app/modules/performance/templates/performance/index.html @@ -239,4 +239,4 @@ } | tojson }} {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/templates/performance/settings.html b/app/modules/performance/templates/performance/settings.html index 98537f4..3c3f8fd 100644 --- a/app/modules/performance/templates/performance/settings.html +++ b/app/modules/performance/templates/performance/settings.html @@ -118,11 +118,14 @@

11번가 원본 데이터 확인

-

11번가 셀러 API 의 주문·클레임 조회 주소를 그날(00:00~23:59)로 실제 불러, 어느 주소가 동작하는지와 - 받은 항목·금액 합계를 보여 줍니다(저장하지 않음). 셀러오피스에서 매출이 있던 날을 넣고 결과를 알려 주시면 그 항목으로 +

11번가 셀러 API 의 주문·클레임·정산 조회 주소를 기간(최대 31일)으로 실제 불러, 어느 주소가 동작하는지와 + 받은 항목·금액 합계를 보여 줍니다(저장하지 않음). 주문 목록은 지금 그 상태인 주문만, 정산은 정산일 기준일 수 있어 + 매출이 있던 날부터 넉넉히(예: 3주) 잡아 주세요. 셀러오피스에서 매출이 있던 날을 넣고 결과를 알려 주시면 그 항목으로 매출 수집을 맞춥니다. 이름·연락처·주소 같은 개인정보는 값을 보이지 않습니다.

+ ~ +
@@ -167,4 +170,4 @@ {% endblock %} -{% block scripts %}{% endblock %} +{% block scripts %}{% endblock %} diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 4989d20..c0a7820 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -861,14 +861,22 @@ def test_elevenst_connection(): def route(url, headers=None, timeout=None): if "/ordservices/complete/" in url: return httpx.Response(200, content=rows) + if "/ordservices/purchaseconfirm/" in url: + return httpx.Response(404, content=b"not found") if "/ordservices/" in url: return httpx.Response(200, content=b"") + if "/claimservice/" in url: + return httpx.Response(200, content="-1" + "해당 건이 없습니다.".encode()) return httpx.Response(404, content=b"not found") httpx.get = route rec = ev.ElevenstAdapter().reconcile(ctx, date(2026, 9, 29)) + wide = ev.ElevenstAdapter().reconcile(ctx, date(2026, 9, 1), to=date(2026, 9, 20)) # 7일씩 3번 + assert wide["to"] == "2026-09-20" and {p["key"]: p.get("count") for p in wide["probes"]}["complete"] == 6 by = {p["key"]: p for p in rec["probes"]} assert by["complete"]["ok"] and by["complete"]["count"] == 2 and by["shipping"]["count"] == 0 - assert not by["canceledorders"]["ok"] and "404" in by["canceledorders"]["error"] + assert not by["purchaseconfirm"]["ok"] and "404" in by["purchaseconfirm"]["error"] + assert by["canceledorders"]["ok"] and by["canceledorders"]["count"] == 0 # 코드 -1 "해당 건이 없습니다" = 0건 f = {x["name"]: x for x in by["complete"]["fields"]} assert f["ordPayAmt"]["sum"] == 15_500 and f["rcvrNm"]["personal"] and f["rcvrNm"]["sample"] == "" assert f["prdNm"]["sample"] == "상품1" and "홍길동" not in repr(rec) diff --git a/app/static/performance.js b/app/static/performance.js index 841c81a..7dcc954 100644 --- a/app/static/performance.js +++ b/app/static/performance.js @@ -833,9 +833,11 @@ const out = document.getElementById("perf-probe-result"); if (!day) return; probe.disabled = true; - out.innerHTML = '

11번가에서 불러오는 중… (주소 9개)

'; + out.innerHTML = '

11번가에서 불러오는 중… (주소 10개 × 7일 단위, 기간이 길면 1분 이상)

'; try { - const r = await api("GET", "/performance/api/marketplaces/" + probe.dataset.code + "/reconcile?date=" + encodeURIComponent(day)); + const to = document.getElementById("perf-probe-to").value || day; + const r = await api("GET", "/performance/api/marketplaces/" + probe.dataset.code + "/reconcile?date=" + encodeURIComponent(day) + + "&to=" + encodeURIComponent(to)); if (!r.ok) { out.innerHTML = '

' + esc((r.label ? r.label + " — " : "") + r.message) + "

"; return; } const summary = '' + '' + From 40d94e28922be31887d32bd3b0a1ca6c5855e3c7 Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 01:20:18 +0900 Subject: [PATCH 29/30] =?UTF-8?q?feat(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=EC=88=98=EC=A7=91=20=E2=80=94=20?= =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=83=81=ED=83=9C=20=EB=AA=A9=EB=A1=9D=20?= =?UTF-8?q?=EA=B8=B0=EC=A4=80,=20=EA=B2=B0=EC=A0=9C=EC=9D=BC=C2=B7?= =?UTF-8?q?=ED=8C=90=EB=A7=A4=EA=B8=88=EC=95=A1+=EB=B0=B0=EC=86=A1?= =?UTF-8?q?=EB=B9=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit "11번가 원본 데이터 확인"(9/9~9/29) 실데이터로 확정: - 주문 상태 목록(결제완료·발송대기·배송중·배송완료)은 지금 그 상태인 주문만 주고, 배송완료 목록에 구매확정 주문도 남는다. 취소된 주문은 취소완료 목록으로 빠진다 - ordAmt − ordPayAmt = 11번가 부담 쿠폰(tmallApplyDscAmt 11,060), 수수료는 판매금액 기준(34,900 × 13% = 4,537) - fetch_orders: 목록 4개를 [기간, 기간+30일(오늘까지)] 7일씩 불러 주문일(결제일)이 기간 안인 줄만, 주문번호+순번 중복 제거 - SALE 금액 = ordAmt + 배송비(주문번호마다 최댓값을 가장 앞 줄에 한 번), ordAmt − ordPayAmt 는 discount_amount 에. 구매자 정보는 raw 에 넣지 않음 - replace_range(11st: 접두어) — 다시 받으면 취소·반품된 주문이 빠진다 - "해당 건이 없습니다"(-1)는 0건. 테스트 추가, 미구현 시험은 G마켓으로 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 111 ++++++++++++++++-- .../performance/tests/test_performance.py | 61 +++++++++- docs/PERFORMANCE_MODULE.md | 16 +++ 3 files changed, 178 insertions(+), 10 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index c3cabf9..c0fe7e2 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -3,10 +3,14 @@ 인증: 셀러오피스(openapi.11st.co.kr → 서비스등록·확인)에서 발급한 Open API Key 를 요청 헤더 `openapikey` 에 넣는다. 셀러 API 는 등록한 IP 에서만 호출된다("Seller API 정보 수정"에서 서버 IP 등록, 셀링툴(사방넷 등)과 함께 쓸 수 있음). (공식 이용방법 openapi.11st.co.kr → OpenApiOperationGuide SERVICE_METHOD, 2026-09-30 확인) +응답은 XML(euc-kr). 없는 주소는 500 + resultCode -997 "등록된 API 정보가 존재하지 않습니다", 건이 없으면 -1 "해당 건이 없습니다". -연결 테스트는 결제완료(발주확인할) 주문 목록을 오늘 하루로 조회한다 — GET /rest/ordservices/complete/{시작}/{끝} -(yyyyMMddHHmm). 엔드포인트 상세 문서는 로그인 뒤에만 보여 널리 쓰이는 경로를 쓰고, 실제 호출 결과로 확인한다. -응답은 XML. 매출 수집(fetch_orders)은 맞출 셀러오피스 화면을 정한 뒤 구현한다. +매출(2026-09-30 실데이터로 확정 — 설정 화면 "11번가 원본 데이터 확인"): + - 주문 상태 목록 4개(결제완료·발송대기·배송중·배송완료)는 지금 그 상태인 주문만 준다. 배송완료 목록에 구매확정 주문도 남는다. + - SALE = 주문 한 줄, 날짜 = 결제일(ordStlEndDt, 없으면 주문일 ordDt), 금액 = ordAmt(판매금액, 11번가 부담 쿠폰 전) + + 배송비(dlvCst, 주문번호당 한 번). ordAmt − ordPayAmt = 11번가 부담 할인(tmallApplyDscAmt). 수수료는 판매금액 기준. + - 취소·반품된 주문은 목록에서 빠진다 → 기간을 통째로 다시 받아(replace_range) 매출에서 빠진다(취소 사건을 따로 만들지 않음). + - 정산 내역(/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd})은 정산확정일(stlDy) 기준 — 확인 도구에서만 쓴다. """ from __future__ import annotations @@ -14,9 +18,17 @@ from __future__ import annotations import re import xml.etree.ElementTree as ET from datetime import date, timedelta -from typing import Any +from typing import Any, Iterable -from .base import AdapterContext, AdapterError, ApiError, AuthFailed, CredentialField, MarketplaceAdapter +from .base import ( + AdapterContext, + AdapterError, + ApiError, + AuthFailed, + CredentialField, + MarketplaceAdapter, + SaleEvent, +) HOST = "https://api.11st.co.kr" @@ -114,10 +126,45 @@ def field_summary(records: list[dict[str, str]]) -> list[dict[str, Any]]: return list(names.values()) +# 매출 수집 — 주문 상태 목록 4개(지금 그 상태인 주문만 준다). 배송완료 목록에는 구매확정된 주문도 남는다(실데이터 확인). +# 취소·반품된 주문은 이 목록들에서 빠진다 → 기간을 통째로 다시 받아(replace_range) 매출에서 자연히 빠지게 한다. +ORDER_PATHS = ("/rest/ordservices/complete/{s}/{e}", "/rest/ordservices/packaging/{s}/{e}", + "/rest/ordservices/shipping/{s}/{e}", "/rest/ordservices/completed/{s}/{e}") +ORDER_STATUS = {"complete": "결제완료", "packaging": "발송대기", "shipping": "배송중", "completed": "배송완료"} +# 목록의 날짜 조건이 주문일인지 상태 변경일(배송완료일 등)인지 문서로 확인 못 해, 기간 뒤로 넉넉히 더 불러 +# 주문일로 거른다(나중에 배송완료된 주문도 빠지지 않게). +LOOKAHEAD_DAYS = 30 +EVENT_PREFIX = "11st:" +# raw 에 남길 항목 — 금액·날짜·상태·상품만(구매자 정보 제외) +RAW_KEEP = ("ordNo", "ordPrdSeq", "ordDt", "ordStlEndDt", "ordAmt", "ordPayAmt", "dlvCst", "ordQty", "prdNo", + "atmtBuyCnfrmYN", "pocnfrmDt", "selPrc", "ordPrdStat") + + +def _won(value: Any) -> int: + try: + return int(round(float(str(value or "0").replace(",", "")))) + except ValueError: + return 0 + + +def _day(value: Any) -> date | None: + """"2026-09-09 15:13:16" / "2026/09/09" / "20260909" → date.""" + s = re.sub(r"[^0-9]", "", str(value or ""))[:8] + if len(s) < 8: + return None + try: + return date(int(s[:4]), int(s[4:6]), int(s[6:8])) + except ValueError: + return None + + class ElevenstAdapter(MarketplaceAdapter): code = "elevenst" name = "11번가" auth_type = "api_key" + implemented = True + replace_range = True + event_prefix = EVENT_PREFIX docs_url = "https://openapi.11st.co.kr/" note = ("11번가 셀러오피스 → 오픈API 에서 발급한 키를 입력합니다. 셀러 API 는 등록한 IP 에서만 호출되므로 " "'Seller API 정보 수정 → IP 직접 입력'에 이 서버의 외부 IP 를 넣어야 합니다.") @@ -127,6 +174,57 @@ class ElevenstAdapter(MarketplaceAdapter): CredentialField("api_key", "Open API Key", secret=True), ] + # ── 수집 ────────────────────────────────────────────── + def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: + """주문 상태 목록 4개를 [start, end+30일(오늘까지)] 7일씩 불러 주문일이 [start, end] 인 줄만. + 같은 줄(주문번호+순번)이 두 목록에 나오면(조회 사이 상태 변경) 한 번만. + 배송비는 주문번호마다 줄들의 dlvCst 최댓값을 가장 앞 순번 줄에 한 번(_ship).""" + from app.timezone import today_kst # noqa: WPS433 + + hi = max(end, min(end + timedelta(days=LOOKAHEAD_DAYS), today_kst())) + seen: set[str] = set() + rows: list[dict[str, Any]] = [] + for tmpl in ORDER_PATHS: + status = ORDER_STATUS[tmpl.split("/")[3]] + s = start + while s <= hi: + e = min(hi, s + timedelta(days=PROBE_CHUNK_DAYS - 1)) + body = self._get(ctx, tmpl.format(s=s.strftime("%Y%m%d") + "0000", e=e.strftime("%Y%m%d") + "2359")) + for r in xml_records(body): + key = f"{r.get('ordNo')}-{r.get('ordPrdSeq')}" + day = _day(r.get("ordStlEndDt") or r.get("ordDt")) + if not r.get("ordNo") or key in seen or day is None or not (start <= day <= end): + continue + seen.add(key) + rows.append({**r, "_status": status}) + s = e + timedelta(days=1) + ship: dict[str, tuple[int, int]] = {} # 주문번호 → (배송비, 가장 앞 순번) + for r in rows: + oid, seq = str(r["ordNo"]), _won(r.get("ordPrdSeq")) + cur = ship.get(oid, (0, seq)) + ship[oid] = (max(cur[0], _won(r.get("dlvCst"))), min(cur[1], seq)) + for r in rows: + fee, first = ship[str(r["ordNo"])] + yield {**r, "_ship": fee if _won(r.get("ordPrdSeq")) == first else 0} + + def normalize_order(self, r: dict[str, Any]) -> list[SaleEvent]: + """주문 한 줄 → SALE. 금액 = 판매금액(ordAmt, 11번가 부담 쿠폰 전) + 배송비(_ship, 주문번호당 한 줄). + 수수료가 판매금액 기준이라(34,900 × 13% = 4,537, 정산 실데이터) 판매자 매출은 할인 전 금액으로 본다.""" + oid, seq = str(r.get("ordNo") or ""), str(r.get("ordPrdSeq") or "") + day = _day(r.get("ordStlEndDt") or r.get("ordDt")) + if not oid or day is None: + return [] + amount = _won(r.get("ordAmt")) + _won(r.get("_ship")) + opt = str(r.get("slctPrdOptNm") or "") + return [SaleEvent( + event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}-{seq}", external_order_id=oid, + external_line_id=seq, order_date=_day(r.get("ordDt")), payment_date=day, event_date=day, + amount=max(0, amount), product_name=str(r.get("prdNm") or "")[:200], option_name=opt[:200], + quantity=int(_won(r.get("ordQty"))), discount_amount=max(0, _won(r.get("ordAmt")) - _won(r.get("ordPayAmt"))), + order_status=str(r.get("_status") or ""), + raw={k: r.get(k) for k in RAW_KEEP if r.get(k) not in (None, "")}, + )] + def _get(self, ctx: AdapterContext, path: str) -> bytes: import httpx # 지연 import @@ -185,5 +283,4 @@ class ElevenstAdapter(MarketplaceAdapter): d = today_kst().strftime("%Y%m%d") body = self._get(ctx, f"/rest/ordservices/complete/{d}0000/{d}2359") _, _, orders = xml_result(body) - return (f"11번가 연결 정상(주문 조회 권한 확인, 오늘 결제완료 {orders}건). " - "매출 수집은 다음 단계에서 구현됩니다.") + return f"11번가 연결 정상(주문 조회 권한 확인, 오늘 결제완료 {orders}건)." diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index c0a7820..5782473 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -383,10 +383,12 @@ def test_not_implemented_and_mock(): st = FakeStore() creds = CredentialService(st, lambda: ring()) svc = SyncService(st, creds) - r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29)) + gm = next(a for a in all_adapters() if a.code == "gmarket") + r = svc.sync_marketplace("gmarket", date(2026, 9, 29), date(2026, 9, 29)) assert r["status"] == "not_configured" # 키 미입력 - creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "k-123456"}) - r = svc.sync_marketplace("elevenst", date(2026, 9, 29), date(2026, 9, 29)) + secret = next(f.key for f in gm.visible_fields() if f.secret) + creds.save(gm, {f.key: ("k-123456" if f.key == secret else "v") for f in gm.visible_fields()}) + r = svc.sync_marketplace("gmarket", date(2026, 9, 29), date(2026, 9, 29)) assert r["status"] == "not_implemented" and "k-123456" not in r["message"] import httpx orig_get, httpx.get = httpx.get, (lambda url, headers=None, timeout=None: httpx.Response(200, content=b"")) @@ -884,6 +886,59 @@ def test_elevenst_connection(): httpx.get = orig +def test_elevenst_collect_sales(): + """11번가 매출 = 주문 상태 목록(결제완료·발송대기·배송중·배송완료)의 줄, 결제일(없으면 주문일) 기준, + 금액 = ordAmt + 배송비(주문번호마다 최댓값을 가장 앞 줄에 한 번). 같은 줄이 두 목록에 나와도 한 번, 기간 밖 주문일은 제외. + 실데이터 9/9: ordAmt 34,900 / ordPayAmt 34,900, 9/10: ordAmt 83,800 / ordPayAmt 72,740(11번가 쿠폰 11,060).""" + import httpx + + import app.modules.performance.sync as syncmod + import app.timezone as _tz + from app.modules.performance.adapters import elevenst as ev + + def line(no, seq, day, amt, pay, ship=0, qty=1): + return (f"{no}{seq}{day} 15:13:16" + f"{amt}{pay}{ship}{qty}" + f"밀폐용기홍길동18550503") + completed = ("" + line("20260909099415322", 1, "2026-09-09", 34900, 34900) + + line("20260910099718265", 1, "2026-09-10", 83800, 72740, qty=2) + + line("20260910099718265", 2, "2026-09-10", 10000, 10000, ship=3000) + + line("20260801000000001", 1, "2026-08-01", 5000, 5000) + "").encode() + packaging = ("" + line("20260909099415322", 1, "2026-09-09", 34900, 34900) + + line("20260911000000002", 1, "2026-09-11", 20000, 20000, ship=3000) + "").encode() + empty = "-1해당 건이 없습니다.".encode() + calls = [] + + def route(url, headers=None, timeout=None): + calls.append(url) + if "/ordservices/completed/" in url: + return httpx.Response(200, content=completed) + if "/ordservices/packaging/" in url: + return httpx.Response(200, content=packaging) + return httpx.Response(200, content=empty) + + st = FakeStore() + creds = CredentialService(st, lambda: ring()) + creds.save(next(a for a in all_adapters() if a.code == "elevenst"), {"api_key": "KEY-11ST"}) + orig, orig_today = httpx.get, _tz.today_kst + httpx.get, _tz.today_kst = route, (lambda: date(2026, 9, 30)) + try: + r = SyncService(st, creds).sync_marketplace("elevenst", date(2026, 9, 9), date(2026, 9, 11)) + finally: + httpx.get, _tz.today_kst = orig, orig_today + assert r["ok"], r + ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "elevenst"} + assert set(ev_) == {"11st:20260909099415322-1", "11st:20260910099718265-1", "11st:20260910099718265-2", + "11st:20260911000000002-1"} # 중복 1번, 8/1 주문 제외 + assert ev_["11st:20260909099415322-1"]["amount"] == 34_900 and ev_["11st:20260909099415322-1"]["sales_date"] == date(2026, 9, 9) + assert ev_["11st:20260910099718265-1"]["amount"] == 83_800 + 3_000 # 2번 줄의 배송비를 앞 줄에 한 번 + assert ev_["11st:20260910099718265-1"]["discount_amount"] == 11_060 + assert ev_["11st:20260910099718265-2"]["amount"] == 10_000 + assert ev_["11st:20260911000000002-1"]["amount"] == 23_000 + assert "홍길동" not in repr(st.events) and "18550503" not in repr(st.events) # 구매자 정보 미저장 + assert any("/20260930" in u for u in calls) and not any("/20261001" in u for u in calls) # 오늘까지만 더 불러옴 + + def test_registry_and_event_validation(): codes = [a.code for a in all_adapters()] assert len(codes) == len(set(codes)) == 10 diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 7815cac..4ff165b 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -83,6 +83,22 @@ 그 주문의 마지막 클레임 품목에 한 번 더한다. 톡체크아웃·자체몰의 환불 기록 없는 취소는 카페24 환불합계에 없음 (9/4: 98,700 + 네이버페이 19,900 + 배송비 3,500 = 122,100 / 9/16: 톡체크아웃 취소 9,900 제외 → 201,100). +### 11번가 (`adapters/elevenst.py`, 구현됨) + +- 인증: 셀러오피스 Open API Key → 헤더 `openapikey`. **셀러 API 는 등록 IP 에서만** 호출된다(Seller API 정보 수정 → + IP 직접 입력에 운영 서버 외부 IP, 셀링툴 사방넷과 함께 사용 가능). 응답은 XML(euc-kr 선언 → 직접 디코딩). +- 없는 주소 = 500 + `-997 등록된 API 정보가 존재하지 않습니다`, 건 없음 = `-1 해당 건이 없습니다`(0건으로 처리). +- 상세 문서가 로그인 뒤에만 있어 설정 화면 **"11번가 원본 데이터 확인"**(`reconcile(day, to)`, 후보 주소별 동작·항목 합계, + 개인정보 값 숨김)으로 실데이터를 보고 확정했다(2026-09-30). +- 주문 상태 목록 4개(`/rest/ordservices/complete|packaging|shipping|completed/{yyyyMMddHHmm}/{…}`)는 **지금 그 상태인 주문만** + 준다. 배송완료 목록에 구매확정 주문도 남는다. 취소·반품된 주문은 목록에서 빠지고 `/rest/claimservice/canceledorders|…` 에 있다. +- SALE = 주문 한 줄(`11st:{ordNo}-{ordPrdSeq}`), 날짜 = 결제일(`ordStlEndDt`, 없으면 주문일 `ordDt`), 금액 = `ordAmt` + (판매금액, 11번가 부담 쿠폰 전) + 배송비(`dlvCst`, 주문번호마다 최댓값을 가장 앞 줄에 한 번). `ordAmt − ordPayAmt` = 11번가 + 부담 할인(`discount_amount` 에 기록). 수수료는 판매금액 기준(정산 `selFee` = 34,900 × 13%). +- `replace_range` — 기간을 통째로 다시 받아 취소·반품된 주문이 매출에서 빠진다(취소 사건을 따로 만들지 않음 → 지난 날짜 + 금액이 나중에 줄 수 있음). 목록의 날짜 조건이 주문일인지 상태 변경일인지 몰라 **기간 뒤 30일(오늘까지)을 더 불러 주문일로 거른다.** +- 정산 내역 `/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}` 은 정산확정일(`stlDy`) 기준 — 확인 도구에서만 쓴다. + ### 연동 단계 체크리스트(쇼핑몰마다) - 공식 문서로 인증 방식·호출 제한·페이지네이션·주문 상태 코드·취소/반품 API·날짜 필드 확인 From f037ea7de0100445703a3a0bdc35b56173df49d0 Mon Sep 17 00:00:00 2001 From: king Date: Wed, 30 Sep 2026 01:24:58 +0900 Subject: [PATCH 30/30] =?UTF-8?q?fix(performance):=2011=EB=B2=88=EA=B0=80?= =?UTF-8?q?=20=EB=A7=A4=EC=B6=9C=20=E2=80=94=20=EC=A0=95=EC=82=B0=EB=90=9C?= =?UTF-8?q?=20=EC=A3=BC=EB=AC=B8=EC=9D=80=20=EC=A0=95=EC=82=B0=20=ED=8C=90?= =?UTF-8?q?=EB=A7=A4=EA=B8=88=EC=95=A1=ED=95=A9=EA=B3=84(=EB=B0=B0?= =?UTF-8?q?=EC=86=A1=EB=B9=84=20=EC=A4=84=20=ED=8F=AC=ED=95=A8)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 셀러오피스 "판매 상세내역"(정산) 대조: 9/10 주문은 상품 83,800 + 배송비 줄 3,000 = 86,800 인데 주문 목록의 dlvCst 는 0 이라 주문 목록만으로는 3,000 이 빠진다. 정산 API 의 selPrcAmt 합(121,700 = 34,900 + 3,000 + 83,800)은 판매 상세내역과 같다. - 정산 내역을 [기간, 기간+45일(오늘까지)] 불러 결제일(ordStlEndDt)로 거르고 주문별 selPrcAmt 합을 매출로(정산확정 상태, cupnAmt = 11번가 부담 할인) - 정산 전 주문만 주문 상태 목록의 ordAmt + 배송비 - 사건을 주문 단위(11st:{ordNo})로 — 정산 전/후가 같은 ID 라 바뀌어도 한 건 - 테스트·문서 갱신 Co-Authored-By: Claude Opus 5.5 --- app/modules/performance/adapters/elevenst.py | 124 +++++++++++------- .../performance/tests/test_performance.py | 40 +++--- docs/PERFORMANCE_MODULE.md | 13 +- 3 files changed, 112 insertions(+), 65 deletions(-) diff --git a/app/modules/performance/adapters/elevenst.py b/app/modules/performance/adapters/elevenst.py index c0fe7e2..43e50db 100644 --- a/app/modules/performance/adapters/elevenst.py +++ b/app/modules/performance/adapters/elevenst.py @@ -5,12 +5,15 @@ (공식 이용방법 openapi.11st.co.kr → OpenApiOperationGuide SERVICE_METHOD, 2026-09-30 확인) 응답은 XML(euc-kr). 없는 주소는 500 + resultCode -997 "등록된 API 정보가 존재하지 않습니다", 건이 없으면 -1 "해당 건이 없습니다". -매출(2026-09-30 실데이터로 확정 — 설정 화면 "11번가 원본 데이터 확인"): - - 주문 상태 목록 4개(결제완료·발송대기·배송중·배송완료)는 지금 그 상태인 주문만 준다. 배송완료 목록에 구매확정 주문도 남는다. - - SALE = 주문 한 줄, 날짜 = 결제일(ordStlEndDt, 없으면 주문일 ordDt), 금액 = ordAmt(판매금액, 11번가 부담 쿠폰 전) - + 배송비(dlvCst, 주문번호당 한 번). ordAmt − ordPayAmt = 11번가 부담 할인(tmallApplyDscAmt). 수수료는 판매금액 기준. +매출(2026-09-30 실데이터·셀러오피스 "판매 상세내역"으로 확정): + - SALE = 주문 하나(`11st:{ordNo}`), 날짜 = 결제일. + - 정산된 주문: 정산 내역(/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}, 정산확정일 stlDy 기준)의 + 판매금액합계(selPrcAmt) 합 — 판매 상세내역과 같고 배송비(도서산간 등)가 별도 줄로 들어 있다. + 예: 9/10 주문 = 83,800 + 배송비 줄 3,000 = 86,800 (주문 목록의 dlvCst 는 0 이라 주문 목록만으로는 모자람). + - 정산 전 주문: 주문 상태 목록 4개(결제완료·발송대기·배송중·배송완료 — 지금 그 상태인 주문만, 배송완료에 구매확정 주문도 + 남음)의 ordAmt(판매금액, 11번가 부담 쿠폰 전) + 배송비(dlvCst 최댓값 한 번). 정산되면 다음 업데이트 때 정산 값으로 바뀐다. + - ordAmt − ordPayAmt = 11번가 부담 할인(= 정산 cupnAmt/tmallApplyDscAmt). 수수료는 판매금액 기준(34,900 × 13% = 4,537). - 취소·반품된 주문은 목록에서 빠진다 → 기간을 통째로 다시 받아(replace_range) 매출에서 빠진다(취소 사건을 따로 만들지 않음). - - 정산 내역(/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd})은 정산확정일(stlDy) 기준 — 확인 도구에서만 쓴다. """ from __future__ import annotations @@ -134,10 +137,9 @@ ORDER_STATUS = {"complete": "결제완료", "packaging": "발송대기", "shippi # 목록의 날짜 조건이 주문일인지 상태 변경일(배송완료일 등)인지 문서로 확인 못 해, 기간 뒤로 넉넉히 더 불러 # 주문일로 거른다(나중에 배송완료된 주문도 빠지지 않게). LOOKAHEAD_DAYS = 30 +SETTLE_LOOKAHEAD_DAYS = 45 # 결제 → 정산확정(구매확정)까지 보통 1~3주 +SETTLEMENT_PATH = "/rest/settlement/settlementList/{ds}/{de}" EVENT_PREFIX = "11st:" -# raw 에 남길 항목 — 금액·날짜·상태·상품만(구매자 정보 제외) -RAW_KEEP = ("ordNo", "ordPrdSeq", "ordDt", "ordStlEndDt", "ordAmt", "ordPayAmt", "dlvCst", "ordQty", "prdNo", - "atmtBuyCnfrmYN", "pocnfrmDt", "selPrc", "ordPrdStat") def _won(value: Any) -> int: @@ -175,54 +177,86 @@ class ElevenstAdapter(MarketplaceAdapter): ] # ── 수집 ────────────────────────────────────────────── + def _pages(self, ctx: AdapterContext, tmpl: str, lo: date, hi: date) -> Iterable[dict[str, str]]: + """[lo, hi] 를 7일씩 나눠 한 주소를 부른다.""" + s = lo + while s <= hi: + e = min(hi, s + timedelta(days=PROBE_CHUNK_DAYS - 1)) + ds, de = s.strftime("%Y%m%d"), e.strftime("%Y%m%d") + yield from xml_records(self._get(ctx, tmpl.format(s=f"{ds}0000", e=f"{de}2359", ds=ds, de=de))) + s = e + timedelta(days=1) + def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]: - """주문 상태 목록 4개를 [start, end+30일(오늘까지)] 7일씩 불러 주문일이 [start, end] 인 줄만. - 같은 줄(주문번호+순번)이 두 목록에 나오면(조회 사이 상태 변경) 한 번만. - 배송비는 주문번호마다 줄들의 dlvCst 최댓값을 가장 앞 순번 줄에 한 번(_ship).""" + """결제일이 [start, end] 인 주문을 주문 단위로 합쳐 돌려준다. + 1) 정산 내역 — 정산확정일 기준이라 [start, end+45일(오늘까지)] 를 불러 결제일(ordStlEndDt)로 거른다. + 판매금액합계(selPrcAmt)는 셀러오피스 "판매 상세내역"과 같고 배송비 줄(도서산간 등)도 따로 들어 있다. + 2) 아직 정산 전인 주문 — 주문 상태 목록 4개([start, end+30일]) 의 ordAmt + 배송비(dlvCst 최댓값 한 번). + 같은 주문이 정산에 있으면 정산 값을 쓴다(정산되면 다음 업데이트 때 정산 값으로 바뀜).""" from app.timezone import today_kst # noqa: WPS433 - hi = max(end, min(end + timedelta(days=LOOKAHEAD_DAYS), today_kst())) + today = today_kst() + orders: dict[str, dict[str, Any]] = {} + + def acc(oid: str, src: str, day: date) -> dict[str, Any]: + return orders.setdefault(oid, {"ordNo": oid, "_src": src, "_day": day, "amount": 0, "qty": 0, + "discount": 0, "ship": 0, "names": [], "opt": "", "raw": {}}) + + settle_hi = max(end, min(end + timedelta(days=SETTLE_LOOKAHEAD_DAYS), today)) + for r in self._pages(ctx, SETTLEMENT_PATH, start, settle_hi): + oid, day = str(r.get("ordNo") or ""), _day(r.get("ordStlEndDt")) + if not oid or day is None or not (start <= day <= end): + continue + o = acc(oid, "settlement", day) + o["amount"] += _won(r.get("selPrcAmt")) + o["qty"] += _won(r.get("ordQty")) + o["discount"] += _won(r.get("cupnAmt")) + if r.get("prdNm") and r["prdNm"] not in o["names"]: + o["names"].append(r["prdNm"]) + o["opt"] = o["opt"] or str(r.get("slctPrdOptNm") or "") + for k in ("stlAmt", "selFee", "deductAmt", "bmStlDlvCst"): + o["raw"][k] = o["raw"].get(k, 0) + _won(r.get(k)) + o["raw"]["stlDy"] = r.get("stlDy") + settled = set(orders) + + hi = max(end, min(end + timedelta(days=LOOKAHEAD_DAYS), today)) seen: set[str] = set() - rows: list[dict[str, Any]] = [] for tmpl in ORDER_PATHS: status = ORDER_STATUS[tmpl.split("/")[3]] - s = start - while s <= hi: - e = min(hi, s + timedelta(days=PROBE_CHUNK_DAYS - 1)) - body = self._get(ctx, tmpl.format(s=s.strftime("%Y%m%d") + "0000", e=e.strftime("%Y%m%d") + "2359")) - for r in xml_records(body): - key = f"{r.get('ordNo')}-{r.get('ordPrdSeq')}" - day = _day(r.get("ordStlEndDt") or r.get("ordDt")) - if not r.get("ordNo") or key in seen or day is None or not (start <= day <= end): - continue - seen.add(key) - rows.append({**r, "_status": status}) - s = e + timedelta(days=1) - ship: dict[str, tuple[int, int]] = {} # 주문번호 → (배송비, 가장 앞 순번) - for r in rows: - oid, seq = str(r["ordNo"]), _won(r.get("ordPrdSeq")) - cur = ship.get(oid, (0, seq)) - ship[oid] = (max(cur[0], _won(r.get("dlvCst"))), min(cur[1], seq)) - for r in rows: - fee, first = ship[str(r["ordNo"])] - yield {**r, "_ship": fee if _won(r.get("ordPrdSeq")) == first else 0} + for r in self._pages(ctx, tmpl, start, hi): + oid = str(r.get("ordNo") or "") + key = f"{oid}-{r.get('ordPrdSeq')}" + day = _day(r.get("ordStlEndDt") or r.get("ordDt")) + if not oid or oid in settled or key in seen or day is None or not (start <= day <= end): + continue + seen.add(key) + o = acc(oid, status, day) + o["amount"] += _won(r.get("ordAmt")) + o["ship"] = max(o["ship"], _won(r.get("dlvCst"))) + o["qty"] += _won(r.get("ordQty")) + o["discount"] += max(0, _won(r.get("ordAmt")) - _won(r.get("ordPayAmt"))) + if r.get("prdNm") and r["prdNm"] not in o["names"]: + o["names"].append(r["prdNm"]) + o["opt"] = o["opt"] or str(r.get("slctPrdOptNm") or "") + o["raw"]["ordDt"] = r.get("ordDt") + for o in orders.values(): + o["amount"] += o.pop("ship") + yield o - def normalize_order(self, r: dict[str, Any]) -> list[SaleEvent]: - """주문 한 줄 → SALE. 금액 = 판매금액(ordAmt, 11번가 부담 쿠폰 전) + 배송비(_ship, 주문번호당 한 줄). + def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]: + """주문 하나 → SALE(결제일). 금액 = 정산 판매금액합계(정산 전이면 ordAmt + 배송비) — 11번가 부담 쿠폰 전 금액. 수수료가 판매금액 기준이라(34,900 × 13% = 4,537, 정산 실데이터) 판매자 매출은 할인 전 금액으로 본다.""" - oid, seq = str(r.get("ordNo") or ""), str(r.get("ordPrdSeq") or "") - day = _day(r.get("ordStlEndDt") or r.get("ordDt")) + oid, day = str(o.get("ordNo") or ""), o.get("_day") if not oid or day is None: return [] - amount = _won(r.get("ordAmt")) + _won(r.get("_ship")) - opt = str(r.get("slctPrdOptNm") or "") + names = o.get("names") or [] + name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else "" return [SaleEvent( - event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}-{seq}", external_order_id=oid, - external_line_id=seq, order_date=_day(r.get("ordDt")), payment_date=day, event_date=day, - amount=max(0, amount), product_name=str(r.get("prdNm") or "")[:200], option_name=opt[:200], - quantity=int(_won(r.get("ordQty"))), discount_amount=max(0, _won(r.get("ordAmt")) - _won(r.get("ordPayAmt"))), - order_status=str(r.get("_status") or ""), - raw={k: r.get(k) for k in RAW_KEEP if r.get(k) not in (None, "")}, + event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}", external_order_id=oid, + 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="정산확정" if o.get("_src") == "settlement" else str(o.get("_src") or ""), + raw={"source": o.get("_src"), **(o.get("raw") or {})}, )] def _get(self, ctx: AdapterContext, path: str) -> bytes: diff --git a/app/modules/performance/tests/test_performance.py b/app/modules/performance/tests/test_performance.py index 5782473..8810861 100644 --- a/app/modules/performance/tests/test_performance.py +++ b/app/modules/performance/tests/test_performance.py @@ -887,30 +887,40 @@ def test_elevenst_connection(): def test_elevenst_collect_sales(): - """11번가 매출 = 주문 상태 목록(결제완료·발송대기·배송중·배송완료)의 줄, 결제일(없으면 주문일) 기준, - 금액 = ordAmt + 배송비(주문번호마다 최댓값을 가장 앞 줄에 한 번). 같은 줄이 두 목록에 나와도 한 번, 기간 밖 주문일은 제외. - 실데이터 9/9: ordAmt 34,900 / ordPayAmt 34,900, 9/10: ordAmt 83,800 / ordPayAmt 72,740(11번가 쿠폰 11,060).""" + """11번가 매출 = 주문 단위, 결제일 기준. + 정산된 주문은 정산 내역의 판매금액합계(selPrcAmt) 합 — 셀러오피스 "판매 상세내역"과 같다(배송비 줄 포함). + 정산 전 주문은 주문 상태 목록의 ordAmt + 배송비. 실데이터: 9/9 = 34,900, 9/10 = 83,800 + 배송비 3,000 = 86,800 + (주문 목록의 dlvCst 는 0 이라 정산 값을 써야 맞음).""" import httpx - import app.modules.performance.sync as syncmod + import app.modules.performance.sync as syncmod # noqa: F401 import app.timezone as _tz - from app.modules.performance.adapters import elevenst as ev def line(no, seq, day, amt, pay, ship=0, qty=1): return (f"{no}{seq}{day} 15:13:16" f"{amt}{pay}{ship}{qty}" f"밀폐용기홍길동18550503") + + def stl(no, pay_day, amt, qty, cupn=0): + return (f"{no}1홍길동" + f"{pay_day}2026/09/19밀폐용기{qty}" + f"{amt}{amt - 100}{cupn}") + settlement = ("" + stl("20260909099415322", "2026/09/09", 34900, 1) + + stl("20260910099718265", "2026/09/10", 3000, 0) + stl("20260910099718265", "2026/09/10", 83800, 2, 11060) + + stl("20260801000000009", "2026/08/01", 9999, 1) + "").encode() completed = ("" + line("20260909099415322", 1, "2026-09-09", 34900, 34900) + line("20260910099718265", 1, "2026-09-10", 83800, 72740, qty=2) + - line("20260910099718265", 2, "2026-09-10", 10000, 10000, ship=3000) + line("20260801000000001", 1, "2026-08-01", 5000, 5000) + "").encode() - packaging = ("" + line("20260909099415322", 1, "2026-09-09", 34900, 34900) + - line("20260911000000002", 1, "2026-09-11", 20000, 20000, ship=3000) + "").encode() + packaging = ("" + line("20260911000000002", 1, "2026-09-11", 20000, 20000, ship=3000) + + line("20260911000000002", 2, "2026-09-11", 5000, 5000, ship=3000) + + line("20260911000000002", 2, "2026-09-11", 5000, 5000, ship=3000) + "").encode() empty = "-1해당 건이 없습니다.".encode() calls = [] def route(url, headers=None, timeout=None): calls.append(url) + if "/settlement/" in url: + return httpx.Response(200, content=settlement if "/20260916/" in url else empty) if "/ordservices/completed/" in url: return httpx.Response(200, content=completed) if "/ordservices/packaging/" in url: @@ -928,13 +938,13 @@ def test_elevenst_collect_sales(): httpx.get, _tz.today_kst = orig, orig_today assert r["ok"], r ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "elevenst"} - assert set(ev_) == {"11st:20260909099415322-1", "11st:20260910099718265-1", "11st:20260910099718265-2", - "11st:20260911000000002-1"} # 중복 1번, 8/1 주문 제외 - assert ev_["11st:20260909099415322-1"]["amount"] == 34_900 and ev_["11st:20260909099415322-1"]["sales_date"] == date(2026, 9, 9) - assert ev_["11st:20260910099718265-1"]["amount"] == 83_800 + 3_000 # 2번 줄의 배송비를 앞 줄에 한 번 - assert ev_["11st:20260910099718265-1"]["discount_amount"] == 11_060 - assert ev_["11st:20260910099718265-2"]["amount"] == 10_000 - assert ev_["11st:20260911000000002-1"]["amount"] == 23_000 + assert set(ev_) == {"11st:20260909099415322", "11st:20260910099718265", "11st:20260911000000002"} # 8/1 제외 + assert ev_["11st:20260909099415322"]["amount"] == 34_900 and ev_["11st:20260909099415322"]["sales_date"] == date(2026, 9, 9) + assert ev_["11st:20260910099718265"]["amount"] == 86_800 # 정산 값(배송비 줄 포함) + assert ev_["11st:20260910099718265"]["discount_amount"] == 11_060 and ev_["11st:20260910099718265"]["quantity"] == 2 + assert ev_["11st:20260910099718265"]["order_status"] == "정산확정" + assert ev_["11st:20260911000000002"]["amount"] == 25_000 + 3_000 # 정산 전: ordAmt + 배송비 한 번, 중복 줄 1번 + assert ev_["11st:20260911000000002"]["order_status"] == "발송대기" assert "홍길동" not in repr(st.events) and "18550503" not in repr(st.events) # 구매자 정보 미저장 assert any("/20260930" in u for u in calls) and not any("/20261001" in u for u in calls) # 오늘까지만 더 불러옴 diff --git a/docs/PERFORMANCE_MODULE.md b/docs/PERFORMANCE_MODULE.md index 4ff165b..1069312 100644 --- a/docs/PERFORMANCE_MODULE.md +++ b/docs/PERFORMANCE_MODULE.md @@ -92,12 +92,15 @@ 개인정보 값 숨김)으로 실데이터를 보고 확정했다(2026-09-30). - 주문 상태 목록 4개(`/rest/ordservices/complete|packaging|shipping|completed/{yyyyMMddHHmm}/{…}`)는 **지금 그 상태인 주문만** 준다. 배송완료 목록에 구매확정 주문도 남는다. 취소·반품된 주문은 목록에서 빠지고 `/rest/claimservice/canceledorders|…` 에 있다. -- SALE = 주문 한 줄(`11st:{ordNo}-{ordPrdSeq}`), 날짜 = 결제일(`ordStlEndDt`, 없으면 주문일 `ordDt`), 금액 = `ordAmt` - (판매금액, 11번가 부담 쿠폰 전) + 배송비(`dlvCst`, 주문번호마다 최댓값을 가장 앞 줄에 한 번). `ordAmt − ordPayAmt` = 11번가 - 부담 할인(`discount_amount` 에 기록). 수수료는 판매금액 기준(정산 `selFee` = 34,900 × 13%). +- SALE = **주문 하나**(`11st:{ordNo}`), 날짜 = 결제일. + - **정산된 주문**: 정산 내역(`/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}`, 정산확정일 `stlDy` 기준 → 기간 뒤 45일 + (오늘까지)을 더 불러 결제일 `ordStlEndDt` 로 거름)의 **판매금액합계 `selPrcAmt` 합**. 셀러오피스 "판매 상세내역"과 같고 + 배송비(도서산간 등)가 별도 줄로 들어 있다 — 9/10 주문 83,800 + 배송비 줄 3,000 = 86,800(주문 목록 `dlvCst` 는 0). + - **정산 전 주문**: 주문 상태 목록의 `ordAmt`(판매금액, 11번가 부담 쿠폰 전) + 배송비(`dlvCst` 최댓값 한 번). 기간 뒤 30일을 더 + 불러 주문일로 거른다. 정산되면 다음 업데이트 때 정산 값으로 바뀐다. + - `ordAmt − ordPayAmt` = 정산 `cupnAmt` = 11번가 부담 할인(`discount_amount`). 수수료는 판매금액 기준(34,900 × 13% = 4,537). - `replace_range` — 기간을 통째로 다시 받아 취소·반품된 주문이 매출에서 빠진다(취소 사건을 따로 만들지 않음 → 지난 날짜 - 금액이 나중에 줄 수 있음). 목록의 날짜 조건이 주문일인지 상태 변경일인지 몰라 **기간 뒤 30일(오늘까지)을 더 불러 주문일로 거른다.** -- 정산 내역 `/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}` 은 정산확정일(`stlDy`) 기준 — 확인 도구에서만 쓴다. + 금액이 나중에 줄 수 있음). 구매자 이름·아이디·연락처는 저장하지 않는다. ### 연동 단계 체크리스트(쇼핑몰마다)
조회주소결과건수