@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 @@
+{# 실적 모듈 탭 — 설정 탭은 관리자에게만(서버도 관리자만 허용). #}
+
+ 실적
+ {% if is_admin %}
+ 설정
+ {% endif %}
+
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" %}
+
+
+
+
+ {% 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 %}
+
+ 총매출
+ 수수료
+ 수수료 차감 매출
+
+
+
+
+
+
+ {% if period_kind == 'year' %}월{% else %}날짜{% endif %}
+ {% for c in codes %}{{ short_names[c] }} {% endfor %}
+ {% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}
+
+
+
+ {% for r in table %}
+
+
+ {{ r.label }}{% if r.holiday %}{{ r.holiday }} {% endif %}
+
+ {% for c in codes %}
+ {% set m = r.cells[c] %}
+ {{ m3(m) }}
+ {% endfor %}
+ {{ m3(r.total) }}
+
+ {% endfor %}
+
+
+
+
+
+
+
+
+
{% if period_kind == 'year' %}월별{% else %}일별{% endif %} 매출 추이
+
+
+
+
+
쇼핑몰별 비중
+ {{ period.label }}
+
+
+
+
+
+
+
+
{{ month.label }} 쇼핑몰별 누적 실적
+
+
+ 쇼핑몰 총매출 수수료 수수료 차감 매출 매출 비중
+
+ {% for r in month.rows %}
+
+ {{ names[r.code] }}
+ {{ won(r.gross) }}
+ {{ won(r.commission) }}
+ {{ won(r.net) }}
+
+ {% if r.share is not none %} {{ "%.1f" | format(r.share) }}%{% else %}– {% endif %}
+
+
+ {% endfor %}
+
+
+
+ 합계
+ {{ 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 %}
+
+ {{ r.label }}
+ {{ won(r.gross) }}
+ {{ won(r.commission) }}
+ {{ won(r.net) }}
+
+ {% endfor %}
+
+
+
+ 합계
+ {{ 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 인증정보는 [설정]에서 입력합니다.
+
+
+
+
+
+
+
+
인증정보 암호화
+
+ 마스터 키
+ {% 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 %}
+
+
+
+
+
테스트 데이터
+ 현재 {{ "{:,}".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 "" + esc(eff) + ' ' + esc(String(r.rate_percent).replace(/\.?0+$/, "")) +
+ "% " + esc(r.memo) + " " + esc((r.created_by || "").split("@")[0]) +
+ ' 삭제 ';
+ }).join("") + "
";
+ }
+ 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 += '" +
+ '";
+ 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;