53 Commits

Author SHA1 Message Date
king 81b1204693 fix(project): 권한 우회·작업 혼선·저장 유실 등 16개 항목 수정 — 지금 권한 기준·읽기 전용 연결 작업·원자적 파일 댓글
권한(서버)
- 공통 권한 모듈 access.py: 모든 판단을 "지금" 권한으로 — 내 작업·수신함·알림·멘션·검색·상세·공유 링크·
  댓글·첨부·알림/메일 수신자에서 권한을 잃은 사람 제외(기록은 이력으로 보존)
- 소유자 변경·남을 소유자로 지정한 생성은 관리자만, 새 소유자는 권한 있는 등록 사용자
- 삭제는 생성자 규칙 + 지금 권한(멤버에서 빠진 생성자 거절), 댓글 수정·삭제도 지금 권한
- @태그는 볼 수 있는 사람만(mention_skipped), 태그 후보 all-users?task_id=, 새 담당자 권한 검사
- 연결(멀티호밍) 작업은 연결된 프로젝트 멤버에게 읽기 전용(task_link_scope), 볼 수 없는 연결 프로젝트 숨김

저장·동기화(화면)
- 작업 창 세대(taskGen)·블록 ctxSeq 로 늦은 A 응답이 B 를 덮지 않게(A→B, A→B→A, 이미지 업로드 중 전환)
- 자동 저장 성공/실패 반환, 실패 칸 재시도, 닫기·전환 전 저장 확인(버리기/계속 편집), 미저장 이탈 경고
- 실시간 동기화 observed/applied 분리·실패 재시도·겹침 방지, snapshot?scope=all 로 전체 범위 반영·권한 회수 안내
- 한국시간 기준 오늘(kstTodayIso), 한글 조합 중 Enter 는 제출하지 않음, 댓글 연타·재전송 중복 방지(client_token)

기타
- 파일 댓글은 본문+파일 한 트랜잭션(POST /comments/files), 실패 파일 표시·유지, 작업 창 댓글에 첨부 표시
- 날짜 범위 검증(부분 수정은 최종 상태), 완료 섹션에 바로 만든 작업 완료 처리·알림
- 마감 알림 발송 기록+수신함 알림 원자적(실패 시 재시도), 권한 없는 수신자 제외
- 테스트: tests/test_project_module.py(로컬 PostgreSQL 11개), tests/js/project_ui.test.js(jsdom 51개)
- 문서(PROJECT_MODULE 6-10·도움말·CLAUDE.md), project.js/css 캐시 버전 20260930g, 새 마이그레이션·환경변수 없음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 16:46:11 +09:00
king ae2e3eb943 Merge branch 'feat/performance' into feat/project — 매출 업데이트 취소 2026-09-30 15:06:47 +09:00
king da63b93302 feat(performance): 매출 업데이트 취소 버튼
- 진행 창 [업데이트 취소](시작한 사람·관리자) → POST /api/sync/jobs/{id}/cancel
- 어댑터가 API 호출 직전마다 ctx.progress.check() — 취소면 Cancelled 로 멈추고 저장하지 않음(기존 매출 그대로),
  차례가 안 온 쇼핑몰은 취소됨으로 건너뜀, 이미 끝난 쇼핑몰 결과는 유지
- 취소 실행은 perf_sync_runs failed + 업데이트 취소, 연결 상태는 바꾸지 않음
- 테스트 1개 추가(30개 통과), performance.js/css 캐시 버전, 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 15:06:25 +09:00
king a2d2382d71 Merge branch 'feat/performance' into feat/project — GS샵 매출 = 협력사 지급액 2026-09-30 15:01:42 +09:00
king 8b3e6dffc5 fix(performance): GS샵 매출 = supGiveAmt(협력사 지급액) — 협력사 포털 주문 통계 금액과 같은 항목
- 9월 실데이터: 6호세트 포털 176,715 ÷ 9 = 19,635 = API supGiveAmt(판매가 23,100·고객 결제 20,330),
  7호세트 45,900 × 85%, 주부체험 9,900 × 90% — 상품마다 GS 수수료율이 달라 판매가로는 못 맞춤
- 9/1~9/29 지급액 4,972,689 vs 포털 순주문 4,823,074(주문일↔매출인식일 차이)
- 이미 GS 수수료를 뺀 금액이라 GS샵 수수료율은 0% 로 둔다(문서·어댑터 설명)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 15:01:27 +09:00
king 898dc1153c Merge branch 'feat/performance' into feat/project — GS샵 매출 수집 2026-09-30 14:53:29 +09:00
king b765fb8fb8 feat(performance): GS샵 매출 수집 — 매출 내역 custChrAmt(할인 후 고객 결제금액), 매출인식일 기준
- 9/3 실데이터로 항목 확인: salePrice − dcTotAmt = custChrAmt, supGiveAmt = 협력사 지급액
- 매출 내역 한 줄 = 사건, SALE 이 아닌 줄은 RETURN 음수, 배송비 제외, replace_range
- GS API 에는 주문일 기준 조회가 없어 포털 주문 통계(총주문금액)와 날짜 기준이 다름 — 문서에 기록
- 원본 데이터 확인에 날짜별 현재 규칙 매출(열 이름은 쇼핑몰별 day_cols)
- 테스트 1개 추가(29개 통과), performance.js 캐시 버전

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 14:53:13 +09:00
king 7c283312b4 Merge branch 'feat/performance' into feat/project — GS샵 운영 KEY 변형 2026-09-30 14:36:51 +09:00
king f4fadec0a4 fix(performance): GS샵 운영 KEY — 16진수 키 변형(글자 그대로·16진수 풀기·앞 32자)도 시도
- 포털 운영 KEY 가 16진수 글자라 키를 바이트로 쓰는 법을 모드와 함께 차례로 시도, 통과한 조합 기억
- 입력칸·안내 문구를 "운영 KEY"로(개발 KEY 아님), 연결 성공 문구에 통과한 방식 표시

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 14:36:36 +09:00
king 74f59c0a94 Merge branch 'feat/performance' into feat/project — GS샵 연결·원본 확인 2026-09-30 14:28:04 +09:00
king e56c5685ca feat(performance): GS샵 연결 테스트·원본 데이터 확인 — 제휴 API AES256 토큰
- 인증: 헤더 supCd + token = base64(AES256(yyyyMMddHHmmss + 협력사코드)), 암호화 모드는 문서에 없어
  CBC(IV=키 앞 16) → ECB → CBC(IV=0) 순서로 시도하고 통과한 모드 기억, HTTP 200 + result=fail 401 도 인증 실패로
- 운영 주소 withgs-api.gsshop.com, 매출 내역(매출인식일, 10일씩·쪽 넘김)·배송비 내역
- 설정 "쇼핑몰 원본 데이터 확인"에 GS샵 — 응답 항목 이름이 문서에 없어 실데이터로 매출 규칙 확정 예정
  (그 전까지 매출 수집은 연동 준비 중)
- 입력칸 라벨: 협력사코드(supCd)·AES256 암복호화 키(저장된 값 그대로 사용)
- 테스트 1개 추가(28개 통과), 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 14:27:49 +09:00
king 67cd73b963 Merge branch 'feat/performance' into feat/project — 매출 업데이트 진행 창 2026-09-30 13:57:11 +09:00
king 3203ff87a4 feat(performance): 매출 업데이트 진행 창 — 쇼핑몰별·전체 진행 막대
- POST /api/sync background=true 로 수집을 백그라운드 스레드에서 돌리고 작업 번호를 바로 돌려줌,
  GET /api/sync/jobs/{id}·/api/sync/current 로 진행 상황 조회(jobs.py, 메모리 보관)
- 어댑터 진행 알림(ctx.progress plan/step/add): 네이버 = 일, 11번가·카페24 = 조회 구간, 받은 자료 건수
- 창: 쇼핑몰마다 막대(대기·수집 중 n/전체·저장 중·완료 n건·실패·건너뜀·경과), 전체 막대(평균),
  수집 없는/인증정보 없는 쇼핑몰은 건너뜀 한 줄, 창을 닫아도 서버에서 계속
- [매출 업데이트]·[과거 매출 가져오기] 모두 진행 창 사용, 이미 진행 중이면 그 진행 상황을 보여 줌
- 테스트 1개 추가(27개 통과), performance.js/css 캐시 버전, 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:56:57 +09:00
king e398e9d906 Merge branch 'feat/performance' into feat/project — 네이버 매출 = 판매금액(총) 2026-09-30 13:47:06 +09:00
king 077c92fa32 fix(performance): 네이버 매출 = 판매분석 "판매금액(총)" — 결제 뒤 취소·반품 포함, 배송비 제외
- 9/1 판매분석 매출 4,455,600원(판매금액(총)): 할인 뒤 금액, 배송비 별도, 환불은 환불일에 따로 빠짐
- 처음 규칙(취소·반품 빼고 배송비 더함)은 4,245,300원으로 달랐음
- 입금대기·미입금 취소만 제외, 결제 뒤 취소·반품도 결제일 매출에 포함
- 원본 데이터 확인 표에 결제 뒤 취소·반품분·배송비(참고) 열 추가
- performance.js 캐시 버전 20260930x, 테스트·문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:46:57 +09:00
king e845f47043 Merge branch 'feat/performance' into feat/project — 네이버 스마트스토어 매출 수집 2026-09-30 13:34:03 +09:00
king a5f90a0343 feat(performance): 네이버 스마트스토어 매출 수집 — 커머스API 토큰·결제일 기준 주문 조회
- 인증: bcrypt 전자서명(client_secret_sign) → OAuth2 client_credentials 토큰, 암호화 저장·만료 5분 전 재발급,
  401 이면 한 번 새로 받아 재호출, 연결 테스트는 항상 새 토큰
- 수집: 조건형 상품 주문 상세 조회(rangeType=PAYED_DATETIME) 하루씩·페이지, 호출 간격·429 재시도
- 1차 매출 규칙: 주문 단위, 결제일, totalPaymentAmount 합 + 배송비(한 번, 배송비 할인 뺌),
  취소·반품 완료·미입금 취소 제외, replace_range
- 설정 화면 "쇼핑몰 원본 데이터 확인"을 네이버·11번가 공용으로 — 네이버는 항목·상태별 합계와
  날짜별 현재 규칙 매출(개인정보는 값 숨김)
- requirements: bcrypt, 테스트 3개 추가(26개 통과), 문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:33:53 +09:00
king 21019ac5f1 style(project): 연간 목표 — 관리자 도구 버튼 33px → 30px
- project.js/css 캐시 버전 20260930f

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 13:00:43 +09:00
king 7a9f55c804 style(project): 연간 목표 — 관리자 도구 막대 1.5배 크기, 파스텔 주황 배경
- 도구 버튼 22px → 33px(글자·아이콘도 1.5배)
- 막대 배경 #ffe3c7, 버튼 올림 #ffc98f
- project.js/css 캐시 버전 20260930e

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 12:10:41 +09:00
king ac2615805b fix(project): 연간 목표 — 왼쪽 이름 세로 가운데 정렬
- 구분·항목 이름 칸 vertical-align: middle
- 관리자 도구(✎ 색 ↑ ↓ + ×)는 칸 아래에 떠 있는 막대로 — 숨은 도구가 자리를 차지해 이름이 위로 치우치던 문제
- project.js/css 캐시 버전 20260930d

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 12:04:46 +09:00
king 220fb6e7d1 feat(project): 연간 목표 — 연간 열 90px, 머리·이름 가운데 정렬, 이름 칸 너비 조절·기억
- 연간 열 너비 90px 고정
- 맨 위 머리 줄과 왼쪽 이름 두 칸(구분·항목) 가운데 정렬
- 이름 두 칸은 머리 칸 오른쪽 끝을 끌어 너비 조절(48~320px, 더블클릭 = 기본 72px),
  브라우저에 기억(localStorage pj_goal_col_w)
- project.js/css 캐시 버전 20260930c

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:54:55 +09:00
king 7de93e78d7 fix(project): 연간 목표 — 월 칸 너비 85px, 영역 색에 색 없음 + 연한 16색
- 표 칸 너비를 여백 포함(border-box)으로 — 150px 이 padding 만큼 171px 로 늘던 문제, 월 칸 85px
- 좁아진 칸에 맞춰 숫자·글 칸 안쪽 여백 6px
- 색 바꾸기 팝업: 맨 위 색 없음(흰 배경) + 연한 16색(8칸×2줄, 기존 8색 포함)
- project.js/css 캐시 버전 20260930b

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 11:32:25 +09:00
king 86ee50b2e6 Merge branch 'feat/performance' into feat/project — 서버가 feat/project 로 실적 모듈까지 함께 돌도록 2026-09-30 11:22:09 +09:00
king f037ea7de0 fix(performance): 11번가 매출 — 정산된 주문은 정산 판매금액합계(배송비 줄 포함)
셀러오피스 "판매 상세내역"(정산) 대조: 9/10 주문은 상품 83,800 + 배송비 줄 3,000
= 86,800 인데 주문 목록의 dlvCst 는 0 이라 주문 목록만으로는 3,000 이 빠진다.
정산 API 의 selPrcAmt 합(121,700 = 34,900 + 3,000 + 83,800)은 판매 상세내역과 같다.

- 정산 내역을 [기간, 기간+45일(오늘까지)] 불러 결제일(ordStlEndDt)로 거르고
  주문별 selPrcAmt 합을 매출로(정산확정 상태, cupnAmt = 11번가 부담 할인)
- 정산 전 주문만 주문 상태 목록의 ordAmt + 배송비
- 사건을 주문 단위(11st:{ordNo})로 — 정산 전/후가 같은 ID 라 바뀌어도 한 건
- 테스트·문서 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 01:24:58 +09:00
king 40d94e2892 feat(performance): 11번가 매출 수집 — 주문 상태 목록 기준, 결제일·판매금액+배송비
"11번가 원본 데이터 확인"(9/9~9/29) 실데이터로 확정:
- 주문 상태 목록(결제완료·발송대기·배송중·배송완료)은 지금 그 상태인 주문만 주고,
  배송완료 목록에 구매확정 주문도 남는다. 취소된 주문은 취소완료 목록으로 빠진다
- ordAmt − ordPayAmt = 11번가 부담 쿠폰(tmallApplyDscAmt 11,060), 수수료는
  판매금액 기준(34,900 × 13% = 4,537)

- fetch_orders: 목록 4개를 [기간, 기간+30일(오늘까지)] 7일씩 불러 주문일(결제일)이
  기간 안인 줄만, 주문번호+순번 중복 제거
- SALE 금액 = ordAmt + 배송비(주문번호마다 최댓값을 가장 앞 줄에 한 번),
  ordAmt − ordPayAmt 는 discount_amount 에. 구매자 정보는 raw 에 넣지 않음
- replace_range(11st: 접두어) — 다시 받으면 취소·반품된 주문이 빠진다
- "해당 건이 없습니다"(-1)는 0건. 테스트 추가, 미구현 시험은 G마켓으로

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 01:20:18 +09:00
king 7d96f2e738 fix(performance): 11번가 원본 데이터 확인 — "해당 건 없음"은 0건, 기간 조회·구매확정 후보
9/9 확인 결과: 취소·반품 주소는 코드 -1 "해당 건이 없습니다"(= 0건)인데 실패로
표시했고, 주문 목록 4개는 지금 그 상태인 주문만 주는 듯해 이미 구매확정된
9/9 주문이 어디에도 없었다. 정산 내역은 정산확정일 기준일 가능성이 있다.

- 결과 문구가 "해당 건이 없습니다" 류면 오류가 아니라 0건
- 기간 조회(최대 31일, 7일씩 나눠 호출) — 매출일부터 정산확정일까지 넓게 확인
- 구매확정 목록 후보 주소 추가
- 테스트 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 01:14:32 +09:00
king 1952e4f0b1 feat(performance): 11번가 원본 데이터 확인 도구 — 후보 조회 주소별 동작·항목 합계
11번가 셀러 API 의 주문·클레임 상세 문서는 로그인 뒤에만 있어 조회 주소와
금액 항목 이름을 공개 자료로 확정할 수 없다. 추측으로 매출 수집을 짜지 않고
실데이터로 확정하기 위해:

- ElevenstAdapter.reconcile(day): 결제완료·발송대상·배송중·배송완료·취소신청·
  취소완료·반품신청·반품완료·정산 후보 주소를 그날로 호출 → 동작 여부(404 등 오류),
  건수, 항목별 채워진 줄·숫자 합계·예시 값. 개인정보 항목은 이름만(값 숨김)
- 설정 화면 "11번가 원본 데이터 확인" 카드
- 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 00:47:55 +09:00
king 6376092bb7 fix(performance): 11번가 연결 테스트 — XML 아닌 응답은 실패, 성공 알림은 초록 체크
- 11번가가 200 으로 웹페이지(IP 차단 안내 등)나 XML 아닌 응답을 주면 "0건 정상"으로
  오판할 수 있어 실패로 처리
- 공용 알림 창 erpAlert(msg, { tone: "ok" }) — 경고 삼각형 대신 초록 체크.
  기존 호출은 그대로. 실적 연결 테스트 성공 알림에 적용

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 00:40:40 +09:00
king c93ab2fbd8 feat(performance): 11번가 연결 테스트 — openapikey 로 결제완료 주문 실제 조회
11번가 셀러 API 키 입력·IP 등록을 마쳤는데 연결 테스트가 "다음 단계에서
구현"만 돌려줘 이 서버에서 통하는지 알 수 없었다.

- test_connection: GET /rest/ordservices/complete/{오늘0000}/{오늘2359},
  헤더 openapikey (공식 이용방법 문서). 셀러 API 는 등록 IP 에서만 호출됨
- XML 응답(euc-kr 선언) 직접 디코딩 후 파싱, result_code 오류·401/403 구분,
  연결 실패 시 등록 IP 확인 안내
- 기존 테스트가 실제 11번가를 부르지 않게 httpx 대체 + 11번가 테스트 추가
- 매출 수집은 아직(맞출 셀러오피스 화면 정한 뒤)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 00:31:57 +09:00
king dd6a849fbd feat(performance): 쿠팡 연결 테스트 — HMAC(CEA) 서명으로 발주서 실제 조회
쿠팡 OPEN API 키를 입력했지만 연결 테스트가 "다음 단계에서 구현"만 돌려줘
키가 이 서버에서 통하는지 알 수 없었다. 키는 판매자당 1개이고 사방넷용
(연동업체 선택)으로 발급한 키는 이 서버 IP 에서 막힐 수 있어 먼저 확인이 필요.

- CEA HMAC-SHA256 서명(signed-date + METHOD + path + query, 공식 예제 방식),
  쿠팡 예시와 같은 쿼리 인코딩(+ → %2B, : 유지)
- test_connection: 오늘 결제완료 발주서(v5 ordersheets) 1건 조회
- 401/403 → 인증 실패 + "연동업체 키면 자체개발로 바꾸고 이 서버 IP 허용" 안내
- 매출 수집은 아직 — 맞출 WING 화면을 정한 뒤 구현(주석에 API 조사 결과)
- 테스트: 서명 형식·쿼리 인코딩·403 메시지·비밀값 미노출

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-30 00:14:06 +09:00
king b52b182d47 fix(performance): 카페24 마켓 통합관리 미사용 — MARKET_MAP 비우기, "카페24 경유" 표시 제거
이 쇼핑몰은 카페24 마켓 통합관리로 들어오는 매출이 없다(사용자 확인). 설정 화면에
네이버·쿠팡 등 9개 쇼핑몰이 "카페24 경유"로 표시돼 카페24 수집분이 그 열로 가는
것처럼 보였다.

- MARKET_MAP = {} — 카페24로 들어온 주문은 market_id 와 관계없이 카페24 열
  (경로 기능은 남겨 두고, 쓰게 되면 매핑만 넣으면 됨)
- 경로 시험은 테스트용 매핑 주입(_with_markets)으로 유지 + 기본값 비어 있음 테스트
- 문서·대조 안내 문구 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 23:59:06 +09:00
king 1129db9e21 fix(performance): 주문 내역 창 고정 열 제목 배경 투명 문제 + 취소 행 전체 서식
- 창(.perf-modal)은 document.body 에 붙어 .perf 밖이라 --perf-soft 등 색 변수가
  없어 고정된 열 제목 배경이 투명 → 내용이 겹쳐 보였다. 색 변수를 .perf-modal 에도
  정의하고 열 제목 배경·아래 줄을 명시
- 취소 행은 행 전체를 기울임 + 취소선 + 회색

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 23:55:53 +09:00
king bfa55bf367 feat(performance): 일자별 표 날짜 mm/dd(요일)·폭 210px, 주문 내역 창 열 제목 고정·취소 표시
- 일자별 × 쇼핑몰: 날짜 "09/01(화)" 형식, 공휴일 이름은 날짜 바로 오른쪽,
  날짜 열 너비 210px 고정
- 주문 내역 창: 열 제목 가운데·굵게·150%(18px), 창을 스크롤해도 위에 고정
- 구분 "취소"는 기울임 + 취소선 + 회색

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 23:52:29 +09:00
king 643ff25f27 fix(performance): 카페24 환불 — 네이버페이만·전체취소 배송비 포함, 0원 결제 주문은 0원
9/4·9/16·9/25 대조 결과:
- 9/4 환불 122,100 = 환불 목록 98,700 + 네이버페이 취소 19,900 + 그 주문 배송비
  3,500 (주문 전체취소) — 우리는 배송비를 빠뜨려 −3,500 (9/14 −7,000 도 같은 유형)
- 9/16 환불 201,100 = 환불 목록 그대로 — 우리가 더 뺀 9,900 은 톡체크아웃
  (KAKAOPAY) 환불 기록 없는 취소. 카페24 는 네이버페이만 센다 (9/21 도 같은 유형)
- 9/25 결제: 실결제·적립금·네이버포인트는 카페24 와 같은데 합계만 +9,900 —
  네 값이 모두 0인 주문(가상계좌·휴대폰 9,900)을 상품식으로 넣었기 때문.
  카페24 는 0원 (9/11 +24,900 도 같은 유형)

- unrefunded_claims: 네이버페이(NCHECKOUT) 주문만, 주문 전체가 취소·반품되면
  배송비(− 배송비 할인·쿠폰)를 마지막 클레임 품목에 한 번 더함
- _paid_total: 상품식 대체 제거
- 대조 표에 품목별 배송비 포함액 표시, 테스트 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 23:03:50 +09:00
king 2f86445077 feat(performance): 카페24 대조에 환불 목록 없는 취소·반품 건별 표
결제합계 공식 교체 후 남은 차이는 결제 2일(9/25 +9,900, 9/11 +24,900)과
환불 5일(9/21·9/16 +9,900, 9/11 +26,400, 9/14 −7,000, 9/4 −3,500).
−3,500/−7,000 은 환불 목록에 없는 취소(네이버페이 등)의 배송비 환불을 안 넣은
것으로 보여, 그 건들을 건별로(뺀 금액·품목 결제금액·쿠폰·주문 전체취소 여부·
주문 배송비) 표시한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 22:53:43 +09:00
king 398e5181fd fix(performance): 카페24 결제합계 = 실결제 + 적립금 + 예치금 + 네이버포인트
9/23 대조 진단으로 확인: 카페24 일별 매출내역 결제합계 1,874,738 =
실결제 1,713,128(initial payment_amount) + 적립금 10,110 + 예치금 0 +
네이버포인트 151,500(주문 naver_point). "상품구매금액 + 배송비 − 할인 − 쿠폰"은
1,874,800 으로 할인 필드에 안 잡히는 차이(62원)가 남는다 — 카페24 화면의
상품구매금액은 결제 금액에서 거꾸로 맞춘 값. 상품추가할인은 0 이라 원인 아님.

- order_total / order_total_now: 실결제 + 적립금 + 예치금 + 네이버포인트
  (모두 0인 주문만 상품식)
- 품목 상품추가할인 차감 제거(직전 커밋의 잘못된 추정)
- 대조 표: 실결제·적립금·예치금·네이버포인트 줄을 카페24 열과 비교,
  상품식은 참고 줄로
- 테스트 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 22:08:18 +09:00
king 20d19792dd feat(performance): 카페24 대조에 원본 금액 필드 합계 진단 + 이상 주문 목록
품목 상품추가할인(additional_discount_price)을 빼도록 바꿨는데도 일별 비교
결과가 그대로(+62, +260 …)라, 카페24 상품구매금액과의 차이가 어느 원본 필드에
있는지 추측하지 않고 찾기 위해:

- reconcile 결과에 diag: 그날 결제 주문 전체의 금액성 숫자 필드 합계
  (initial_order_amount / actual_order_amount / items / 주문 최상위). 이름에
  price·amount·discount·point·fee 등이 들어간 필드만 — 계좌·연락처 제외
- odd_orders: 상품금액이 100원 단위가 아니거나 판매가×수량 합과 다른 주문(최대 60건)
  + 품목의 0 아닌 금액 필드
- 화면: 판매가 합계 − 카페24 상품구매금액 = 찾는 금액, 같은 값 필드 강조
- performance.js 캐시 버전 올림(이전 커밋에서 빠짐)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 21:49:12 +09:00
king 6f43f8066a fix(performance): 카페24 결제합계에서 품목 상품추가할인 빼기 + 대조 표에 카페24 열별 차이
일별 비교 결과 결제합계가 틀린 날은 모두 카페24 상품구매금액이 100원 단위가
아닌 날이고, 차이만큼 더하면 정확히 100원 단위가 된다(9/23 1,860,738+62,
9/22 2,620,740+260, 9/12 7,889,287+13 …). 카페24 화면의 상품구매금액은
품목 상품추가할인(items[].additional_discount_price, 문서: 상품추가할인액)을
뺀 값인데, initial_order_amount 에는 이 할인이 없어 우리가 그만큼 많았다.

- order_total: 판매가 합계 − 품목 상품추가할인 + 배송비 − 할인 − 쿠폰
- order_total_now: 취소·반품 품목의 추가할인은 제외
- 대조 표: 상품구매금액을 추가할인 뺀 값으로 + 판매가 합계·추가할인 세부 줄
- 일별 비교에서 날짜를 눌러 연 대조 표에 붙여넣은 카페24 열과 열별 차이 표시
- 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 21:43:50 +09:00
king 614332a1e6 feat(performance): 카페24 일별 매출내역 붙여넣기로 날짜별 한 번에 비교
카페24 화면과 몇몇 날짜만 안 맞는데 어느 날·어느 쪽(결제/환불)인지,
저장값이 예전 규칙이라서인지 규칙 자체가 틀린 건지 구분할 방법이 없었다.

- GET /performance/api/marketplaces/{code}/daily-check?from=&to=&live=1 (관리자, 62일)
  db   = 저장된 날짜별 결제합계·결제 건수·환불합계(c24: 사건 전체 = 카페24 화면 범위)
  live = 지금 API·현재 규칙으로 다시 계산(adapter.collect, 저장 안 함)
- 설정 → 카페24 매출 대조 카드에 "일별 한 번에 비교": 카페24 표 붙여넣기 →
  날짜별 차이(저장값/API), 판정(일치 / 다시 가져오면 해결 / 규칙 차이(결제·환불)),
  [다시 가져오기] 버튼, 날짜 클릭 시 그날 상세 대조
- 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 21:36:32 +09:00
king 1d12ac878b fix(performance): 카페24 환불합계를 일별 매출내역과 같게 — 적립금 환불 + 네이버페이 취소
실데이터 대조 결과 카페24 일별 매출 환불합계 =
  환불 목록(실제 환불액 + 적립금·예치금 환불)
  + 환불 목록에 없는 취소·반품(네이버페이 취소 등, 품목 취소일 기준)
9/26: 178,220 + 1,080 + 96,500 = 275,800, 9/27: 145,000 + 55,800 = 200,800 일치.

- normalize_refund 금액에 적립금·예치금 환불 포함(refund_total)
- unrefunded_claims: orders date_type=cancel_date|return_complete_date 의 C40~43/R40~43
  품목 중 앞뒤 60일 환불 목록에 없는 주문 → CANCEL/RETURN 사건(c24:{품목코드}-CL)
- 대조 화면 환불합계를 적용 규칙으로 표시 + "적용 규칙" 후보
- 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:59:24 +09:00
king b3ee219858 feat(performance): 카페24 매출 대조 — 금액이 줄어든 주문 건별 + 주문취소일 조회
결제일 기준 후보도 카페24 환불합계와 맞지 않음(9/26, 9/27). 9/26 결제 주문의
(결제 당시 − 현재) 205,200 중 환불 기록은 148,320 뿐이라, 환불 API 에 안 잡히는
취소(네이버페이 등)를 찾기 위해 줄어든 주문을 건별로(채널·결제수단·품목 상태·
네이버페이 클레임·취소일·환불 기록) 표시. 클레임 조회에 cancel_date 추가.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:52:57 +09:00
king 1eca66838b feat(performance): 카페24 매출 대조 — 결제일 기준 환불 후보
9/26 에 실제로 일어난 환불은 4건(178,220)뿐인데 카페24 환불합계는 275,800.
카페24 일별 매출이 환불을 원 주문 결제일에 빼는지 확인하기 위해 후보 추가:
- 그날 결제한 주문이 오늘까지 환불된 금액(실제 / 적립금 포함, 환불일 표시)
- 그날 결제한 주문의 결제 당시 금액 − 현재 금액(actual_order_amount)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:49:02 +09:00
king 370834b58b feat(performance): 카페24 매출 대조 — 환불합계 후보·환불 건별·취소/반품 완료 품목
9/26 은 결제합계가 카페24와 같고 환불만 97,580 모자라며 완료일·접수일·적립금
어느 기준으로도 맞지 않아, 환불 API 에 빠진 건을 찾는 진단을 추가.
- 환불합계 후보 표: 카페24 화면 값을 입력하면 같은 줄 강조
- 환불 건별 목록(완료일·접수일 기준 합침, 계좌 등 개인정보 제외)
- 그날 취소/반품/교환 완료 품목(orders date_type=*_complete_date, embed=items)
  품목 판매가·결제금액·쿠폰·환불 기록 유무

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:44:21 +09:00
king a19c1f4cab feat(performance): 매출 업데이트는 보고 있는 기간을 가져오기 + 카페24 환불 기준 비교
- 대시보드 [매출 업데이트]가 최근 7일 고정이 아니라 지금 보고 있는 기간(오늘까지)을 가져온다
  ("이번달"이면 1일~오늘). 모듈 권한자 92일까지, 더 긴 기간(최대 366일)은 관리자만. 미래 기간은 400
- 카페24 매출 대조에 "환불 기준 비교": 환불완료일(완료) vs 환불접수일(전체 상태·상태별),
  실제 환불액만 / 적립금·예치금 포함 — 9/23~27 순매출이 카페24보다 크게 나오는 원인 확인용

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:21:08 +09:00
king fb7c29833e fix(performance): 카페24 매출 대조 채널 표를 market_id × 주문경로로 — self 를 "PC"로 잘못 표시하던 문제
실데이터 확인: market_id "self" 는 PC 전용이 아니라 자체몰 전체이고, 그 안에 주문경로 "PC쇼핑몰"·"모바일웹"이
섞여 있다. 구분을 "자체몰"로 고치고, (market_id, 주문경로) 한 쌍을 한 줄로 나눠 표시.
환불도 원 주문의 주문경로로 같은 줄에 붙인다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:11:27 +09:00
king ef12a34600 feat(performance): 카페24 매출 대조 — 채널별 PC/모바일 주문 분리 + 결제수단별 표
- 주문 채널별 표에 PC 주문 / 모바일 주문(주문의 order_from_mobile 기준 — PC 채널이어도 휴대폰 주문은 모바일)
  건수·결제합계, 카페24 열(자체몰) 합계 줄
- 결제수단별 표(카페24 열 주문의 payment_method_name 조합별 주문수·결제합계·비중)
- 대조 카드를 설정 화면 가로 전체 폭으로(넓은 표가 잘리지 않게), 자체몰 채널 이름 정리(PC)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 17:04:51 +09:00
king f63f82d642 fix(performance): 카페24 market_id 의 자체몰 채널(모바일웹·네이버페이·톡체크아웃)을 자체몰로 분류
실데이터 대조 결과 "다른 마켓 연동"으로 보이던 주문은 mobile(모바일웹)·NCHECKOUT(네이버페이)·
KAKAOPAY(톡체크아웃) — 모두 카페24 자체몰 주문. 금액은 이미 카페24 열이었지만 대조 표시가 오해를 불렀다.

- SELF_CHANNELS 로 자체몰 채널 명시, channel_kind(self/market/unknown)
- MARKET_MAP 에서 결제수단과 헷갈리는 일반 이름(naver, kakao 등) 제거
- 매출 대조: "카페24 열 / 다른 쇼핑몰 열" + "주문 채널별" 표(자체몰 채널/외부 마켓/알 수 없는 채널)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:59:16 +09:00
king 19396f1745 feat(performance): 카페24 마켓 연동 주문을 해당 쇼핑몰 열로 집계
- 카페24 마켓 통합관리가 가져온 주문(market_id ≠ self)을 MARKET_MAP 으로 네이버·쿠팡·11번가 등 열에
  (SaleEvent.marketplace_code). 연결표에 없는 마켓은 카페24 열 — 전체 합계는 카페24 일별 매출내역과 같음
- 환불도 원 주문의 마켓으로 같은 열에
- 카페24 사건 ID 에 c24: 접두어, 기간 교체는 카페24 열 + 다른 열의 c24: 행만 — 직접 연동분은 보존
- 매출 대조 마켓별 표에 "반영 열", 설정 화면에 "카페24 경유" 표시

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:54:10 +09:00
king 4cb37688ed feat(performance): 카페24 매출 대조에 다른 마켓 연동 주문을 마켓별(market_id·주문경로)로 표시
9/28 대조 결과 자체몰 + 다른 마켓 연동 합계가 카페24 일별 매출내역과 모든 줄에서 일치(공식 확인).
어느 마켓 주문인지 확인할 수 있게 market_id 별 주문수·결제합계·환불·순매출 표를 추가.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:46:28 +09:00
king 27ee92c0a6 fix(performance): 카페24 매출을 카페24 "일별 매출내역" 기준으로(결제합계·환불합계) + 매출 대조 도구
원인: 품목 결제금액(배송비 제외)을 매출로, 취소·반품 완료일의 품목 금액을 환불로 잡아
카페24 화면(결제합계 = 상품구매금액 + 배송비 − 할인 − 쿠폰, 환불합계 = 환불완료일 실제 환불액)과 달랐다.

- SALE: 결제일 기준 주문 단위 결제합계(initial_order_amount — 결제 당시 금액)
- CANCEL/RETURN: GET /admin/refunds 환불완료일, 실제 환불액(환불코드 R=반품)
- 환불도 원 주문 market_id 로 자체몰만(다른 마켓 연동 주문 제외)
- 기간 교체(replace_range): 동기화한 기간의 카페24 실데이터를 지우고 새로 넣음(한 트랜잭션,
  테스트 데이터 제외) — 예전 품목 단위 행이 남아 이중 집계되지 않게
- 설정 화면 "카페24 매출 대조": 날짜별로 카페24 화면 열 순서대로 원천 금액 합산(자체몰/마켓 구분, 저장 안 함)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:38:44 +09:00
king 04a1fddd95 feat(performance): 카페24 주문 매출 수집 연동 + 과거 매출 가져오기
카페24 (Admin API GET /admin/orders, 문서 2026-09-01 기준)
- 결제(SALE): date_type=pay_date, embed=items — 결제된 주문의 품목 결제금액(할인 반영·배송비 제외), 결제일
- 취소(CANCEL): cancel_complete_date, 품목 C40~C43 만 음수(입금전취소 C47~C49 제외)
- 반품(RETURN): return_complete_date, 품목 R40~R43 음수, 부분 반품은 claim_quantity 비율
- 자체몰 주문만(market_id=self) — 카페24로 연동된 다른 마켓 주문은 이중 집계 방지로 제외
- 60일 단위 분할(한 호출 3개월 미만), limit 1000 페이지 넘김, 개인정보 미저장(raw 는 금액·상태만)
- 기존 app/integrations/cafe24 토큰·클라이언트 재사용, 연결 테스트는 주문 권한까지 확인
- DEFAULT_SCOPES 에 mall.read_order 추가(읽기만) — 카페24 상품관리 → 시스템에서 재연결 필요

과거 매출 가져오기(설정, 관리자): 기간 지정 수집(최대 366일), 일반 사용자는 403

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:25:25 +09:00
king 6e175d0bac fix(performance): 매출 업데이트 결과 — 인증정보 미설정 쇼핑몰은 실패(빨강)가 아닌 회색 한 줄로
실패는 인증 실패·API 오류처럼 손봐야 하는 것만 표시. 미설정/연동 준비 중은 이름만 모아 표시.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:16:07 +09:00
king aa669553db feat(performance): 실적(쇼핑몰 통합 매출) 모듈 1단계 — 대시보드·설정·보안·어댑터 구조
- 네 영역 분리: ① 수집(adapters/ 쇼핑몰 10곳 + sync.py) ② 보안(security/ + credentials.py)
  ③ 계산·저장(calc.py + db.py) ④ 화면(dashboard.py, router.py, templates, performance.css/js)
- 대시보드: 기간(오늘/이번주/이번달/올해/직접선택, 이전·다음), 쇼핑몰 필터, KPI 5개(진행 중 기간은
  직전 기간 같은 경과일 대비), 일자×쇼핑몰 표(주간합계, 총매출/수수료/차감매출 전환), 일별 추이·
  쇼핑몰 비중(SVG), 월 누적(비중)·연간 누적, 금액 클릭 → 주문 상세
- 설정(관리자): 사용/매출 집계, 수수료율 이력(적용 시작일), 쇼핑몰별 API 인증정보 입력·연결 테스트·
  연결 상태, 마스터 키 상태·재암호화, 테스트(모의) 데이터 생성/삭제
- 인증정보: 설정 화면 입력 → AES-256-GCM(키 버전, AAD=쇼핑몰+항목) 암호화 저장, secret 원문은
  화면으로 다시 보내지 않음, 오류·로그·raw 는 비밀값 가린 뒤 저장. 마스터 키는 APP_ENCRYPTION_KEY(.env)
- 매출 기준일: 결제=결제일, 취소·반품=발생일. 금액 원 단위 정수, 수수료 반올림은 calc.commission 한 곳
- 동기화: 같은 쇼핑몰 동시 실행 차단(running 부분 유니크), 쇼핑몰별 실패 격리, 중복 방지 UNIQUE+UPSERT
- 카페24 어댑터는 기존 app/integrations/cafe24 OAuth 토큰 재사용, 나머지는 입력칸만(수집은 다음 단계)
- performance_db 초기화 스크립트, 권한키 performance(설정은 is_admin), 문서·.env.example

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 16:07:46 +09:00
65 changed files with 11200 additions and 396 deletions
+17
View File
@@ -146,3 +146,20 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# 읽기 전용 역할 itemcode_ro 를 먼저 생성하고(아래 DSN), 낱개+세트 UNION 검색 SQL 사용: # 읽기 전용 역할 itemcode_ro 를 먼저 생성하고(아래 DSN), 낱개+세트 UNION 검색 SQL 사용:
# ITEMCODE_DB_URL=postgresql://itemcode_ro:replace-me@postgres-db:5432/itemcode_db # ITEMCODE_DB_URL=postgresql://itemcode_ro:replace-me@postgres-db:5432/itemcode_db
# ITEMCODE_SEARCH_SQL=SELECT item_code AS code, name AS name, '낱개' AS type FROM single_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s UNION ALL SELECT item_code AS code, name AS name, '세트' AS type FROM set_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s ORDER BY code ASC LIMIT %(limit)s # ITEMCODE_SEARCH_SQL=SELECT item_code AS code, name AS name, '낱개' AS type FROM single_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s UNION ALL SELECT item_code AS code, name AS name, '세트' AS type FROM set_items WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s ORDER BY code ASC LIMIT %(limit)s
# ─── 실적(쇼핑몰 통합 매출) — app/modules/performance ───
# performance_db 전용. 미설정 시 모듈이 "설정 필요" 안내만 표시.
# 초기화: scripts/sql/performance_db_init.sql (docs/DATABASES.md 참고)
# PERFORMANCE_DB_URL=postgresql://performance_app:replace-me@postgres-db:5432/performance_db
#
# 쇼핑몰 API 인증정보(ID·Key·Secret·Token)는 여기에 넣지 않는다 —
# 실적 → 설정 화면에서 입력하면 아래 마스터 키로 AES-256-GCM 암호화해 DB 에 저장한다.
# 마스터 키는 DB 에 저장되지 않으며, 잃어버리면 저장된 인증정보를 복구할 수 없다(별도 안전 보관).
# 생성: openssl rand -hex 32 (64자 hex, 또는 32바이트 base64)
# APP_ENCRYPTION_KEY=
# APP_ENCRYPTION_KEY_VERSION=1
# 키 교체(rotation) 시: 새 키를 APP_ENCRYPTION_KEY 에, 버전을 올리고(예: 2),
# 예전 키는 APP_ENCRYPTION_KEY_V1= 로 남긴 뒤 설정 화면 [현재 키로 다시 암호화] → 완료 후 V1 삭제.
# APP_ENCRYPTION_KEY_V1=
# [매출 업데이트] 가 가져오는 기간(오늘 포함 최근 N일, 기본 7, 최대 90)
# PERFORMANCE_SYNC_DAYS=7
+3 -1
View File
@@ -36,7 +36,9 @@ Claude Code는 이 저장소에서 작업을 시작하기 전에 **반드시 아
- 말레이시아 창고 재고관리 (`app/modules/malaysia/`, `malaysia_stock_db`) — 낱개(MT/MX/MZ) 입출고·조정, 세트(MY) BOM, 일일 재고조사(세트→낱개 자동 분해), 현재고 현황. 뚜껑(MD-)은 재고 집계 제외 — 단, 창고 랙에는 위치 확인용으로 배치 가능(`store.LID_ITEMS`). 상품은 `itemcode_db` 읽기 전용. 권한키 `malaysia` - 말레이시아 창고 재고관리 (`app/modules/malaysia/`, `malaysia_stock_db`) — 낱개(MT/MX/MZ) 입출고·조정, 세트(MY) BOM, 일일 재고조사(세트→낱개 자동 분해), 현재고 현황. 뚜껑(MD-)은 재고 집계 제외 — 단, 창고 랙에는 위치 확인용으로 배치 가능(`store.LID_ITEMS`). 상품은 `itemcode_db` 읽기 전용. 권한키 `malaysia`
- 말레이시아 배송 (`app/modules/dispatch/`, `dispatch_db`) — TikTok·Shopee 출고관리. 플랫폼별 데이터 엑셀 업로드(TikTok=03_TikTok_Order_Export.xlsx, Shopee=Packing List.Doorstep Delivery.xlsx) → 1상자=1카드 출고 작업 리스트·SKU 피킹 요약·Kagayaku 전달표 자동 생성. 1상자 묶음 기준 Package ID > Tracking ID > Order ID, 같은 상자 같은 SKU 합산. 작업 상태 토글(`dispatch_logs` 기록). 받는 사람 이름/전화/주소는 상자 단위로 저장(작업 카드 표시 + 출고 엑셀 생성용 — 개인정보). 배치 다운로드 zip 에 업로드 원본 + 취합 출고 엑셀(`YYYY.MM.DD(Ddd)_tictoc|shopee.xlsx`) 포함. 엑셀은 openpyxl 파싱/생성. 권한키 `dispatch`. 상세는 `docs/DISPATCH_MODULE.md` - 말레이시아 배송 (`app/modules/dispatch/`, `dispatch_db`) — TikTok·Shopee 출고관리. 플랫폼별 데이터 엑셀 업로드(TikTok=03_TikTok_Order_Export.xlsx, Shopee=Packing List.Doorstep Delivery.xlsx) → 1상자=1카드 출고 작업 리스트·SKU 피킹 요약·Kagayaku 전달표 자동 생성. 1상자 묶음 기준 Package ID > Tracking ID > Order ID, 같은 상자 같은 SKU 합산. 작업 상태 토글(`dispatch_logs` 기록). 받는 사람 이름/전화/주소는 상자 단위로 저장(작업 카드 표시 + 출고 엑셀 생성용 — 개인정보). 배치 다운로드 zip 에 업로드 원본 + 취합 출고 엑셀(`YYYY.MM.DD(Ddd)_tictoc|shopee.xlsx`) 포함. 엑셀은 openpyxl 파싱/생성. 권한키 `dispatch`. 상세는 `docs/DISPATCH_MODULE.md`
- 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력. 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널). 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지(`POST /admin/products/{no}/images` 에 base64 data URI + `image_upload_type=A` — NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지. 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력. 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지). **카페24 관리자 API 는 PUT 뒤 한동안 GET 에서 예전 값을 돌려준다(읽기 지연)** — 우리 캐시 문제가 아니다. 그래서 "마지막 쓰기가 권위": 상세설명은 카페24 값이 최근 revision 중 하나와 같으면 지연으로 보고 마지막 MANUAL/SCHEDULED 를 표시·지문 기준으로 쓰고(`store.resolve_description`), 스칼라(상품명·가격·이미지·진열/판매)는 PUT 응답 스냅샷(`cafe24_products.last_write_snapshot`, 마이그레이션 004)과 GET 의 `updated_date` 를 비교해 덮어씌운다(`store.overlay_recent_write`). 유예시간 `CAFE24_READ_LAG_GRACE_MIN`(기본 360분). 쓰기 후 화면은 PUT 응답으로 그리고 다시 GET 하지 않는다. 예약은 DB 저장 + 별도 worker(`app/modules/cafe24/worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다. 권한키 `cafe24`(연결/해제는 admin 전용). 상세는 `docs/CAFE24_MODULE.md` - 카페24 상품관리 (`app/modules/cafe24/`, `cafe24_db`) — 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력. 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널). 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지(`POST /admin/products/{no}/images` 에 base64 data URI + `image_upload_type=A` — NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨), 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매)을 수정. 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지. 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력. 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지). **카페24 관리자 API 는 PUT 뒤 한동안 GET 에서 예전 값을 돌려준다(읽기 지연)** — 우리 캐시 문제가 아니다. 그래서 "마지막 쓰기가 권위": 상세설명은 카페24 값이 최근 revision 중 하나와 같으면 지연으로 보고 마지막 MANUAL/SCHEDULED 를 표시·지문 기준으로 쓰고(`store.resolve_description`), 스칼라(상품명·가격·이미지·진열/판매)는 PUT 응답 스냅샷(`cafe24_products.last_write_snapshot`, 마이그레이션 004)과 GET 의 `updated_date` 를 비교해 덮어씌운다(`store.overlay_recent_write`). 유예시간 `CAFE24_READ_LAG_GRACE_MIN`(기본 360분). 쓰기 후 화면은 PUT 응답으로 그리고 다시 GET 하지 않는다. 예약은 DB 저장 + 별도 worker(`app/modules/cafe24/worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다. 권한키 `cafe24`(연결/해제는 admin 전용). 상세는 `docs/CAFE24_MODULE.md`
- 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·프로젝트 색상(32색 — 아사나 16색 + 진한 16색)·아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011)·작업(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed, 섹션 기본 담당자 `default_assignee_email` — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정, 마이그레이션 009)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글. 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다. 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 작업(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 작업이 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/작업/단계 CRUD — URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터). 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만. 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, 관리자만 보기·복구(`/project/trash`). 연간 목표(마이그레이션 013, `goal_*` 테이블) — 사이드바 "목표" → 연도 펼침 → `/project/goals/{연도}` 에 매출(목표·실적·달성)·로아스 월별 숫자 + 업무 영역(상품·마케팅·컨텐츠·유통 등)별 연간·월별 글, 조회는 전원·입력은 `is_admin` 만. 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008. 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성). 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503), 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외), 댓글 `@아이디` 는 아이콘+이름 칩. 수신함 "확인"은 페이지 이동 없이 오른쪽 iframe 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`). 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남). 상세는 `docs/PROJECT_MODULE.md` - 프로젝트 관리 (`app/modules/project/`, `project_db`) — 아사나식. 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE)·프로젝트 색상(32색 — 아사나 16색 + 진한 16색)·아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011)·작업(`tasks`: 담당자·우선순위·시작/마감)·진행단계(`project_stages` 칸반, 생성시 기본 4단계 seed, 섹션 기본 담당자 `default_assignee_email` — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정, 마이그레이션 009)·멤버 배정(`project_members`)·활동이력(`project_activity`). 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글. 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다. 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다. 좌측 사이드바에 수신함·내 작업(접이식) 메뉴. 설명란은 주소 붙여넣기 시 자동 링크, 설명란·댓글에서 @로 멤버를 태그하면 (`task_mentions`, 마이그레이션 006) 수신함에 그 작업이 쌓인다. 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동). 프로젝트 생성은 `project` 권한자 누구나(만든 사람이 owner), 삭제는 만든 사람만(슈퍼관리자 예외), 사용자 배정은 `is_admin` 만. 배정 멤버(또는 owner/admin)만 그 프로젝트를 조회(화면·API 모두, 비멤버 403)하고 서브프로젝트/작업/단계 CRUD — URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증. 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백). 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터). 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만. 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, 관리자만 보기·복구(`/project/trash`). 권한은 **지금 기준 공통 모듈 `access.py`**(목록·배지·알림·멘션·메일 수신자·삭제·댓글 수정까지 — 멤버에서 빠지면 기록이 있어도 안 보이고 알림도 없음), 소유자 변경은 관리자만, 연결(멀티호밍)된 작업은 연결된 프로젝트 멤버에게 읽기 전용(docs/PROJECT_MODULE.md 6-10). 연간 목표(마이그레이션 013, `goal_*` 테이블) — 사이드바 "목표" → 연도 펼침 → `/project/goals/{연도}` 에 매출(목표·실적·달성)·로아스 월별 숫자 + 업무 영역(상품·마케팅·컨텐츠·유통 등)별 연간·월별 글, 조회는 전원·입력은 `is_admin` 만. 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008. 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지). 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`). 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*`+`PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기). 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성). 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503), 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외), 댓글 `@아이디` 는 아이콘+이름 칩. 수신함 "확인"은 페이지 이동 없이 오른쪽 iframe 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`). 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남). 상세는 `docs/PROJECT_MODULE.md`
- 실적 (`app/modules/performance/`, `performance_db`) — 쇼핑몰 통합 매출. 네 영역 분리: ① 수집 `adapters/`(쇼핑몰 하나 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄) + `sync.py`(공통 동기화, 같은 쇼핑몰 동시 실행 차단, 쇼핑몰별 실패 격리) ② 보안 `security/`(AES-256-GCM, 키 버전, 비밀값 가리기) + `credentials.py` ③ 계산 `calc.py`(주=월~일, 수수료 반올림은 `commission()` 한 곳, 요율 이력) + `db.py` ④ 화면 `dashboard.py`/`router.py`/템플릿. 쇼핑몰 API 인증정보는 `.env` 가 아니라 **설정 화면에서 입력 → 마스터 키 `APP_ENCRYPTION_KEY` 로 암호화해 DB 저장**, secret 원문은 화면으로 다시 보내지 않는다. 쇼핑몰 API 는 백엔드에서만 호출, 오류·로그·raw 는 `redact` 후 저장. 매출 기준일: 결제=결제일, 취소·반품=발생일(`sync.sales_date_for`). 금액은 원 단위 정수. 권한키 `performance`, 설정 화면·API 는 `is_admin`. 카페24 어댑터는 기존 `app/integrations/cafe24` 토큰 재사용. 1단계는 모의 데이터(`is_sample`)·구조까지, 실제 수집은 쇼핑몰별로 공식 문서 확인 후 순차 구현. 상세는 `docs/PERFORMANCE_MODULE.md`
상세는 `docs/PROJECT_OVERVIEW.md`. 상세는 `docs/PROJECT_OVERVIEW.md`.
+4 -1
View File
@@ -33,7 +33,10 @@ STORE_SCOPES: tuple[str, ...] = ("mall.read_store", "mall.write_store")
# 실제로 요청하는 scope 묶음. 개발자센터 앱에 등록된 권한과 어긋나면 인증이 # 실제로 요청하는 scope 묶음. 개발자센터 앱에 등록된 권한과 어긋나면 인증이
# 거부되므로, 여기에 추가할 때는 앱 권한도 함께 확인해야 한다. # 거부되므로, 여기에 추가할 때는 앱 권한도 함께 확인해야 한다.
# 쓰지 않는 권한은 요청하지 않는다 — 토큰이 유출돼도 피해 범위를 좁히기 위함. # 쓰지 않는 권한은 요청하지 않는다 — 토큰이 유출돼도 피해 범위를 좁히기 위함.
DEFAULT_SCOPES: tuple[str, ...] = PRODUCT_SCOPES # 주문은 읽기만(실적 모듈의 매출 수집) — 앱에 쓰기 권한이 있어도 요청하지 않는다.
# 이 목록을 바꾸면 카페24 상품관리 → 시스템에서 한 번 다시 연결해야 새 권한이 토큰에 붙는다
# (기존 토큰은 예전 권한 그대로 계속 동작).
DEFAULT_SCOPES: tuple[str, ...] = PRODUCT_SCOPES + ("mall.read_order",)
DEFAULT_API_VERSION = "2026-03-01" DEFAULT_API_VERSION = "2026-03-01"
+19
View File
@@ -24,6 +24,8 @@ from .modules.expense import CategoryStore, build_expense_store
from .modules.expense import router as expense_router from .modules.expense import router as expense_router
from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store
from .modules.malaysia import router as malaysia_router from .modules.malaysia import router as malaysia_router
from .modules.performance import build_performance_store
from .modules.performance import router as performance_router
from .modules.project import build_project_store from .modules.project import build_project_store
from .modules.project import router as project_router from .modules.project import router as project_router
from .modules.vacation import build_vacation_store from .modules.vacation import build_vacation_store
@@ -49,6 +51,7 @@ MODULE_LABELS: dict[str, str] = {
"dispatch": "말레이시아 배송", "dispatch": "말레이시아 배송",
"project": "프로젝트 관리", "project": "프로젝트 관리",
"cafe24": "카페24 상품관리", "cafe24": "카페24 상품관리",
"performance": "실적",
"expense_approver": "개인경비", "expense_approver": "개인경비",
"vacation_approver": "휴가", "vacation_approver": "휴가",
} }
@@ -136,6 +139,7 @@ _MODULE_TEMPLATE_DIRS = [
BASE_DIR / "modules" / "dispatch" / "templates", BASE_DIR / "modules" / "dispatch" / "templates",
BASE_DIR / "modules" / "project" / "templates", BASE_DIR / "modules" / "project" / "templates",
BASE_DIR / "modules" / "cafe24" / "templates", BASE_DIR / "modules" / "cafe24" / "templates",
BASE_DIR / "modules" / "performance" / "templates",
] ]
templates = Jinja2Templates(directory=str(BASE_DIR / "templates")) templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.loader = ChoiceLoader( templates.env.loader = ChoiceLoader(
@@ -195,6 +199,9 @@ app.state.project_store = build_project_store(dsn=env("PROJECT_DB_URL") or None)
# 카페24 상품관리: CAFE24_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내). # 카페24 상품관리: CAFE24_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내).
# 카페24 API 호출/토큰은 app/integrations/cafe24 공통 계층(CAFE24_* 환경변수). # 카페24 API 호출/토큰은 app/integrations/cafe24 공통 계층(CAFE24_* 환경변수).
app.state.cafe24_store = build_cafe24_store(dsn=env("CAFE24_DB_URL") or None) app.state.cafe24_store = build_cafe24_store(dsn=env("CAFE24_DB_URL") or None)
# 실적(쇼핑몰 통합 매출): PERFORMANCE_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내).
# 쇼핑몰 API 인증정보는 설정 화면에서 입력 → APP_ENCRYPTION_KEY 로 암호화해 performance_db 에 저장.
app.state.performance_store = build_performance_store(dsn=env("PERFORMANCE_DB_URL") or None)
# 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄. # 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄.
app.include_router(expense_router) app.include_router(expense_router)
@@ -204,6 +211,7 @@ app.include_router(malaysia_router)
app.include_router(dispatch_router) app.include_router(dispatch_router)
app.include_router(project_router) app.include_router(project_router)
app.include_router(cafe24_router) app.include_router(cafe24_router)
app.include_router(performance_router)
def public_url_for(request: Request, route_name: str) -> str: def public_url_for(request: Request, route_name: str) -> str:
@@ -386,6 +394,16 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
"status": "ready", "status": "ready",
"category": "운영", "category": "운영",
}, },
{
"key": "performance",
"title": "실적",
"subtitle": "Sales Performance",
"description": "여러 쇼핑몰의 매출을 일자·쇼핑몰별로 한 화면에서 보고 수수료 차감 매출을 계산합니다.",
"url": "/performance/",
"health_url": "/performance/health",
"status": "ready",
"category": "관리",
},
] ]
allowed = allowed_modules(user_rec) allowed = allowed_modules(user_rec)
for item in items: for item in items:
@@ -406,6 +424,7 @@ def _icon_svg(name: str) -> str:
"dispatch": '<rect x="1" y="3" width="15" height="13"/><path d="M16 8h4l3 3v5h-7V8z"/><circle cx="5.5" cy="18.5" r="2.5"/><circle cx="18.5" cy="18.5" r="2.5"/>', "dispatch": '<rect x="1" y="3" width="15" height="13"/><path d="M16 8h4l3 3v5h-7V8z"/><circle cx="5.5" cy="18.5" r="2.5"/><circle cx="18.5" cy="18.5" r="2.5"/>',
"project": '<rect x="3" y="4" width="18" height="16" rx="2"/><line x1="3" y1="9" x2="21" y2="9"/><line x1="8" y1="13" x2="13" y2="13"/><line x1="8" y1="16" x2="11" y2="16"/>', "project": '<rect x="3" y="4" width="18" height="16" rx="2"/><line x1="3" y1="9" x2="21" y2="9"/><line x1="8" y1="13" x2="13" y2="13"/><line x1="8" y1="16" x2="11" y2="16"/>',
"cafe24": '<rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 9h10"/><path d="M7 13h7"/><path d="M7 17h4"/>', "cafe24": '<rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 9h10"/><path d="M7 13h7"/><path d="M7 17h4"/>',
"performance": '<path d="M3 3v18h18"/><rect x="7" y="12" width="3" height="6"/><rect x="12" y="8" width="3" height="10"/><rect x="17" y="5" width="3" height="13"/>',
"modules": '<rect x="3" y="3" width="7" height="7"/><rect x="14" y="3" width="7" height="7"/><rect x="3" y="14" width="7" height="7"/><rect x="14" y="14" width="7" height="7"/>', "modules": '<rect x="3" y="3" width="7" height="7"/><rect x="14" y="3" width="7" height="7"/><rect x="3" y="14" width="7" height="7"/><rect x="14" y="14" width="7" height="7"/>',
} }
body = paths.get(name, paths["modules"]) body = paths.get(name, paths["modules"])
+25
View File
@@ -0,0 +1,25 @@
"""실적(쇼핑몰 통합 매출) 모듈.
네 영역을 분리해 둔다(쇼핑몰 하나를 추가할 때 어댑터 파일 하나만 늘어나게).
① 쇼핑몰 API 수집 adapters/ (쇼핑몰별 어댑터) + sync.py (공통 동기화 서비스)
② 인증정보·보안 security/ (AES-256-GCM, 비밀값 가리기) + credentials.py
③ 매출 계산/저장 calc.py (기간·수수료·집계) + db.py (performance_db)
④ 대시보드/UI dashboard.py (화면 데이터 조립) + router.py + templates/performance/
데이터 저장은 performance_db 전용이다. PERFORMANCE_DB_URL 미설정 시
build_performance_store 는 None 을 반환하고 라우터가 "설정 필요" 안내를 보여 준다(앱은 죽지 않음).
"""
from typing import Any
from .router import router
__all__ = ["router", "build_performance_store"]
def build_performance_store(*, dsn: str | None) -> Any:
if not dsn:
return None
from .db import PerformanceDBStore # 지연 import (개발 환경 deps 없을 수 있음)
return PerformanceDBStore(dsn)
@@ -0,0 +1,5 @@
"""① 쇼핑몰 API 수집 — 쇼핑몰별 어댑터(공통 인터페이스는 base.py, 목록은 registry.py)."""
from .registry import all_adapters, get_adapter
__all__ = ["all_adapters", "get_adapter"]
+253
View File
@@ -0,0 +1,253 @@
"""① 쇼핑몰 API 수집 — 공통 인터페이스.
쇼핑몰 하나 = 어댑터 파일 하나. 새 쇼핑몰은 `MarketplaceAdapter` 를 상속한 파일을
만들고 `registry.py` 에 한 줄 추가하면 설정 화면·동기화·대시보드에 자동으로 붙는다.
흐름: 쇼핑몰 원본 → 어댑터(fetch_* → normalize_*) → 공통 SaleEvent → sync 서비스가 DB 저장
어댑터가 지켜야 할 것:
- 인증정보는 `ctx.credentials.get(key)` 로만 꺼낸다(복호화는 서버 안에서만).
- 새 토큰은 `ctx.credentials.set(key, value)` 로 저장한다(자동 암호화).
- 오류는 아래 AdapterError 계열로 던진다. 메시지에 비밀값을 넣지 않는다
(sync 서비스가 한 번 더 가리지만, 애초에 넣지 않는 것이 원칙).
- 금액은 원 단위 정수(int). 결제는 +, 취소/반품은 − 로 만든다.
- 날짜 기준을 섞지 않는다: order_date / payment_date / event_date 를 각각 채운다.
집계 기준일(sales_date)은 sync 서비스가 정한다(결제=결제일, 취소·반품=발생일).
"""
from __future__ import annotations
from abc import ABC
from dataclasses import dataclass, field
from datetime import date
from typing import Any, Iterable, Protocol
# 연결 상태 코드 → 화면 표시. DB CHECK 제약과 같은 목록.
STATUS_LABELS: dict[str, str] = {
"ok": "정상 연결",
"not_configured": "인증정보 미설정",
"auth_failed": "인증 실패",
"token_expired": "Token 만료",
"api_error": "API 오류",
"not_implemented": "연동 준비 중",
"unknown": "확인 전",
"disabled": "사용 중지", # DB 에는 저장하지 않는 화면 전용 상태(쇼핑몰 사용 OFF)
"cancelled": "취소됨", # 화면 전용 — 매출 업데이트 창에서 [업데이트 취소](연결 상태는 바꾸지 않음)
}
EVENT_TYPES = ("SALE", "CANCEL", "RETURN", "ADJUST")
# ════════════════════════════════════════════════════════════
# 오류 — status 가 곧 연결 상태 코드
# ════════════════════════════════════════════════════════════
class AdapterError(Exception):
status = "api_error"
def __init__(self, message: str = "") -> None:
super().__init__(message or STATUS_LABELS.get(self.status, "오류"))
self.message = message or STATUS_LABELS.get(self.status, "오류")
class NotConfigured(AdapterError):
status = "not_configured"
class AuthFailed(AdapterError):
status = "auth_failed"
class TokenExpired(AdapterError):
status = "token_expired"
class ApiError(AdapterError):
status = "api_error"
class NotImplementedYet(AdapterError):
status = "not_implemented"
class Cancelled(AdapterError):
"""사용자가 매출 업데이트를 취소함 — 어댑터가 ctx.progress.check() 에서 받는다. 연결 오류가 아니다."""
status = "cancelled"
# ════════════════════════════════════════════════════════════
# 설정 입력칸 · 공통 매출 사건
# ════════════════════════════════════════════════════════════
@dataclass(frozen=True)
class CredentialField:
"""설정 화면 입력칸 하나. secret=True 면 저장 후 값을 화면으로 다시 보내지 않는다.
internal=True 는 화면에 안 보이는 내부 값(access/refresh token 등) — 어댑터가 직접 저장.
"""
key: str
label: str
secret: bool = False
required: bool = True
help: str = ""
placeholder: str = ""
internal: bool = False
@dataclass
class SaleEvent:
"""쇼핑몰 원본을 공통 형식으로 바꾼 매출 사건 하나(주문 라인 단위 권장)."""
event_type: str # SALE / CANCEL / RETURN / ADJUST
external_event_id: str # 쇼핑몰 안에서 이 사건을 유일하게 가리키는 값(중복 방지 키)
external_order_id: str
event_date: date # 사건 발생일(결제=결제일, 취소=취소일, 반품=반품완료일)
amount: int # 원 단위 정수. 결제 +, 취소/반품 −
external_line_id: str = ""
order_date: date | None = None
payment_date: date | None = None
product_name: str = ""
option_name: str = ""
quantity: int = 0
discount_amount: int = 0
order_status: str = ""
raw: dict[str, Any] = field(default_factory=dict)
# 어느 쇼핑몰 열로 집계할지 — None 이면 이 어댑터의 쇼핑몰. 다른 쇼핑몰 주문을 대신 받아 오는
# 연동(예: 카페24 마켓 통합관리가 가져온 스마트스토어 주문)은 해당 쇼핑몰 코드를 넣는다.
marketplace_code: str | None = None
def validate(self) -> None:
if self.event_type not in EVENT_TYPES:
raise ValueError(f"알 수 없는 사건 종류: {self.event_type}")
if not self.external_event_id or not self.external_order_id:
raise ValueError("external_event_id / external_order_id 가 필요합니다.")
if not isinstance(self.amount, int) or isinstance(self.amount, bool):
raise ValueError("amount 는 원 단위 정수여야 합니다.")
if self.event_type == "SALE" and self.amount < 0:
raise ValueError("결제(SALE) 금액은 음수일 수 없습니다.")
if self.event_type in ("CANCEL", "RETURN") and self.amount > 0:
raise ValueError("취소/반품 금액은 음수(또는 0)여야 합니다.")
class CredentialAccessor(Protocol):
def get(self, key: str) -> str: ...
def set(self, key: str, value: str) -> None: ...
def has(self, key: str) -> bool: ...
class Progress:
"""수집 진행 알림(매출 업데이트 창의 진행 막대용). 기본은 아무것도 하지 않는다 — sync 가 진행 상황을 모으는
객체(jobs.ShopProgress)로 바꿔 넣는다.
어댑터: 조회를 시작하기 전에 plan(전체 단계 수, 단위) → 단계 하나(하루·조회 구간)를 끝낼 때마다
step(items=그 단계에서 받은 건수). 하다가 할 일이 늘면 add(늘어난 단계 수).
API 를 부르기 직전마다 check() — 사용자가 [업데이트 취소]를 눌렀으면 Cancelled 를 던져 거기서 멈춘다."""
def plan(self, total: int, unit: str = "단계") -> None:
return None
def add(self, n: int) -> None:
return None
def step(self, n: int = 1, *, items: int = 0) -> None:
return None
def check(self) -> None:
return None
@dataclass
class AdapterContext:
code: str
credentials: CredentialAccessor
app_state: Any = None # 공통 연동 계층 재사용(예: 카페24 토큰 저장소)
timeout_sec: float = 20.0
progress: Progress = field(default_factory=Progress)
# ════════════════════════════════════════════════════════════
# 어댑터
# ════════════════════════════════════════════════════════════
class MarketplaceAdapter(ABC):
code: str = ""
name: str = ""
auth_type: str = "api_key" # api_key / oauth / shared(공통 연동 계층 재사용)
docs_url: str = ""
implemented: bool = False # 실제 수집(fetch)이 구현됐는가
# True 면 동기화 때 그 기간(sales_date)의 이 쇼핑몰 실데이터를 지우고 새로 넣는다(한 트랜잭션).
# 쇼핑몰 API 가 "기간 안 결제·환불"을 빠짐없이 돌려줄 때만 켠다 — 규칙이 바뀌거나
# 주문이 사라져도 예전 행이 남지 않는다. False 면 같은 사건 ID 만 덮어쓴다(upsert).
replace_range: bool = False
# replace_range 일 때 이 어댑터가 만든 사건을 가려내는 외부 사건 ID 접두어. 다른 쇼핑몰 열로 보낸
# 사건(marketplace_code 지정)도 이 접두어로 찾아 함께 교체한다 — 그 쇼핑몰의 직접 연동분은 건드리지 않음.
event_prefix: str = ""
note: str = "" # 설정 화면 안내 문구
# ── 설정 ──────────────────────────────────────────────
def credential_fields(self) -> list[CredentialField]:
return []
def visible_fields(self) -> list[CredentialField]:
return [f for f in self.credential_fields() if not f.internal]
@property
def uses_shared_integration(self) -> bool:
return self.auth_type == "shared"
def validate_credentials(self, values: dict[str, str]) -> list[str]:
"""저장 전 검사. 값 자체를 오류 문구에 넣지 않는다."""
errors: list[str] = []
for f in self.visible_fields():
v = (values.get(f.key) or "").strip()
if f.required and not v:
errors.append(f"{f.label} 을(를) 입력하세요.")
elif v and len(v) > 2000:
errors.append(f"{f.label} 값이 너무 깁니다.")
return errors
def is_configured(self, ctx: AdapterContext) -> bool:
return all(ctx.credentials.has(f.key) for f in self.visible_fields() if f.required)
# ── 인증 ──────────────────────────────────────────────
def authenticate(self, ctx: AdapterContext) -> None:
"""API 호출 전 준비(토큰 발급 등). 기본은 할 일 없음."""
if not self.is_configured(ctx):
raise NotConfigured("필수 인증정보가 입력되지 않았습니다.")
def refresh_token(self, ctx: AdapterContext) -> None:
"""OAuth 쇼핑몰: refresh token 으로 access token 재발급 후 ctx.credentials.set(...)."""
return None
def test_connection(self, ctx: AdapterContext) -> str:
"""성공 시 사람이 읽을 짧은 문구 반환. 실패는 AdapterError."""
self.authenticate(ctx)
raise NotImplementedYet(f"{self.name} API 연동은 다음 단계에서 구현됩니다.")
# ── 수집 ──────────────────────────────────────────────
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
raise NotImplementedYet(f"{self.name} 주문 수집은 다음 단계에서 구현됩니다.")
def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
return []
def normalize_order(self, raw: dict[str, Any]) -> list[SaleEvent]:
raise NotImplementedYet(f"{self.name} 주문 변환은 다음 단계에서 구현됩니다.")
def normalize_refund(self, raw: dict[str, Any]) -> list[SaleEvent]:
return []
def collect(self, ctx: AdapterContext, start: date, end: date) -> tuple[int, list[SaleEvent]]:
"""기간의 주문·취소/반품을 받아 공통 사건으로 변환. (원본 건수, 사건 목록)."""
self.authenticate(ctx)
fetched = 0
events: list[SaleEvent] = []
for raw in self.fetch_orders(ctx, start, end):
fetched += 1
events.extend(self.normalize_order(raw))
for raw in self.fetch_refunds(ctx, start, end):
fetched += 1
events.extend(self.normalize_refund(raw))
for ev in events:
ev.validate()
return fetched, events
+770
View File
@@ -0,0 +1,770 @@
"""카페24 — 공통 연동 계층(app/integrations/cafe24) 재사용.
카페24는 이미 OAuth 로 연결해 쓰고 있다(상품관리). 실적 설정에서 인증정보를 따로
받지 않고, 같은 토큰 저장소(cafe24_db)와 클라이언트(재시도·429·토큰 자동 갱신)를 쓴다.
주문 읽기 권한(mall.read_order)이 필요하다 — config.DEFAULT_SCOPES 에 포함, 권한 추가 후
카페24 상품관리 → 시스템에서 한 번 다시 연결해야 한다.
카페24 관리자 "일별 매출내역"과 같은 기준으로 센다(Admin API 문서 2026-09-01 확인).
- 결제합계(SALE, +): GET /admin/orders date_type=pay_date(결제일), 결제된(paid=T) 주문마다
실결제금액 + 적립금 + 예치금 + 네이버포인트 = 고객이 실제로 낸 금액
(initial_order_amount 의 payment_amount·points_spent_amount·credits_spent_amount + 주문의 naver_point)
"상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이(수십~수만 원)가 생겨 쓰지 않는다
(2026-09-23 실데이터: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식은 1,874,800).
네 값이 모두 0인 주문도 0원(카페24와 같음).
환불은 따로 빼므로 취소 후 금액(actual_order_amount)이 아니라 결제 당시 금액을 쓴다.
- 환불합계(CANCEL/RETURN, −): GET /admin/refunds date_type=refund_date(환불완료일),
실제 환불액(actual_refund_amount). 환불코드가 R 로 시작하면 반품, 그 밖은 취소.
- 수집 기간을 통째로 다시 받는다(replace_range) — 결제·환불 모두 기간 안 날짜로 조회되므로
그 기간의 카페24 실데이터를 지우고 새로 넣는다. 규칙이 바뀌거나 주문이 사라져도 이중 집계 없음.
- 자체몰 주문(market_id 가 self/빈값)은 카페24 열. 카페24 마켓 통합관리로 들어온 다른 마켓 주문
(스마트스토어·쿠팡 등)은 MARKET_MAP 으로 해당 쇼핑몰 열에 넣는다(환불도 원 주문으로 판단).
현재 이 쇼핑몰은 마켓 통합관리를 쓰지 않아 MARKET_MAP 이 비어 있다 — 모두 카페24 열.
MARKET_MAP 에 없는 마켓은 카페24 열 — 전체 합계는 항상 카페24 일별 매출내역과 같다.
네이버페이 결제(order_place_id=NCHECKOUT)는 자체몰 주문이라 카페24 열.
카페24 가 만든 사건은 모두 외부 사건 ID 앞에 "c24:" — 다시 받을 때 이것만 골라 교체하므로
해당 쇼핑몰을 나중에 직접 연동해도 그 데이터는 건드리지 않는다(단, 같은 주문을 양쪽에서 받지 않게
직접 연동을 켜는 쇼핑몰은 MARKET_MAP 에서 빼야 한다).
- 한 호출 검색기간 3개월 미만 → 60일씩 나눠 요청. orders limit ≤ 1000, refunds limit ≤ 500, offset ≤ 15000.
- 개인정보(구매자 이름·주소·연락처·계좌)는 저장하지 않는다 — raw 에는 금액·상태 필드만.
- 할인 항목 구성·마켓 주문 포함 여부는 `reconcile()`(설정 화면 "카페24 매출 대조")로 카페24 화면과
대조해 확정한다.
"""
from __future__ import annotations
from datetime import date, timedelta
from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
from typing import Any, Iterable
from .base import (
AdapterContext,
ApiError,
AuthFailed,
MarketplaceAdapter,
NotConfigured,
SaleEvent,
TokenExpired,
)
ORDER_SCOPE = "mall.read_order"
ORDER_LIMIT = 1000
REFUND_LIMIT = 500
LOOKUP_BATCH = 100
MAX_OFFSET = 15000
CHUNK_DAYS = 60
EVENT_PREFIX = "c24:"
# 매출 대조 전용 — 클레임 완료 주문 조회 날짜 유형과 "완료" 상태(입금전취소 C47~49 는 결제 전이라 제외)
CLAIM_DATE_TYPES = (("cancel_complete_date", "취소완료"), ("cancel_date", "주문취소일"),
("return_complete_date", "반품완료"), ("exchange_complete_date", "교환완료"))
CLAIM_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43", "E40"})
UNPAID_CANCEL = frozenset({"C47", "C48", "C49"})
# 환불 목록(/admin/refunds)에 없는 취소·반품(네이버페이 등) — 카페24 일별 매출 환불합계에는 들어간다(실데이터 확인)
NO_RECORD_DATE_TYPES = ("cancel_date", "return_complete_date")
NO_RECORD_DONE = frozenset({"C40", "C41", "C42", "C43", "R40", "R41", "R42", "R43"})
NO_RECORD_CHANNEL = "ncheckout" # 네이버페이만 — 톡체크아웃·자체몰의 환불 기록 없는 취소는 카페24 환불합계에 없다
REFUND_LOOKAROUND_DAYS = 60
# 카페24 자체몰 주문 채널 — market_id 는 외부 마켓만이 아니라 주문 채널·간편결제도 담는다
# (실데이터 확인 2026-09-30: mobile=모바일웹, NCHECKOUT=네이버페이, KAKAOPAY=톡체크아웃).
# 이 주문들은 카페24 자체몰 매출이다. 비교는 소문자로.
SELF_CHANNELS: dict[str, str] = {
# self 는 PC 전용이 아니다 — 주문경로(order_place_name)가 "PC쇼핑몰"·"모바일웹"으로 나뉘어 섞여 있다(실데이터 확인).
"": "자체몰", "self": "자체몰", "cafe24": "자체몰", "mobile": "모바일웹", "mobile_d": "모바일앱",
"ncheckout": "네이버페이", "kakaopay": "톡체크아웃",
}
# 카페24 마켓 통합관리가 가져온 외부 마켓 주문의 market_id(또는 order_place_id) → 우리 쇼핑몰 열.
# 이 쇼핑몰은 카페24 마켓 통합관리를 쓰지 않는다(2026-09 사용자 확인) — 비워 두어 카페24로 들어온 주문은 모두
# 카페24 열. 나중에 쓰게 되면 대조 화면 "주문 채널별" 표의 market_id 로 확인해 예: {"shopn": "naver"} 처럼 넣는다
# (그 쇼핑몰을 직접 연동한다면 넣지 않는다 — 같은 주문을 두 번 받게 됨). 결제수단과 헷갈리는 이름(naver, kakao) 금지.
MARKET_MAP: dict[str, str] = {}
def _key(value: Any) -> str:
return str(value or "").strip().lower()
def channel_kind(market_id: Any, order_place_id: Any = None) -> str:
"""self(자체몰 채널) / market(외부 마켓, 해당 쇼핑몰 열) / unknown(모르는 채널 → 카페24 열)."""
if market_id is None or _key(market_id) in SELF_CHANNELS:
return "self"
if _key(market_id) in MARKET_MAP or _key(order_place_id) in MARKET_MAP:
return "market"
return "unknown"
def target_code(market_id: Any, order_place_id: Any = None) -> str:
"""이 주문을 집계할 쇼핑몰 열. 자체몰 채널·모르는 채널은 카페24."""
if channel_kind(market_id, order_place_id) != "market":
return "cafe24"
return MARKET_MAP.get(_key(market_id)) or MARKET_MAP[_key(order_place_id)]
# 참고식(상품구매금액 + 배송비 − 할인 − 쿠폰)의 필드 — 결제합계는 PAID_FIELDS + naver_point 로 센다
DISCOUNT_FIELDS = ("membership_discount_amount", "set_product_discount_amount", "app_discount_amount",
"market_other_discount_amount", "shipping_fee_discount_amount")
COUPON_FIELDS = ("coupon_discount_price", "coupon_shipping_fee_amount")
AMOUNT_FIELDS = ("order_price_amount", "shipping_fee", *DISCOUNT_FIELDS, *COUPON_FIELDS,
"points_spent_amount", "credits_spent_amount", "payment_amount")
PAID_FIELDS = ("payment_amount", "points_spent_amount", "credits_spent_amount")
def _won(value: Any) -> int:
"""카페24 금액 문자열("29000.00") → 원 단위 정수."""
try:
return int(Decimal(str(value or "0")).quantize(Decimal(1), rounding=ROUND_HALF_UP))
except (InvalidOperation, ValueError):
return 0
def _day(value: Any) -> date | None:
""""2018-07-04T11:21:35+09:00" / "2017-07-10 15:55:51" → date (카페24 는 KST 로 준다)."""
s = str(value or "").strip()
if len(s) < 10:
return None
try:
return date.fromisoformat(s[:10])
except ValueError:
return None
def order_amounts(order: dict[str, Any]) -> dict[str, int]:
"""결제 당시 금액(initial_order_amount, 없으면 actual_order_amount) 항목별 원 단위 + 네이버포인트(주문 필드)."""
a = order.get("initial_order_amount") or order.get("actual_order_amount") or {}
return {**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "naver_point": _won(order.get("naver_point"))}
def goods_total(w: dict[str, int]) -> int:
"""참고식: 상품구매금액 + 배송비 − 할인 − 쿠폰."""
return (w["order_price_amount"] + w["shipping_fee"]
- sum(w[k] for k in DISCOUNT_FIELDS) - sum(w[k] for k in COUPON_FIELDS))
def _paid_total(w: dict[str, int]) -> int:
"""결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트. 넷 다 0인 주문은 카페24도 0원으로 센다
(9/25 가상계좌·휴대폰 9,900 주문 — 상품식으로 넣으면 그만큼 많아짐)."""
return sum(w[k] for k in PAID_FIELDS) + w["naver_point"]
def order_total(order: dict[str, Any]) -> int:
"""결제합계(결제 당시) — 카페24 일별 매출내역 결제합계와 같은 기준."""
return _paid_total(order_amounts(order))
def refund_total(refund: dict[str, Any]) -> int:
"""환불합계 = 실제 환불액 + 적립금·예치금 환불."""
return _won(refund.get("actual_refund_amount")) + _won(refund.get("used_points")) + _won(refund.get("used_credits"))
def order_total_now(order: dict[str, Any]) -> int:
"""취소·반품 반영 후 현재 결제합계(actual_order_amount). 없으면 결제 당시 금액."""
a = order.get("actual_order_amount") or order.get("initial_order_amount") or {}
return _paid_total({**{k: _won(a.get(k)) for k in AMOUNT_FIELDS}, "naver_point": _won(order.get("naver_point"))})
def is_self_market(market_id: Any) -> bool:
"""카페24 자체몰 채널(PC·모바일·네이버페이·톡체크아웃 등)인가."""
return channel_kind(market_id) == "self"
# 대조 진단 — 이름에 이 말이 들어간 숫자 필드만 합산(계좌·연락처 같은 개인정보 숫자는 이름이 달라 제외)
DIAG_WORDS = ("price", "amount", "discount", "point", "fee", "credit", "mileage", "sale", "benefit", "incentive", "coupon")
def _num(value: Any) -> Decimal | None:
if isinstance(value, bool) or value is None:
return None
try:
d = Decimal(str(value).strip())
except (InvalidOperation, ValueError):
return None
return d if d.is_finite() else None
def money_fields(obj: Any) -> dict[str, int]:
"""dict 의 금액성 숫자 필드(이름에 DIAG_WORDS) → 원 단위. 중첩은 한 단계까지 "부모.자식"."""
out: dict[str, int] = {}
if not isinstance(obj, dict):
return out
for k, v in obj.items():
if isinstance(v, dict):
for k2, v2 in money_fields(v).items():
out[f"{k}.{k2}"] = v2
continue
if not any(w in str(k).lower() for w in DIAG_WORDS):
continue
n = _num(v)
if n is not None:
out[str(k)] = int(n.quantize(Decimal(1), rounding=ROUND_HALF_UP))
return out
def _chunks(start: date, end: date) -> Iterable[tuple[date, date]]:
s = start
while s <= end:
e = min(end, s + timedelta(days=CHUNK_DAYS - 1))
yield s, e
s = e + timedelta(days=1)
class Cafe24Adapter(MarketplaceAdapter):
code = "cafe24"
name = "카페24"
auth_type = "shared"
implemented = True
replace_range = True
event_prefix = EVENT_PREFIX
docs_url = "https://apidocs.cafe24.com/docs/admin/get-orders"
note = ("카페24 상품관리에서 연결한 OAuth 토큰을 함께 씁니다(여기서 따로 입력하지 않음). "
"주문 읽기 권한이 필요해 권한 추가 후 한 번 다시 연결해야 합니다.")
# ── 연결 ──────────────────────────────────────────────
def is_configured(self, ctx: AdapterContext) -> bool:
return True
def _repo(self, ctx: AdapterContext):
return getattr(ctx.app_state, "cafe24_store", None) if ctx.app_state is not None else None
def shared_status(self, ctx: AdapterContext) -> dict:
from app.integrations.cafe24.config import load_config # 지연 import
from app.integrations.cafe24.tokens import TokenService # 지연 import
repo = self._repo(ctx)
config = load_config()
if repo is None:
return {"connected": False, "missing": config.missing or ["CAFE24_DB_URL"], "needs_reauth": False}
return TokenService(repo, config).status()
def authenticate(self, ctx: AdapterContext) -> None:
st = self.shared_status(ctx)
if not st.get("connected"):
if st.get("missing"):
raise NotConfigured("카페24 연동 환경변수가 설정되지 않았습니다.")
if st.get("needs_reauth") and str(st.get("reason", "")).startswith("refresh"):
raise TokenExpired("카페24 연결이 만료되었습니다. 카페24 상품관리 → 시스템에서 재연결하세요.")
raise AuthFailed("카페24에 연결되어 있지 않습니다. 카페24 상품관리 → 시스템에서 연결하세요.")
if ORDER_SCOPE not in str(st.get("scopes") or ""):
raise AuthFailed("카페24 토큰에 주문 읽기 권한(mall.read_order)이 없습니다. "
"카페24 상품관리 → 시스템에서 다시 연결하세요.")
def _client(self, ctx: AdapterContext):
from app.integrations.cafe24 import build_cafe24_api # 지연 import
return build_cafe24_api(self._repo(ctx)).client
def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]:
from app.integrations.cafe24.errors import ( # 지연 import
Cafe24ApiError,
Cafe24AuthError,
Cafe24ConfigError,
Cafe24RateLimitError,
)
try:
return self._client(ctx).get(path, params=params)
except Cafe24ConfigError as exc:
raise NotConfigured(str(exc)) from None
except Cafe24AuthError as exc:
raise AuthFailed(str(exc)) from None
except Cafe24RateLimitError as exc:
raise ApiError(f"카페24 호출 제한(429): {exc}") from None
except Cafe24ApiError as exc:
status = getattr(exc, "status", None)
if status == 403:
raise AuthFailed(f"카페24 권한 오류(403): {exc}. 주문 권한 추가 후 재연결하세요.") from None
raise ApiError(f"카페24 API 오류({status}): {exc}") from None
def test_connection(self, ctx: AdapterContext) -> str:
from app.timezone import today_kst # noqa: WPS433
self.authenticate(ctx)
today = today_kst().isoformat()
self._get(ctx, "/admin/orders", {"start_date": today, "end_date": today, "date_type": "pay_date", "limit": 1})
return "카페24 연결 정상(주문 조회 권한 확인)."
# ── 조회 ──────────────────────────────────────────────
def _paged(self, ctx: AdapterContext, path: str, key: str, params: dict[str, Any],
limit: int) -> Iterable[dict[str, Any]]:
offset = 0
while True:
if offset > MAX_OFFSET:
raise ApiError(f"카페24 조회 건수가 너무 많습니다({params.get('start_date')}~{params.get('end_date')}). "
"기간을 줄여 다시 시도하세요.")
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
rows = self._get(ctx, path, {**params, "limit": limit, "offset": offset}).get(key) or []
yield from rows
if len(rows) < limit:
return
offset += limit
def paid_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
for s, e in _chunks(start, end):
n = 0
for o in self._paged(ctx, "/admin/orders", "orders",
{"start_date": s.isoformat(), "end_date": e.isoformat(),
"date_type": "pay_date", "embed": "items"}, ORDER_LIMIT):
n += 1
yield o
ctx.progress.step(items=n)
def refunds(self, ctx: AdapterContext, start: date, end: date,
date_type: str = "refund_date") -> Iterable[dict[str, Any]]:
"""환불 목록. date_type: refund_date(환불완료일, 기본) / accepted_refund_date(환불접수일)."""
for s, e in _chunks(start, end):
n = 0
for r in self._paged(ctx, "/admin/refunds", "refunds",
{"start_date": s.isoformat(), "end_date": e.isoformat(),
"date_type": date_type}, REFUND_LIMIT):
n += 1
yield r
ctx.progress.step(items=n)
def claim_items(self, ctx: AdapterContext, day: date) -> dict[str, Any]:
"""그날 취소완료·반품완료·교환완료된 주문의 클레임 품목(대조 전용). 환불 API 에 안 잡히는 건
(네이버페이 취소 등)을 찾기 위한 것. 조회 실패는 errors 에 담고 계속한다. 개인정보 제외."""
items: list[dict[str, Any]] = []
errors: list[str] = []
seen: set[str] = set()
full_cancel_shipping = 0
for date_type, label in CLAIM_DATE_TYPES:
try:
orders = list(self._paged(ctx, "/admin/orders", "orders",
{"start_date": day.isoformat(), "end_date": day.isoformat(),
"date_type": date_type, "embed": "items"}, ORDER_LIMIT))
except ApiError as exc:
errors.append(f"{label}: {exc}")
continue
for o in orders:
oid = str(o.get("order_id") or "")
its = o.get("items") or []
claimed = [i for i in its if str(i.get("order_status") or "")[:1] in ("C", "R", "E")
and str(i.get("order_status") or "") not in UNPAID_CANCEL]
if claimed and len(claimed) == len(its) and oid not in seen and \
all(str(i.get("order_status") or "") in CLAIM_DONE and str(i.get("order_status"))[:1] == "C" for i in its):
full_cancel_shipping += order_amounts(o)["shipping_fee"]
for i in claimed:
key = str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}")
if key in seen:
continue
seen.add(key)
status = str(i.get("order_status") or "")
qty = int(i.get("quantity") or 0)
items.append({
"via": label, "order_id": oid, "item_code": key,
"channel": str(o.get("order_place_name") or o.get("market_id") or ""),
"paid": o.get("paid") == "T", "pay_date": str(o.get("payment_date") or "")[:10],
"status": status, "status_text": str(i.get("status_text") or ""),
"done": status in CLAIM_DONE,
"claim_code": str(i.get("claim_code") or ""),
"product_name": str(i.get("product_name") or "")[:40], "quantity": qty,
"product_amount": (_won(i.get("product_price")) + _won(i.get("option_price"))) * qty,
"payment_amount": _won(i.get("payment_amount")),
"coupon": _won(i.get("coupon_discount_price")),
"naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""),
"cancel_date": str(i.get("cancel_date") or "")[:16],
"refund_date": str(i.get("refund_date") or "")[:16],
"return_confirmed_date": str(i.get("return_confirmed_date") or "")[:16],
})
seen.add(oid)
return {"items": items, "errors": errors, "full_cancel_shipping": full_cancel_shipping}
def unrefunded_claims(self, ctx: AdapterContext, start: date, end: date) -> list[dict[str, Any]]:
"""환불 목록에 기록이 없는 네이버페이 취소·반품 완료 품목. 날짜 = 품목 취소일(반품은 반품완료일).
금액 = 판매가(+옵션)×수량 − 품목 할인·쿠폰. 주문 전체가 취소·반품되면 배송비(− 배송비 할인·쿠폰)도 환불로
보고 그 주문의 마지막 클레임 품목에 한 번 더한다. 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 있으면
제외해 환불 목록 쪽과 두 번 빼지 않는다.
카페24 일별 매출 환불합계와 대조한 결과(2026-09): 네이버페이만 센다 — 톡체크아웃(KAKAOPAY)·자체몰의
환불 기록 없는 취소는 넣지 않는다(9/16 톡체크아웃 취소 9,900 제외, 9/4 네이버페이 전체취소 배송비 3,500 포함)."""
from app.timezone import today_kst # noqa: WPS433
found: dict[str, dict[str, Any]] = {}
for date_type in NO_RECORD_DATE_TYPES:
for s, e in _chunks(start, end):
scanned = 0
for o in self._paged(ctx, "/admin/orders", "orders",
{"start_date": s.isoformat(), "end_date": e.isoformat(),
"date_type": date_type, "embed": "items"}, ORDER_LIMIT):
scanned += 1
if NO_RECORD_CHANNEL not in (_key(o.get("market_id")), _key(o.get("order_place_id"))):
continue
oid = str(o.get("order_id") or "")
its = o.get("items") or []
claimed: list[tuple[date, str, dict[str, Any]]] = []
for i in its:
status = str(i.get("order_status") or "")
if status not in NO_RECORD_DONE:
continue
keys = (("cancel_date", "refund_date", "return_confirmed_date") if status[:1] == "C"
else ("return_confirmed_date", "refund_date", "cancel_date"))
day = next((d for d in (_day(i.get(k)) for k in keys) if d), None)
if day is not None:
claimed.append((day, str(i.get("order_item_code") or f"{oid}-{i.get('item_no')}"), i))
if not claimed:
continue
all_claimed = len(claimed) == len(its)
w = order_amounts(o)
ship = max(0, w["shipping_fee"] - w["coupon_shipping_fee_amount"] - w["shipping_fee_discount_amount"])
last = max((d, k) for d, k, _ in claimed)
for day, key, i in claimed:
if not (start <= day <= end):
continue
status = str(i.get("order_status") or "")
qty = int(i.get("quantity") or 0)
amount = max(0, (_won(i.get("product_price")) + _won(i.get("option_price"))) * qty
- _won(i.get("additional_discount_price")) - _won(i.get("coupon_discount_price"))
- _won(i.get("app_item_discount_amount")))
ship_refund = ship if all_claimed and (day, key) == last else 0
found[key] = {
"order_id": oid, "item_code": key, "status": status, "day": day,
"market_id": o.get("market_id"), "place_id": o.get("order_place_id"),
"place_name": o.get("order_place_name"), "order_date": _day(o.get("order_date")),
"quantity": qty, "amount": amount + ship_refund, "shipping_refund": ship_refund,
"product_name": str(i.get("product_name") or "")[:40],
"naver_pay_claim_status": str(i.get("naver_pay_claim_status") or ""),
# 대조용 — 주문 전체가 취소·반품됐는지, 그 주문 배송비
"order_all_claimed": all_claimed, "order_shipping_fee": w["shipping_fee"],
"item_payment_amount": _won(i.get("payment_amount")),
"coupon": _won(i.get("coupon_discount_price")),
}
ctx.progress.step(items=scanned)
if not found:
return []
lo = start - timedelta(days=REFUND_LOOKAROUND_DAYS)
hi = max(end, min(end + timedelta(days=REFUND_LOOKAROUND_DAYS), today_kst()))
ctx.progress.add(2 * len(list(_chunks(lo, hi)))) # 환불 목록 대조(완료일·접수일) — 찾은 게 있을 때만
refunded = {str(r.get("order_id") or "") for dt in ("refund_date", "accepted_refund_date")
for r in self.refunds(ctx, lo, hi, dt)}
return [c for c in found.values() if c["order_id"] not in refunded]
def market_ids(self, ctx: AdapterContext, refunds: list[dict[str, Any]]) -> dict[str, tuple[Any, Any, Any]]:
"""환불의 원 주문 (market_id, order_place_id, order_place_name) — 주문일 60일 구간·100건씩 묶어 조회.
못 찾으면 자체몰."""
pairs = sorted({(_day(r.get("order_date")) or date.min, str(r.get("order_id") or ""))
for r in refunds if r.get("order_id")})
out: dict[str, Any] = {}
i = 0
while i < len(pairs):
first = pairs[i][0]
group = [p for p in pairs[i:i + LOOKUP_BATCH] if (p[0] - first).days < CHUNK_DAYS]
ids = [oid for _, oid in group]
if first != date.min:
params = {"order_id": ",".join(ids), "start_date": first.isoformat(),
"end_date": group[-1][0].isoformat(), "date_type": "order_date", "limit": LOOKUP_BATCH}
for o in self._get(ctx, "/admin/orders", params).get("orders") or []:
out[str(o.get("order_id"))] = (o.get("market_id"), o.get("order_place_id"), o.get("order_place_name"))
i += len(group)
return out
# ── 수집(어댑터 공통 흐름) ──────────────────────────────
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
# 진행 막대: 60일 구간마다 결제 주문 1 + 환불 1 + 환불 없는 취소·반품(취소일·반품완료일) 2
c = len(list(_chunks(start, end)))
ctx.progress.plan(c * (2 + len(NO_RECORD_DATE_TYPES)), "구간")
yield from self.paid_orders(ctx, start, end)
def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
rows = [r for r in self.refunds(ctx, start, end) if str(r.get("status") or "T") == "T"]
markets = self.market_ids(ctx, rows)
for r in rows:
mid, place, _name = markets.get(str(r.get("order_id")), ("self", None, None))
yield {**r, "_market_id": mid, "_order_place_id": place}
for c in self.unrefunded_claims(ctx, start, end):
yield {**c, "_kind": "claim"}
def normalize_order(self, order: dict[str, Any]) -> list[SaleEvent]:
"""결제 주문 → SALE. 자체몰은 카페24 열, 마켓 연동 주문은 해당 쇼핑몰 열(MARKET_MAP)."""
if order.get("paid") != "T":
return []
pay_day = _day(order.get("payment_date"))
if pay_day is None:
return []
items = order.get("items") or []
names = [str(i.get("product_name") or "") for i in items if i.get("product_name")]
name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else ""
oid = str(order.get("order_id") or "")
target = target_code(order.get("market_id"), order.get("order_place_id"))
return [SaleEvent(
marketplace_code=target,
event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}-PAY", external_order_id=oid,
order_date=_day(order.get("order_date")), payment_date=pay_day, event_date=pay_day,
amount=max(0, order_total(order)), product_name=name,
quantity=sum(int(i.get("quantity") or 0) for i in items), order_status="결제완료",
discount_amount=sum(order_amounts(order)[k] for k in DISCOUNT_FIELDS + COUPON_FIELDS),
raw={"order_id": oid, "market_id": order.get("market_id"), "order_place_id": order.get("order_place_id"),
"items": len(items), **{f"initial_{k}": v for k, v in order_amounts(order).items()}},
)]
def normalize_refund(self, refund: dict[str, Any]) -> list[SaleEvent]:
"""환불 → CANCEL/RETURN(−). 원 주문의 market_id 로 결제와 같은 쇼핑몰 열에 넣는다.
금액 = 실제 환불액 + 적립금·예치금 환불(카페24 일별 매출 환불합계와 같음, 실데이터 확인)."""
if refund.get("_kind") == "claim":
return self.normalize_claim(refund)
day = _day(refund.get("refund_date"))
code = str(refund.get("refund_code") or "")
if day is None or not code:
return []
amount = refund_total(refund)
return [SaleEvent(
marketplace_code=target_code(refund.get("_market_id"), refund.get("_order_place_id")),
event_type="RETURN" if code.upper().startswith("R") else "CANCEL",
external_event_id=f"{EVENT_PREFIX}{code}", external_order_id=str(refund.get("order_id") or ""),
external_line_id=",".join(refund.get("order_item_code") or []),
order_date=_day(refund.get("order_date")), event_date=day, amount=-amount,
quantity=-int(refund.get("quantity") or 0), order_status="환불완료",
raw={"refund_code": code, "order_id": refund.get("order_id"), "status": refund.get("status"),
"actual_refund_amount": refund.get("actual_refund_amount"),
"used_points": refund.get("used_points"), "used_credits": refund.get("used_credits"),
"quantity": refund.get("quantity"), "order_item_code": refund.get("order_item_code")},
)]
def normalize_claim(self, c: dict[str, Any]) -> list[SaleEvent]:
"""환불 목록에 없는 취소·반품 품목(네이버페이 등) → CANCEL/RETURN(−), 취소일(반품완료일)."""
if not c.get("amount") or c.get("day") is None:
return []
is_return = str(c.get("status"))[:1] == "R"
return [SaleEvent(
marketplace_code=target_code(c.get("market_id"), c.get("place_id")),
event_type="RETURN" if is_return else "CANCEL",
external_event_id=f"{EVENT_PREFIX}{c['item_code']}-CL", external_order_id=str(c.get("order_id") or ""),
external_line_id=str(c["item_code"]), order_date=c.get("order_date"), event_date=c["day"],
amount=-int(c["amount"]), quantity=-int(c.get("quantity") or 0), product_name=c.get("product_name") or "",
order_status="반품완료" if is_return else "취소완료",
raw={"order_id": c.get("order_id"), "item_code": c["item_code"], "status": c.get("status"),
"market_id": c.get("market_id"), "naver_pay_claim_status": c.get("naver_pay_claim_status"),
"no_refund_record": True},
)]
# ── 대조(설정 화면 "카페24 매출 대조") ─────────────────
def reconcile(self, ctx: AdapterContext, day: date) -> dict[str, Any]:
"""그날 결제 주문·환불을 항목별로 합산 — 카페24 일별 매출내역과 비교해 규칙을 확정하는 용도.
groups["self"] = 카페24 열(자체몰 채널 + 알 수 없는 채널), groups["market"] = 다른 쇼핑몰 열로 가는
외부 마켓 주문. by_channel = 주문 채널(market_id)별 내역. 개인정보는 담지 않는다.
"""
self.authenticate(ctx)
def empty() -> dict[str, int]:
return {"orders": 0, "items": 0, "lines": 0, **{k: 0 for k in AMOUNT_FIELDS},
"naver_point": 0, "goods_total": 0, "total": 0}
def channel(mid: Any, place: Any, place_name: Any = None) -> dict[str, Any]:
"""(market_id, 주문경로) 한 쌍 = 한 줄. self 안에도 PC쇼핑몰·모바일웹 경로가 섞여 있어 나눠 본다."""
mkey = "" if mid is None else str(mid)
pname = str(place_name or place or "")
kind = channel_kind(mid, place)
return by_channel.setdefault((mkey, pname), {
"market_id": mkey or "(없음)", "place": pname, "place_id": str(place or ""),
"label": SELF_CHANNELS.get(_key(mid), ""), "names": set(),
"kind": kind, "target": target_code(mid, place),
"orders": 0, "total": 0, "refund_count": 0, "refund_amount": 0,
# 기기 — 주문의 order_from_mobile(T=모바일에서 주문). PC 채널(self)에도 모바일 주문이 섞여 있다.
"pc_orders": 0, "pc_total": 0, "mobile_orders": 0, "mobile_total": 0,
})
groups = {"self": empty(), "market": empty()}
by_channel: dict[str, dict[str, Any]] = {}
by_payment: dict[str, dict[str, Any]] = {} # 결제수단 조합별(카페24 열 주문만)
unpaid = 0
paid_self: dict[str, int] = {} # 그날 결제된 카페24 열 주문 → (결제 당시 − 현재) 금액
reduced: dict[str, dict[str, Any]] = {} # 그중 금액이 줄어든 주문(취소·반품) — 환불 기록과 대조
# 진단 — 어떤 원본 필드가 카페24 화면 열과 맞는지 찾는 용도(결제 주문 전체, 개인정보 제외)
diag = {"order": {}, "initial": {}, "actual": {}, "item": {}}
odd: list[dict[str, Any]] = [] # 판매가×수량 합이 주문 상품금액과 다르거나 100원 단위가 아닌 주문
for o in self.paid_orders(ctx, day, day):
if o.get("paid") != "T":
unpaid += 1
continue
for part, src in (("order", {k: v for k, v in o.items() if not isinstance(v, (dict, list))}),
("initial", o.get("initial_order_amount")), ("actual", o.get("actual_order_amount"))):
for k, v in money_fields(src).items():
diag[part][k] = diag[part].get(k, 0) + v
its = o.get("items") or []
for i in its:
for k, v in money_fields(i).items():
diag["item"][k] = diag["item"].get(k, 0) + v
gross = sum((_won(i.get("product_price")) + _won(i.get("option_price"))) * int(i.get("quantity") or 0) for i in its)
opa = order_amounts(o)["order_price_amount"]
if (gross != opa or opa % 100) and len(odd) < 60:
odd.append({"order_id": str(o.get("order_id") or ""),
"channel": str(o.get("order_place_name") or o.get("market_id") or ""),
"order_price_amount": opa, "items_gross": gross, "total": order_total(o),
"items": [{"code": str(i.get("order_item_code") or ""), "status": str(i.get("order_status") or ""),
"quantity": int(i.get("quantity") or 0),
"fields": {k: v for k, v in money_fields(i).items() if v}} for i in its]})
ch = channel(o.get("market_id"), o.get("order_place_id"), o.get("order_place_name"))
total = order_total(o)
ch["orders"] += 1
ch["total"] += total
dev = "mobile" if str(o.get("order_from_mobile") or "").upper() == "T" else "pc"
ch[f"{dev}_orders"] += 1
ch[f"{dev}_total"] += total
if ch["target"] == "cafe24":
names = [str(n) for n in (o.get("payment_method_name") or o.get("payment_method") or []) if n]
pkey = " + ".join(names) or "(없음)"
pm = by_payment.setdefault(pkey, {"method": pkey, "orders": 0, "total": 0})
pm["orders"] += 1
pm["total"] += total
for n in (o.get("order_place_name"), o.get("order_place_id")):
if n:
ch["names"].add(str(n))
g = groups["self" if ch["target"] == "cafe24" else "market"]
g["orders"] += 1
g["items"] += sum(int(i.get("quantity") or 0) for i in o.get("items") or [])
g["lines"] += len(o.get("items") or [])
for k, v in order_amounts(o).items():
g[k] += v
g["goods_total"] += goods_total(order_amounts(o))
g["total"] += order_total(o)
if ch["target"] == "cafe24":
oid_ = str(o.get("order_id") or "")
paid_self[oid_] = order_total(o) - order_total_now(o)
if paid_self[oid_] > 0:
reduced[oid_] = {
"order_id": oid_, "channel": str(o.get("order_place_name") or o.get("market_id") or ""),
"payment": " + ".join(str(n) for n in (o.get("payment_method_name") or []) if n),
"initial": order_total(o), "now": order_total_now(o), "diff": paid_self[oid_],
"statuses": sorted({f"{i.get('order_status') or ''} {i.get('status_text') or ''}".strip()
for i in o.get("items") or []}),
"naver_pay": sorted({str(i.get("naver_pay_claim_status")) for i in o.get("items") or []
if i.get("naver_pay_claim_status")}),
"claim_dates": sorted({str(i.get(k))[:10] for i in o.get("items") or []
for k in ("cancel_date", "refund_date", "return_confirmed_date")
if i.get(k)}),
"refunded": 0, "refund_dates": [],
}
rows = [r for r in self.refunds(ctx, day, day) if str(r.get("status") or "T") == "T"]
markets = self.market_ids(ctx, rows)
refunds = {k: {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0,
"no_record_count": 0, "no_record": 0, "total": 0} for k in ("self", "market")}
for r in rows:
mid, place, place_name = markets.get(str(r.get("order_id")), ("self", None, None))
ch = channel(mid, place, place_name)
g = refunds["self" if ch["target"] == "cafe24" else "market"]
g["count"] += 1
for k in ("actual_refund_amount", "used_points", "used_credits"):
g[k] += _won(r.get(k))
g["total"] += refund_total(r)
ch["refund_count"] += 1
ch["refund_amount"] += refund_total(r)
no_record = self.unrefunded_claims(ctx, day, day)
for c in no_record:
ch = channel(c["market_id"], c["place_id"], c["place_name"])
g = refunds["self" if ch["target"] == "cafe24" else "market"]
g["no_record_count"] += 1
g["no_record"] += c["amount"]
g["total"] += c["amount"]
ch["refund_count"] += 1
ch["refund_amount"] += c["amount"]
channels_out = sorted(({**v, "names": sorted(v["names"])} for v in by_channel.values()),
key=lambda v: v["total"], reverse=True)
# 환불 기준 비교 — 카페24 "환불합계"가 어느 기준인지 확정하는 용도.
# 완료일(refund_date, 완료 T) vs 접수일(accepted_refund_date, 상태 T/F/M 전부)
# 각각 실제 환불액만 / 적립금·예치금 환불 포함
def rsum(items: Iterable[dict[str, Any]]) -> dict[str, int]:
out = {"count": 0, "actual_refund_amount": 0, "used_points": 0, "used_credits": 0}
for x in items:
out["count"] += 1
for k in ("actual_refund_amount", "used_points", "used_credits"):
out[k] += _won(x.get(k))
out["with_points"] = out["actual_refund_amount"] + out["used_points"] + out["used_credits"]
return out
accepted = list(self.refunds(ctx, day, day, "accepted_refund_date"))
status_names = {"T": "환불완료", "F": "환불전", "M": "환불보류"}
refund_basis = {
"completed": rsum(rows),
"accepted_all": rsum(accepted),
"accepted_by_status": [
{"status": s, "label": status_names.get(s, s or "(없음)"),
**rsum(x for x in accepted if str(x.get("status") or "") == s)}
for s in sorted({str(x.get("status") or "") for x in accepted})
],
}
# 환불 건별 목록(완료일 기준 + 접수일 기준, 환불코드로 합침) — 개인정보(이메일·계좌) 제외
extra = markets | self.market_ids(ctx, [a for a in accepted if str(a.get("order_id")) not in markets])
refund_list: dict[str, dict[str, Any]] = {}
for basis, items in (("completed", rows), ("accepted", accepted)):
for x in items:
code = str(x.get("refund_code") or "")
mid, place, place_name = extra.get(str(x.get("order_id")), ("self", None, None))
e = refund_list.setdefault(code, {
"refund_code": code, "order_id": str(x.get("order_id") or ""),
"channel": str(place_name or mid or ""), "status": str(x.get("status") or ""),
"accepted_date": str(x.get("accepted_refund_date") or "")[:16].replace("T", " "),
"refund_date": str(x.get("refund_date") or "")[:16].replace("T", " "),
"quantity": int(x.get("quantity") or 0),
"actual_refund_amount": _won(x.get("actual_refund_amount")),
"used_points": _won(x.get("used_points")), "used_credits": _won(x.get("used_credits")),
"cancel_fee_amount": _won(x.get("cancel_fee_amount")),
"methods": [str(m) for m in (x.get("refund_methods") or []) if m],
"in_completed": False, "in_accepted": False,
})
e["in_" + basis] = True
claims = self.claim_items(ctx, day)
refunded_orders = {r["order_id"] for r in refund_list.values()}
for c in claims["items"]:
c["has_refund"] = c["order_id"] in refunded_orders
def csum(pred) -> dict[str, int]:
sel = [c for c in claims["items"] if c["done"] and pred(c)]
return {"count": len(sel), "payment_amount": sum(c["payment_amount"] for c in sel),
"product_amount": sum(c["product_amount"] for c in sel)}
# 결제일 기준 — 그날 결제된 주문이 그 뒤(오늘까지) 환불된 금액. 카페24 일별 매출이 환불을 원 주문 결제일에
# 빼는지 확인하는 용도(최근일만 맞고 지난 날일수록 차이가 커지는 현상).
from app.timezone import today_kst # noqa: WPS433
later = [x for x in self.refunds(ctx, day, max(day, today_kst()))
if str(x.get("order_id") or "") in paid_self and str(x.get("status") or "T") == "T"]
by_pay = rsum(later)
by_pay["amount_diff"] = sum(v for v in paid_self.values() if v > 0)
by_pay["refund_dates"] = sorted({str(x.get("refund_date") or "")[:10] for x in later})
refund_basis["by_pay_date"] = by_pay
for x in later:
r_ = reduced.get(str(x.get("order_id") or ""))
if r_ is not None:
r_["refunded"] += _won(x.get("actual_refund_amount")) + _won(x.get("used_points")) + _won(x.get("used_credits"))
r_["refund_dates"] = sorted({*r_["refund_dates"], str(x.get("refund_date") or "")[:10]})
comp = refund_basis["completed"]
no_refund = csum(lambda c: not c["has_refund"])
claimed = csum(lambda c: True)
# 카페24 "환불합계" 후보 — 화면 값과 같은 줄을 찾는다(화면에서 값을 입력하면 강조)
candidates = [
{"key": "applied", "label": "적용 규칙 · 환불 목록(실제 + 적립금·예치금) + 환불 목록 없는 취소·반품(네이버페이 등)",
"amount": refunds["self"]["total"] + refunds["market"]["total"]},
{"key": "completed", "label": "환불완료일 · 실제 환불액 (이전 규칙)", "amount": comp["actual_refund_amount"]},
{"key": "completed_pts", "label": "환불완료일 · 실제 환불액 + 적립금·예치금", "amount": comp["with_points"]},
{"key": "pay_date", "label": "결제일 기준 · 그날 결제 주문의 환불(오늘까지) · 실제 환불액",
"amount": by_pay["actual_refund_amount"]},
{"key": "pay_date_pts", "label": "결제일 기준 · 그날 결제 주문의 환불(오늘까지) · 실제 + 적립금·예치금",
"amount": by_pay["with_points"]},
{"key": "pay_date_diff", "label": "결제일 기준 · 그날 결제 주문의 (결제 당시 금액 − 현재 금액)",
"amount": by_pay["amount_diff"]},
{"key": "accepted", "label": "환불접수일(전체 상태) · 실제 환불액", "amount": refund_basis["accepted_all"]["actual_refund_amount"]},
{"key": "accepted_pts", "label": "환불접수일(전체 상태) · 실제 + 적립금·예치금", "amount": refund_basis["accepted_all"]["with_points"]},
{"key": "claim_pay", "label": "취소·반품·교환 완료 품목 · 품목 결제금액", "amount": claimed["payment_amount"]},
{"key": "claim_prod", "label": "취소·반품·교환 완료 품목 · 판매가(+옵션)×수량", "amount": claimed["product_amount"]},
{"key": "claim_pay_ship", "label": "완료 품목 결제금액 + 전체취소 주문 배송비",
"amount": claimed["payment_amount"] + claims["full_cancel_shipping"]},
{"key": "completed_plus_noref", "label": "환불완료 실제 환불액 + 환불 기록 없는 완료 품목 결제금액",
"amount": comp["actual_refund_amount"] + no_refund["payment_amount"]},
{"key": "completed_pts_plus_noref", "label": "환불완료 (실제+적립금) + 환불 기록 없는 완료 품목 결제금액",
"amount": comp["with_points"] + no_refund["payment_amount"]},
]
return {"date": day.isoformat(), "orders": groups, "refunds": refunds, "unpaid_orders": unpaid,
"by_channel": channels_out, "refund_basis": refund_basis,
"refund_list": sorted(refund_list.values(), key=lambda r: r["refund_code"]),
"claims": claims, "refund_candidates": candidates,
"no_record_claims": [{**c, "day": c["day"].isoformat(),
"order_date": c["order_date"].isoformat() if c["order_date"] else None}
for c in no_record],
"reduced_orders": sorted(reduced.values(), key=lambda r: r["diff"] - r["refunded"], reverse=True),
"by_payment": sorted(by_payment.values(), key=lambda v: v["total"], reverse=True),
"diag": {part: dict(sorted(v.items())) for part, v in diag.items()}, "odd_orders": odd,
"formula": "결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트(결제 당시). 참고식 = 상품구매금액 + 배송비 − 할인("
+ ", ".join(DISCOUNT_FIELDS) + ") − 쿠폰(" + ", ".join(COUPON_FIELDS) + ")"}
+112
View File
@@ -0,0 +1,112 @@
"""쿠팡 — 쿠팡 윙(마켓플레이스) Open API.
인증: Vendor ID + Access Key + Secret Key 로 요청마다 HMAC 서명(CEA 헤더).
signed-date = UTC "yyMMddTHHmmssZ", message = signed-date + METHOD + path + query(물음표 없이, 보내는 그대로)
Authorization: CEA algorithm=HmacSHA256, access-key=…, signed-date=…, signature=hex(HMAC-SHA256(secret, message))
(공식 문서 developers.coupangcorp.com → 시작하기 → HMAC Signature 생성 / Python Example, 2026-09-30 확인)
OPEN API 키는 판매자당 1개(유효기간 180일). 발급 방식이 둘 —
· 연동업체 선택(사방넷 등 1곳만): 그 업체 서버에서 쓰는 키. 우리 서버에서 부르면 막힐 수 있다.
· 자체개발: 업체명·URL·허용 IP(최대 10개). 우리 서버 IP 를 넣어야 한다.
연결 테스트는 오늘 결제완료 발주서 1건을 실제로 조회해 키·IP 가 통하는지 확인한다.
매출 수집(fetch_orders)은 아직 — 어느 WING 화면과 맞출지 정한 뒤 구현한다.
· 발주서 목록(v5 ordersheets, 주문일 기준, 상태별 조회) + 반품/취소 요청(v6 returnRequests, 접수일 기준, 금액 없음)
· 매출내역(v1 revenue-history)은 매출인식일(구매확정 또는 배송완료+7일) 기준이라 결제일 기준 일별 매출과 다르다.
로켓(공급) 매출은 기존 쿠팡 밀크런 모듈의 cupang_sales 에 있다 — 필요 시 별도 연계.
"""
from __future__ import annotations
import hashlib
import hmac
import time
from typing import Any
from urllib.parse import quote, urlencode
from .base import (
AdapterContext,
ApiError,
AuthFailed,
CredentialField,
MarketplaceAdapter,
NotConfigured,
)
HOST = "https://api-gateway.coupang.com"
def signed_date(now: float | None = None) -> str:
return time.strftime("%y%m%dT%H%M%SZ", time.gmtime(now))
def authorization(method: str, path: str, query: str, access_key: str, secret_key: str,
*, now: float | None = None) -> str:
"""쿠팡 CEA HMAC 헤더. query 는 실제로 보내는 문자열 그대로(물음표 제외)."""
dt = signed_date(now)
sig = hmac.new(secret_key.encode("utf-8"), f"{dt}{method}{path}{query}".encode("utf-8"),
hashlib.sha256).hexdigest()
return f"CEA algorithm=HmacSHA256, access-key={access_key}, signed-date={dt}, signature={sig}"
def build_query(params: dict[str, Any]) -> str:
"""쿠팡 예시와 같은 인코딩 — '+' 는 %2B, ':' 는 그대로(2026-09-30%2B09:00)."""
return urlencode({k: v for k, v in params.items() if v is not None}, quote_via=quote, safe=":")
class CoupangAdapter(MarketplaceAdapter):
code = "coupang"
name = "쿠팡"
auth_type = "api_key"
docs_url = "https://developers.coupangcorp.com/"
note = ("쿠팡 윙 → 판매자정보 → 추가판매정보 → OPEN API 키 발급에서 확인합니다. 키는 판매자당 1개이며, "
"'연동업체(사방넷 등)'로 발급한 키는 이 서버에서 막힐 수 있습니다 — 그때는 '자체개발'로 바꾸고 "
"이 서버 IP 를 허용 IP 에 넣어야 합니다(연결 테스트로 확인).")
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("vendor_id", "Vendor ID(업체코드)", placeholder="A00012345"),
CredentialField("access_key", "Access Key", secret=True),
CredentialField("secret_key", "Secret Key", secret=True),
]
# ── 호출 ──────────────────────────────────────────────
def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]:
import httpx # 지연 import
access, secret = ctx.credentials.get("access_key").strip(), ctx.credentials.get("secret_key").strip()
if not (access and secret):
raise NotConfigured("쿠팡 Vendor ID·Access Key·Secret Key 를 모두 입력하세요.")
query = build_query(params)
headers = {"Authorization": authorization("GET", path, query, access, secret),
"Content-Type": "application/json;charset=UTF-8"}
try:
res = httpx.get(f"{HOST}{path}?{query}", headers=headers, timeout=ctx.timeout_sec)
except httpx.HTTPError as exc:
raise ApiError(f"쿠팡 API 연결 실패: {type(exc).__name__}") from None
try:
body = res.json()
except ValueError:
body = {}
msg = str(body.get("message") or body.get("error") or res.text[:200] or "").strip()
if res.status_code in (401, 403):
raise AuthFailed(
f"쿠팡 인증 거부({res.status_code}): {msg}. Vendor ID·키가 맞는지 확인하세요. 키를 '연동업체(사방넷 등)'로 "
"발급했다면 이 서버에서 쓸 수 없을 수 있습니다 — WING 에서 '자체개발'로 바꾸고 이 서버 IP 를 허용 IP 에 "
"넣어야 합니다(사방넷 IP 도 함께 넣어야 사방넷이 계속 동작).")
if res.status_code >= 400:
raise ApiError(f"쿠팡 API 오류({res.status_code}): {msg}")
return body
def test_connection(self, ctx: AdapterContext) -> str:
from app.timezone import today_kst # noqa: WPS433
self.authenticate(ctx)
vendor = ctx.credentials.get("vendor_id").strip()
today = today_kst().isoformat()
body = self._get(ctx, f"/v2/providers/openapi/apis/api/v5/vendors/{vendor}/ordersheets",
{"createdAtFrom": f"{today}+09:00", "createdAtTo": f"{today}+09:00",
"status": "ACCEPT", "maxPerPage": 1})
n = len(body.get("data") or [])
return (f"쿠팡 연결 정상(발주서 조회 권한 확인, 오늘 결제완료 {'있음' if n else '없음'}). "
"매출 수집은 다음 단계에서 구현됩니다.")
@@ -0,0 +1,329 @@
"""11번가 — 11번가 셀러 오픈API.
인증: 셀러오피스(openapi.11st.co.kr → 서비스등록·확인)에서 발급한 Open API Key 를 요청 헤더 `openapikey` 에 넣는다.
셀러 API 는 등록한 IP 에서만 호출된다("Seller API 정보 수정"에서 서버 IP 등록, 셀링툴(사방넷 등)과 함께 쓸 수 있음).
(공식 이용방법 openapi.11st.co.kr → OpenApiOperationGuide SERVICE_METHOD, 2026-09-30 확인)
응답은 XML(euc-kr). 없는 주소는 500 + resultCode -997 "등록된 API 정보가 존재하지 않습니다", 건이 없으면 -1 "해당 건이 없습니다".
매출(2026-09-30 실데이터·셀러오피스 "판매 상세내역"으로 확정):
- SALE = 주문 하나(`11st:{ordNo}`), 날짜 = 결제일.
- 정산된 주문: 정산 내역(/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}, 정산확정일 stlDy 기준)의
판매금액합계(selPrcAmt) 합 — 판매 상세내역과 같고 배송비(도서산간 등)가 별도 줄로 들어 있다.
예: 9/10 주문 = 83,800 + 배송비 줄 3,000 = 86,800 (주문 목록의 dlvCst 는 0 이라 주문 목록만으로는 모자람).
- 정산 전 주문: 주문 상태 목록 4개(결제완료·발송대기·배송중·배송완료 — 지금 그 상태인 주문만, 배송완료에 구매확정 주문도
남음)의 ordAmt(판매금액, 11번가 부담 쿠폰 전) + 배송비(dlvCst 최댓값 한 번). 정산되면 다음 업데이트 때 정산 값으로 바뀐다.
- ordAmt − ordPayAmt = 11번가 부담 할인(= 정산 cupnAmt/tmallApplyDscAmt). 수수료는 판매금액 기준(34,900 × 13% = 4,537).
- 취소·반품된 주문은 목록에서 빠진다 → 기간을 통째로 다시 받아(replace_range) 매출에서 빠진다(취소 사건을 따로 만들지 않음).
"""
from __future__ import annotations
import re
import xml.etree.ElementTree as ET
from datetime import date, timedelta
from typing import Any, Iterable
from .base import (
AdapterContext,
AdapterError,
ApiError,
AuthFailed,
CredentialField,
MarketplaceAdapter,
SaleEvent,
)
HOST = "https://api.11st.co.kr"
def _xml_text(content: bytes) -> str:
"""11번가 XML 은 euc-kr 선언이 많다 — 파이썬 XML 파서가 다바이트 인코딩 선언을 못 읽어 직접 풀고 선언을 뗀다."""
head = content[:200].decode("ascii", "ignore")
m = re.search(r"encoding=[\"']([\w-]+)", head)
enc = (m.group(1) if m else "utf-8").lower()
try:
text = content.decode("cp949" if enc in ("euc-kr", "euckr", "ks_c_5601-1987") else enc)
except (LookupError, UnicodeDecodeError):
text = content.decode("utf-8", "replace")
return re.sub(r"^\s*<\?xml[^>]*\?>", "", text)
def xml_result(content: bytes) -> tuple[str, str, int]:
"""(결과코드, 결과문구, 주문 수). 네임스페이스와 무관하게 태그 끝 이름으로 찾는다. XML 이 아니면 코드 "not-xml"."""
try:
root = ET.fromstring(_xml_text(content))
except ET.ParseError:
return "not-xml", "", 0
if root.tag.rsplit("}", 1)[-1].lower() == "html": # 오류 안내 웹페이지(IP 차단 등)
return "not-xml", "", 0
code = text = ""
orders = 0
for el in root.iter():
tag = el.tag.rsplit("}", 1)[-1].lower()
if tag in ("result_code", "resultcode") and not code:
code = (el.text or "").strip()
elif tag in ("result_text", "resulttext", "result_message", "message") and not text:
text = (el.text or "").strip()
elif tag == "order":
orders += 1
return code, text, orders
# 원본 데이터 확인용 후보 주소 — {s}/{e} = yyyyMMddHHmm, {d} = yyyyMMdd. 문서 미확인 경로가 섞여 있어
# 404 등 실패도 그대로 보여 준다(어느 주소가 살아 있는지 확인하는 것이 목적).
PROBE_PATHS: tuple[tuple[str, str, str], ...] = (
("complete", "결제완료(발주확인 전)", "/rest/ordservices/complete/{s}/{e}"),
("packaging", "발송처리 대상(발주확인 후)", "/rest/ordservices/packaging/{s}/{e}"),
("shipping", "배송중", "/rest/ordservices/shipping/{s}/{e}"),
("completed", "배송완료", "/rest/ordservices/completed/{s}/{e}"),
("cancelorders", "취소신청", "/rest/claimservice/cancelorders/{s}/{e}"),
("canceledorders", "취소완료", "/rest/claimservice/canceledorders/{s}/{e}"),
("returnorders", "반품신청", "/rest/claimservice/returnorders/{s}/{e}"),
("returnedorders", "반품완료", "/rest/claimservice/returnedorders/{s}/{e}"),
("purchaseconfirm", "구매확정(후보)", "/rest/ordservices/purchaseconfirm/{s}/{e}"),
("settlement", "정산 내역", "/rest/settlement/settlementList/{ds}/{de}"),
)
NO_DATA = re.compile(r"해당\s*건이\s*없|조회된?\s*(내역|건|데이터)이?\s*없") # 코드 -1 이어도 "0건"
PROBE_CHUNK_DAYS = 7
PROBE_MAX_DAYS = 31
# 개인정보로 보이는 항목 — 값은 보이지 않고 이름만(이름·연락처·주소·우편번호·아이디·메일·메모)
PERSONAL = re.compile(r"(nm|name|tel|tlphn|phone|hp|addr|zip|mail|id|memo|msg|pcc|clearance|birth)$|rcvr|ordnm|buyer",
re.IGNORECASE)
NUMBER = re.compile(r"^-?\d+(\.\d+)?$")
SAFE = re.compile(r"^(prd|opt|slct|dlvEtprs|dlvMthd|clm|reason|stl|sel)", re.IGNORECASE) # 상품·옵션·클레임 사유 등은 보임
def xml_records(content: bytes) -> list[dict[str, str]]:
"""응답에서 주문(또는 클레임·정산) 한 줄씩 — 자식이 모두 글자 항목인 요소를 한 줄로 본다(태그 끝 이름 → 값)."""
try:
root = ET.fromstring(_xml_text(content))
except ET.ParseError:
return []
out: list[dict[str, str]] = []
for el in root.iter():
kids = list(el)
if len(kids) >= 3 and all(len(k) == 0 for k in kids):
out.append({k.tag.rsplit("}", 1)[-1]: (k.text or "").strip() for k in kids})
return out
def field_summary(records: list[dict[str, str]]) -> list[dict[str, Any]]:
"""항목별: 채워진 줄 수, 숫자면 합계, 개인정보 아니면 예시 값 하나."""
names: dict[str, dict[str, Any]] = {}
for r in records:
for k, v in r.items():
f = names.setdefault(k, {"name": k, "filled": 0, "numeric": True, "sum": 0.0, "sample": "",
"personal": bool(PERSONAL.search(k)) and not SAFE.match(k)})
if not v:
continue
f["filled"] += 1
if NUMBER.match(v) and f["numeric"]:
f["sum"] += float(v)
else:
f["numeric"] = False
if not f["sample"] and not f["personal"]:
f["sample"] = v[:40]
for f in names.values():
f["sum"] = int(round(f["sum"])) if f["numeric"] and f["filled"] else None
return list(names.values())
# 매출 수집 — 주문 상태 목록 4개(지금 그 상태인 주문만 준다). 배송완료 목록에는 구매확정된 주문도 남는다(실데이터 확인).
# 취소·반품된 주문은 이 목록들에서 빠진다 → 기간을 통째로 다시 받아(replace_range) 매출에서 자연히 빠지게 한다.
ORDER_PATHS = ("/rest/ordservices/complete/{s}/{e}", "/rest/ordservices/packaging/{s}/{e}",
"/rest/ordservices/shipping/{s}/{e}", "/rest/ordservices/completed/{s}/{e}")
ORDER_STATUS = {"complete": "결제완료", "packaging": "발송대기", "shipping": "배송중", "completed": "배송완료"}
# 목록의 날짜 조건이 주문일인지 상태 변경일(배송완료일 등)인지 문서로 확인 못 해, 기간 뒤로 넉넉히 더 불러
# 주문일로 거른다(나중에 배송완료된 주문도 빠지지 않게).
LOOKAHEAD_DAYS = 30
SETTLE_LOOKAHEAD_DAYS = 45 # 결제 → 정산확정(구매확정)까지 보통 1~3주
SETTLEMENT_PATH = "/rest/settlement/settlementList/{ds}/{de}"
EVENT_PREFIX = "11st:"
def _won(value: Any) -> int:
try:
return int(round(float(str(value or "0").replace(",", ""))))
except ValueError:
return 0
def _day(value: Any) -> date | None:
""""2026-09-09 15:13:16" / "2026/09/09" / "20260909" → date."""
s = re.sub(r"[^0-9]", "", str(value or ""))[:8]
if len(s) < 8:
return None
try:
return date(int(s[:4]), int(s[4:6]), int(s[6:8]))
except ValueError:
return None
def _n_chunks(lo: date, hi: date) -> int:
return max(0, ((hi - lo).days + PROBE_CHUNK_DAYS) // PROBE_CHUNK_DAYS)
class ElevenstAdapter(MarketplaceAdapter):
code = "elevenst"
name = "11번가"
auth_type = "api_key"
implemented = True
replace_range = True
event_prefix = EVENT_PREFIX
docs_url = "https://openapi.11st.co.kr/"
note = ("11번가 셀러오피스 → 오픈API 에서 발급한 키를 입력합니다. 셀러 API 는 등록한 IP 에서만 호출되므로 "
"'Seller API 정보 수정 → IP 직접 입력'에 이 서버의 외부 IP 를 넣어야 합니다.")
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("api_key", "Open API Key", secret=True),
]
# ── 수집 ──────────────────────────────────────────────
def _pages(self, ctx: AdapterContext, tmpl: str, lo: date, hi: date) -> Iterable[dict[str, str]]:
"""[lo, hi] 를 7일씩 나눠 한 주소를 부른다."""
s = lo
while s <= hi:
e = min(hi, s + timedelta(days=PROBE_CHUNK_DAYS - 1))
ds, de = s.strftime("%Y%m%d"), e.strftime("%Y%m%d")
rows = xml_records(self._get(ctx, tmpl.format(s=f"{ds}0000", e=f"{de}2359", ds=ds, de=de)))
ctx.progress.step(items=len(rows))
yield from rows
s = e + timedelta(days=1)
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
"""결제일이 [start, end] 인 주문을 주문 단위로 합쳐 돌려준다.
1) 정산 내역 — 정산확정일 기준이라 [start, end+45일(오늘까지)] 를 불러 결제일(ordStlEndDt)로 거른다.
판매금액합계(selPrcAmt)는 셀러오피스 "판매 상세내역"과 같고 배송비 줄(도서산간 등)도 따로 들어 있다.
2) 아직 정산 전인 주문 — 주문 상태 목록 4개([start, end+30일]) 의 ordAmt + 배송비(dlvCst 최댓값 한 번).
같은 주문이 정산에 있으면 정산 값을 쓴다(정산되면 다음 업데이트 때 정산 값으로 바뀜)."""
from app.timezone import today_kst # noqa: WPS433
today = today_kst()
orders: dict[str, dict[str, Any]] = {}
def acc(oid: str, src: str, day: date) -> dict[str, Any]:
return orders.setdefault(oid, {"ordNo": oid, "_src": src, "_day": day, "amount": 0, "qty": 0,
"discount": 0, "ship": 0, "names": [], "opt": "", "raw": {}})
settle_hi = max(end, min(end + timedelta(days=SETTLE_LOOKAHEAD_DAYS), today))
hi = max(end, min(end + timedelta(days=LOOKAHEAD_DAYS), today))
# 진행 막대: 7일 구간마다 한 번 — 정산 내역 + 주문 상태 목록 4개
ctx.progress.plan(_n_chunks(start, settle_hi) + len(ORDER_PATHS) * _n_chunks(start, hi), "구간")
for r in self._pages(ctx, SETTLEMENT_PATH, start, settle_hi):
oid, day = str(r.get("ordNo") or ""), _day(r.get("ordStlEndDt"))
if not oid or day is None or not (start <= day <= end):
continue
o = acc(oid, "settlement", day)
o["amount"] += _won(r.get("selPrcAmt"))
o["qty"] += _won(r.get("ordQty"))
o["discount"] += _won(r.get("cupnAmt"))
if r.get("prdNm") and r["prdNm"] not in o["names"]:
o["names"].append(r["prdNm"])
o["opt"] = o["opt"] or str(r.get("slctPrdOptNm") or "")
for k in ("stlAmt", "selFee", "deductAmt", "bmStlDlvCst"):
o["raw"][k] = o["raw"].get(k, 0) + _won(r.get(k))
o["raw"]["stlDy"] = r.get("stlDy")
settled = set(orders)
seen: set[str] = set()
for tmpl in ORDER_PATHS:
status = ORDER_STATUS[tmpl.split("/")[3]]
for r in self._pages(ctx, tmpl, start, hi):
oid = str(r.get("ordNo") or "")
key = f"{oid}-{r.get('ordPrdSeq')}"
day = _day(r.get("ordStlEndDt") or r.get("ordDt"))
if not oid or oid in settled or key in seen or day is None or not (start <= day <= end):
continue
seen.add(key)
o = acc(oid, status, day)
o["amount"] += _won(r.get("ordAmt"))
o["ship"] = max(o["ship"], _won(r.get("dlvCst")))
o["qty"] += _won(r.get("ordQty"))
o["discount"] += max(0, _won(r.get("ordAmt")) - _won(r.get("ordPayAmt")))
if r.get("prdNm") and r["prdNm"] not in o["names"]:
o["names"].append(r["prdNm"])
o["opt"] = o["opt"] or str(r.get("slctPrdOptNm") or "")
o["raw"]["ordDt"] = r.get("ordDt")
for o in orders.values():
o["amount"] += o.pop("ship")
yield o
def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]:
"""주문 하나 → SALE(결제일). 금액 = 정산 판매금액합계(정산 전이면 ordAmt + 배송비) — 11번가 부담 쿠폰 전 금액.
수수료가 판매금액 기준이라(34,900 × 13% = 4,537, 정산 실데이터) 판매자 매출은 할인 전 금액으로 본다."""
oid, day = str(o.get("ordNo") or ""), o.get("_day")
if not oid or day is None:
return []
names = o.get("names") or []
name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else ""
return [SaleEvent(
event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}", external_order_id=oid,
payment_date=day, event_date=day, amount=max(0, int(o.get("amount") or 0)),
product_name=name[:200], option_name=str(o.get("opt") or "")[:200], quantity=int(o.get("qty") or 0),
discount_amount=max(0, int(o.get("discount") or 0)),
order_status="정산확정" if o.get("_src") == "settlement" else str(o.get("_src") or ""),
raw={"source": o.get("_src"), **(o.get("raw") or {})},
)]
def _get(self, ctx: AdapterContext, path: str) -> bytes:
import httpx # 지연 import
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
headers = {"openapikey": ctx.credentials.get("api_key").strip(), "Accept": "application/xml"}
try:
res = httpx.get(f"{HOST}{path}", headers=headers, timeout=ctx.timeout_sec)
except httpx.HTTPError as exc:
raise ApiError(f"11번가 API 연결 실패: {type(exc).__name__} — 등록한 IP 가 이 서버 IP 인지 확인하세요.") from None
code, text, _ = xml_result(res.content)
detail = text or res.text[:200].strip()
if res.status_code in (401, 403):
raise AuthFailed(f"11번가 인증 거부({res.status_code}): {detail}. 키와 등록 IP(이 서버 외부 IP)를 확인하세요.")
if res.status_code >= 400:
raise ApiError(f"11번가 API 오류({res.status_code}): {detail}")
if code == "not-xml":
raise ApiError(f"11번가가 예상하지 못한 응답을 돌려줬습니다(XML 아님): {res.text[:120].strip()}")
if code and code not in ("0", "200", "00") and not NO_DATA.search(text):
raise ApiError(f"11번가 API 오류(코드 {code}): {detail}")
return res.content
# ── 원본 데이터 확인(설정 화면 "11번가 원본 데이터 확인") ─────────
def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]:
"""후보 조회 주소마다 기간(day~to, 최대 31일, 7일씩 나눠)을 실제로 불러 동작 여부·줄 수·항목별 합계를 돌려준다.
셀러 API 상세 문서가 로그인 뒤에만 있어, 어느 주소·항목이 셀러오피스 화면 매출과 맞는지 실데이터로 확정하는 용도.
개인정보 항목(이름·연락처·주소·아이디 등)은 값 없이 이름만."""
self.authenticate(ctx)
to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1))
chunks = []
s = day
while s <= to:
e = min(to, s + timedelta(days=PROBE_CHUNK_DAYS - 1))
chunks.append((s, e))
s = e + timedelta(days=1)
out = []
for key, label, tmpl in PROBE_PATHS:
row: dict[str, Any] = {"key": key, "label": label, "path": tmpl.split("/{")[0] + "/…"}
records: list[dict[str, str]] = []
error = ""
for s, e in chunks:
ds, de = s.strftime("%Y%m%d"), e.strftime("%Y%m%d")
try:
records += xml_records(self._get(ctx, tmpl.format(s=f"{ds}0000", e=f"{de}2359", ds=ds, de=de)))
except AdapterError as exc:
error = exc.message[:200]
break
if error:
out.append({**row, "ok": False, "error": error})
else:
out.append({**row, "ok": True, "count": len(records), "fields": field_summary(records)})
return {"date": day.isoformat(), "to": to.isoformat(), "probes": out}
def test_connection(self, ctx: AdapterContext) -> str:
from app.timezone import today_kst # noqa: WPS433
self.authenticate(ctx)
d = today_kst().strftime("%Y%m%d")
body = self._get(ctx, f"/rest/ordservices/complete/{d}0000/{d}2359")
_, _, orders = xml_result(body)
return f"11번가 연결 정상(주문 조회 권한 확인, 오늘 결제완료 {orders}건)."
@@ -0,0 +1,23 @@
"""G마켓 — ESM(ESM Plus / ESM Trading API).
인증: ESM 마스터 ID + 판매자 ID + 발급 Secret Key 로 JWT 서명(연동 단계에서 확정).
"""
from __future__ import annotations
from .base import CredentialField, MarketplaceAdapter
class GmarketAdapter(MarketplaceAdapter):
code = "gmarket"
name = "G마켓"
auth_type = "api_key"
docs_url = "https://etapi.gmarket.com/"
note = "ESM Plus 에서 발급한 API 인증정보를 입력합니다."
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("master_id", "ESM 마스터 ID"),
CredentialField("seller_id", "G마켓 판매자 ID"),
CredentialField("secret_key", "Secret Key", secret=True),
]
+308
View File
@@ -0,0 +1,308 @@
"""GS샵 — GSSHOP 제휴 API(협력사 API V3, partners.gsshop.com → 제휴 API → 개발가이드).
인증(개발가이드 2026-09-30 확인): 요청 헤더
supCd = 협력사코드
token = AES256( Sysdate("yyyyMMddHHmmss") + 협력사코드 ) 예: "20181017174913" + "1036018"
AES256 암복호화 키는 partners.gsshop.com/api/apiMain 에 로그인하면 보인다.
암호화 모드(CBC/ECB, IV)와 키를 바이트로 쓰는 법은 문서에 없다 → 키 변형(글자 그대로 / 16진수 풀기 / 앞 32자,
key_variants) × 모드(CBC·IV=키 앞 16바이트 → ECB → CBC·IV=0) 순서로 시도하고 통과한 조합을 기억한다. 출력은 base64.
(포털 "운영 KEY" 는 16진수처럼 보이는 글자 — 32자면 글자 그대로 AES256, 64자면 16진수로 풀어 32바이트일 수 있다.)
token 이 틀리면 HTTP 200 + {"result":"fail","message":"키 인증 중 오류…","code":"401 UNAUTHORIZED"}.
주소: 운영 https://withgs-api.gsshop.com (개발가이드의 예시 주소 atwithgs-api 는 테스트용 — 두 곳 모두 응답 확인).
매출(Settlement API 1.0): GET /api/v2/settlement/out/sales/period?supCode=&fromDate=&toDate=&pageIdx=&rowsPerPage=
— 매출인식일(YYYYMMDD) 기준, 한 번에 10일까지, 쪽당 최대 1만 건. 응답 {data:[…], hasMorePage, totalCount, …}.
배송비는 /api/v2/settlement/out/sales/shippingFee/period(같은 조건).
응답 줄 항목(2026-09-30 실데이터 9/3 — 개발가이드 예시에는 없음): saleAwareDt(매출인식일), ordNo·ordItemNo·orgOrdNo,
ordType(SALE …), prdCd·prdNm, chrQty(수량), salePrice(할인 전 판매가 — 줄 합계), dcTotAmt(할인 합계),
custChrAmt(고객 결제금액 = salePrice − dcTotAmt), supGiveAmt(협력사 지급액, 수수료 차감), sup*DcAmt(협력사 부담 할인).
9/3: salePrice 211,100 − dcTotAmt 19,528 = custChrAmt 191,572, supGiveAmt 179,435, 배송비 내역 7,000.
**주문일 기준 조회 API 는 없다**(V3 문서에 주문 조회 없음) — 협력사 포털 주문 통계(총주문금액, 주문일)와는 기준이 달라
날짜별로 똑같이 맞출 수 없다.
매출 규칙 — 협력사 포털 주문 통계의 금액 = **supGiveAmt(협력사 지급액)**(2026-09-30, 9월 실데이터로 확인):
미라미라클 6호세트 포털 176,715 ÷ 9 = 19,635 = API 줄 supGiveAmt 19,635(판매가 23,100·고객 결제 20,330),
7호세트 39,015 = 45,900 × 85%, 주부체험 세트 8,910 = 9,900 × 90% — 상품마다 GS 수수료율이 달라 판매가 × 요율로는 못 맞춘다.
9/1~9/29: 지급액 4,972,689 / 포털 순주문 4,823,074(차이는 주문일 ↔ 매출인식일 기준 차이·취소분).
- 매출 내역 한 줄 = 사건 하나(`gs:{ordNo}-{ordItemNo}-{ordType}-{saleAwareDt}`), 날짜 = 매출인식일.
- 금액 = supGiveAmt, 배송비 제외. 이미 GS 수수료를 뺀 금액이라 **실적 설정의 GS샵 수수료율은 0%** 로 둔다.
ordType 이 SALE 이 아니면(취소·반품 등) 음수로(RETURN). 할인 = dcTotAmt. 기간을 통째로 다시 받는다(replace_range).
"""
from __future__ import annotations
import base64
from datetime import date, datetime, timedelta
from typing import Any, Iterable
from .base import (
AdapterContext,
AdapterError,
ApiError,
AuthFailed,
CredentialField,
MarketplaceAdapter,
NotConfigured,
SaleEvent,
)
from .elevenst import field_summary
HOST = "https://withgs-api.gsshop.com"
SALES_PATH = "/api/v2/settlement/out/sales/period"
SHIPPING_PATH = "/api/v2/settlement/out/sales/shippingFee/period"
DAILY_SALES_PATH = "/api/v2/settlement/out/sales"
CHUNK_DAYS = 10 # 기간 조회는 시작일부터 10일 이내
ROWS_PER_PAGE = 10000
MAX_PAGES = 50
PROBE_MAX_DAYS = 31
TOKEN_MODES = ("cbc-keyiv", "ecb", "cbc-zeroiv")
MODE_LABEL = {"cbc-keyiv": "AES/CBC(IV=키 앞 16바이트)", "ecb": "AES/ECB", "cbc-zeroiv": "AES/CBC(IV=0)"}
KEY_LABEL = {"text": "키 글자 그대로", "hex": "키 16진수 풀기", "first32": "키 앞 32자"}
def key_variants(aes_key: str) -> list[tuple[str, bytes]]:
"""AES 키로 쓸 수 있는 바이트 후보(시도 순서). 하나도 없으면 길이 오류."""
raw = aes_key.strip().encode("utf-8")
out: list[tuple[str, bytes]] = []
if len(raw) in (16, 24, 32):
out.append(("text", raw))
txt = aes_key.strip()
if len(txt) in (32, 48, 64) and all(c in "0123456789abcdefABCDEF" for c in txt):
out.append(("hex", bytes.fromhex(txt)))
if len(raw) > 32:
out.append(("first32", raw[:32]))
if not out:
raise AuthFailed(f"AES 키 길이가 올바르지 않습니다({len(raw)}자). 제휴 API 메인 화면의 운영 KEY 를 "
"[복사] 버튼으로 복사해 그대로 붙여 넣으세요.")
return out
def make_token(aes_key: str | bytes, sup_cd: str, now: datetime, mode: str) -> str:
"""token = base64(AES(yyyyMMddHHmmss + 협력사코드)), PKCS7(=PKCS5) 패딩. aes_key 가 글자면 그대로 바이트로."""
from cryptography.hazmat.primitives import padding # 지연 import
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
key = aes_key if isinstance(aes_key, bytes) else aes_key.encode("utf-8")
if len(key) not in (16, 24, 32):
raise AuthFailed(f"AES 키 길이가 올바르지 않습니다({len(key)}바이트 — 16·24·32 중 하나여야 함). "
"제휴 API 메인 화면의 키를 그대로 붙여 넣으세요.")
plain = (now.strftime("%Y%m%d%H%M%S") + sup_cd).encode("utf-8")
padder = padding.PKCS7(128).padder()
data = padder.update(plain) + padder.finalize()
if mode == "ecb":
cipher = Cipher(algorithms.AES(key), modes.ECB())
elif mode == "cbc-zeroiv":
cipher = Cipher(algorithms.AES(key), modes.CBC(b"\0" * 16))
else:
cipher = Cipher(algorithms.AES(key), modes.CBC(key[:16]))
enc = cipher.encryptor()
return base64.b64encode(enc.update(data) + enc.finalize()).decode("ascii")
def _rows(body: dict[str, Any]) -> list[dict[str, Any]]:
data = body.get("data")
return [r for r in data if isinstance(r, dict)] if isinstance(data, list) else []
def _strs(row: dict[str, Any]) -> dict[str, str]:
"""원본 확인용 — 값은 모두 글자로(중첩은 JSON 글자 그대로 짧게)."""
return {str(k): ("" if v is None else str(v)) for k, v in row.items()}
EVENT_PREFIX = "gs:"
def _won(value: Any) -> int:
try:
return int(round(float(str(value if value is not None else 0).replace(",", ""))))
except ValueError:
return 0
def _yyyymmdd(value: Any) -> date | None:
s = "".join(ch for ch in str(value or "") if ch.isdigit())[:8]
if len(s) < 8:
return None
try:
return date(int(s[:4]), int(s[4:6]), int(s[6:8]))
except ValueError:
return None
class GsshopAdapter(MarketplaceAdapter):
code = "gsshop"
name = "GS샵"
auth_type = "api_key"
implemented = True
replace_range = True
event_prefix = EVENT_PREFIX
docs_url = "https://partners.gsshop.com/api/apiDevGuide"
note = ("GS SHOP 협력사 포털(partners.gsshop.com) → 제휴 API 메인 화면의 협력사코드와 "
"운영 KEY(오른쪽 [복사] 버튼)를 입력합니다. 개발 KEY 가 아니라 운영 KEY 입니다.")
def __init__(self) -> None:
self._mode: dict[str, tuple[str, str]] = {} # 협력사코드 → 통과한 (키 변형, 암호화 모드)
def credential_fields(self) -> list[CredentialField]:
# 키 이름(vendor_code·api_key)은 처음 만든 입력칸 그대로 — 이미 저장한 값을 다시 넣지 않아도 되게.
return [
CredentialField("vendor_code", "협력사코드(supCd)", help="예: 1036018"),
CredentialField("api_key", "운영 KEY(AES256 암복호화 키)", secret=True,
help="제휴 API 메인 화면의 운영 KEY — [복사] 버튼으로 복사해 붙여 넣기"),
]
# ── 호출 ──────────────────────────────────────────────
def _creds(self, ctx: AdapterContext) -> tuple[str, str]:
sup = ctx.credentials.get("vendor_code").strip()
key = ctx.credentials.get("api_key").strip()
if not sup or not key:
raise NotConfigured("협력사코드와 AES256 키를 입력하세요.")
return sup, key
def _call(self, ctx: AdapterContext, path: str, params: dict[str, Any], how: tuple[str, str]) -> dict[str, Any]:
import httpx # 지연 import
from app.timezone import now_kst # noqa: WPS433
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
sup, key = self._creds(ctx)
key_bytes = dict(key_variants(key))[how[0]]
headers = {"supCd": sup, "token": make_token(key_bytes, sup, now_kst(), how[1]), "Accept": "application/json"}
try:
res = httpx.get(f"{HOST}{path}", params={"supCode": sup, **params}, headers=headers, timeout=ctx.timeout_sec)
except httpx.HTTPError as exc:
raise ApiError(f"GS샵 API 연결 실패: {type(exc).__name__}") from None
try:
body = res.json()
except ValueError:
raise ApiError(f"GS샵이 예상하지 못한 응답을 돌려줬습니다({res.status_code}): {res.text[:150].strip()}") from None
if not isinstance(body, dict):
body = {"data": body}
code = str(body.get("code") or "")
msg = str(body.get("message") or "")[:200]
if res.status_code in (401, 403) or (str(body.get("result")) == "fail" and ("401" in code or "403" in code)):
raise AuthFailed(f"GS샵 인증 거부({code or res.status_code}): {msg}")
if res.status_code >= 400 or str(body.get("result")) == "fail":
raise ApiError(f"GS샵 API 오류({code or res.status_code}): {msg or res.text[:150].strip()}")
return body
def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]:
"""토큰 만드는 법(키 변형 × 암호화 모드)을 모르면 순서대로 시도 — 통과한 조합을 기억한다."""
sup, key = self._creds(ctx)
known = self._mode.get(sup)
if known:
return self._call(ctx, path, params, known)
tries = [(v, m) for v, _ in key_variants(key) for m in TOKEN_MODES]
last: AuthFailed | None = None
for how in tries:
try:
body = self._call(ctx, path, params, how)
except AuthFailed as exc:
last = exc
continue
self._mode[sup] = how
return body
raise AuthFailed(f"{last.message if last else 'GS샵 인증 실패'} — 토큰 만드는 방식 {len(tries)}가지 모두 거부. "
"협력사코드·운영 KEY 가 맞는지, 서버 시각이 정확한지 확인하세요.")
def _pages(self, ctx: AdapterContext, path: str, lo: date, hi: date) -> list[dict[str, Any]]:
"""[lo, hi] 를 10일씩 나눠 쪽을 넘겨 모두 받는다."""
out: list[dict[str, Any]] = []
s = lo
while s <= hi:
e = min(hi, s + timedelta(days=CHUNK_DAYS - 1))
for page in range(1, MAX_PAGES + 1):
body = self._get(ctx, path, {"fromDate": s.strftime("%Y%m%d"), "toDate": e.strftime("%Y%m%d"),
"pageIdx": page, "rowsPerPage": ROWS_PER_PAGE})
rows = _rows(body)
out.extend(rows)
if not body.get("hasMorePage") or not rows:
break
ctx.progress.step(items=len(out))
s = e + timedelta(days=1)
return out
# ── 수집 ──────────────────────────────────────────────
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
"""매출인식일이 [start, end] 인 매출 내역 줄. 같은 사건 ID 가 두 번 나오면 뒤에 번호를 붙여 둘 다 남긴다."""
ctx.progress.plan(max(1, ((end - start).days + CHUNK_DAYS) // CHUNK_DAYS), "구간")
seen: dict[str, int] = {}
for r in self._pages(ctx, SALES_PATH, start, end):
day = _yyyymmdd(r.get("saleAwareDt"))
if day is None or not (start <= day <= end):
continue
base = f"{r.get('ordNo')}-{r.get('ordItemNo')}-{r.get('ordType') or 'SALE'}-{day.strftime('%Y%m%d')}"
n = seen.get(base, 0)
seen[base] = n + 1
yield {**r, "_day": day, "_id": base if n == 0 else f"{base}-{n + 1}"}
def normalize_order(self, r: dict[str, Any]) -> list[SaleEvent]:
"""매출 내역 한 줄 → SALE(ordType=SALE) 또는 RETURN(그 밖, 음수). 금액 = supGiveAmt(협력사 지급액 — 포털 주문 통계 금액)."""
oid, day = str(r.get("ordNo") or ""), r.get("_day")
if not oid or day is None:
return []
kind = str(r.get("ordType") or "SALE").upper()
amount = abs(_won(r.get("supGiveAmt")))
is_sale = kind == "SALE"
return [SaleEvent(
event_type="SALE" if is_sale else "RETURN", external_event_id=f"{EVENT_PREFIX}{r['_id']}",
external_order_id=oid, external_line_id=str(r.get("ordItemNo") or ""), event_date=day,
payment_date=day if is_sale else None, amount=amount if is_sale else -amount,
product_name=str(r.get("prdNm") or "")[:200], quantity=abs(_won(r.get("chrQty"))),
discount_amount=abs(_won(r.get("dcTotAmt"))), order_status=kind[:50],
raw={"salePrice": _won(r.get("salePrice")), "custChrAmt": _won(r.get("custChrAmt")),
"orgOrdNo": str(r.get("orgOrdNo") or ""), "prdCd": str(r.get("prdCd") or "")},
)]
def test_connection(self, ctx: AdapterContext) -> str:
from app.timezone import today_kst # noqa: WPS433
self.authenticate(ctx)
sup, _ = self._creds(ctx)
self._mode.pop(sup, None) # 입력값을 바꿨을 수 있으니 모드를 다시 찾는다
day = today_kst() - timedelta(days=1)
body = self._get(ctx, DAILY_SALES_PATH, {"stdDate": day.strftime("%Y%m%d"), "pageIdx": 1, "rowsPerPage": 10})
total = body.get("totalCount")
return (f"GS샵 연결 정상(매출 내역 조회 확인, 어제 매출 {total if total is not None else len(_rows(body))}건, "
f"토큰 {self._how_label(sup)}).")
def _how_label(self, sup: str) -> str:
v, m = self._mode.get(sup, ("", ""))
return f"{MODE_LABEL.get(m, m)}, {KEY_LABEL.get(v, v)}"
# ── 원본 데이터 확인(설정 화면 "쇼핑몰 원본 데이터 확인") ─────────
def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]:
"""매출 내역·배송비 내역을 기간(최대 31일, 10일씩)으로 실제 불러 항목별 합계를 돌려준다(저장 안 함).
응답 항목 이름이 개발가이드에 없어 협력사 포털 매출 화면과 맞는 항목을 실데이터로 확정하는 용도."""
self.authenticate(ctx)
to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1))
probes = []
got: dict[str, list[dict[str, Any]]] = {}
for key, label, path in (("sales", "매출 내역(매출인식일 기준)", SALES_PATH),
("shipping", "배송비 내역(매출인식일 기준)", SHIPPING_PATH)):
row: dict[str, Any] = {"key": key, "label": label, "path": path}
try:
rows = self._pages(ctx, path, day, to)
except AdapterError as exc:
probes.append({**row, "ok": False, "error": exc.message[:300]})
continue
got[key] = rows
probes.append({**row, "ok": True, "count": len(rows), "fields": field_summary([_strs(r) for r in rows])})
# 날짜별 현재 규칙 매출(supGiveAmt, SALE 아닌 줄은 음수) — 협력사 포털 매출 화면과 나란히 비교
days = []
d = day
while d <= to:
sales = [r for r in got.get("sales", []) if _yyyymmdd(r.get("saleAwareDt")) == d]
ret = [r for r in sales if str(r.get("ordType") or "SALE").upper() != "SALE"]
amt = sum(abs(_won(r.get("supGiveAmt"))) for r in sales if r not in ret) - sum(abs(_won(r.get("supGiveAmt"))) for r in ret)
days.append({"date": d.isoformat(), "orders": len({str(r.get("ordNo")) for r in sales if r not in ret}),
"amount": amt, "claimed": sum(abs(_won(r.get("supGiveAmt"))) for r in ret),
"ship": sum(_won(r.get("salePrice")) for r in got.get("shipping", [])
if _yyyymmdd(r.get("saleAwareDt")) == d)})
d += timedelta(days=1)
return {"date": day.isoformat(), "to": to.isoformat(), "probes": probes, "days": days,
"day_cols": {"claimed": "그중 취소·반품(음수로 반영)", "ship": "배송비(참고, 매출 제외)"},
"rule": "매출인식일 기준 매출 내역 supGiveAmt(협력사 지급액 = 포털 주문 통계 금액) 합, SALE 이 아닌 줄은 빼기, "
"배송비 제외. 주문 통계는 주문일 기준이라 날마다 같지는 않고 기간이 길수록 가까워진다"}
+21
View File
@@ -0,0 +1,21 @@
"""카카오 — 카카오쇼핑(톡스토어) 판매자 API.
인증 방식·필드는 연동 단계에서 공식 문서로 확정한다.
"""
from __future__ import annotations
from .base import CredentialField, MarketplaceAdapter
class KakaoAdapter(MarketplaceAdapter):
code = "kakao"
name = "카카오"
auth_type = "api_key"
note = "입력 항목은 연동 단계에서 카카오쇼핑 판매자 API 문서로 확정합니다."
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("seller_id", "판매자(채널) ID"),
CredentialField("api_key", "API Key", secret=True),
]
@@ -0,0 +1,21 @@
"""롯데ON — 롯데ON 판매자 API.
인증: 거래처번호 + 발급 API Key(연동 단계에서 확정).
"""
from __future__ import annotations
from .base import CredentialField, MarketplaceAdapter
class LotteonAdapter(MarketplaceAdapter):
code = "lotteon"
name = "롯데ON"
auth_type = "api_key"
note = "롯데ON 스토어센터에서 발급한 API 인증정보를 입력합니다."
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("trade_no", "거래처번호"),
CredentialField("api_key", "API Key", secret=True),
]
+63
View File
@@ -0,0 +1,63 @@
"""테스트(모의) 매출 데이터 — 실제 API 연동 전 화면 확인용.
같은 (쇼핑몰, 날짜)면 항상 같은 값이 나온다(재현 가능). 결제뿐 아니라 전체 취소·
부분 반품도 섞어 넣어 음수 반영과 합계를 확인할 수 있게 한다.
DB 에는 is_sample=TRUE 로 들어가며 설정 화면에서 한 번에 지울 수 있다.
"""
from __future__ import annotations
import random
from datetime import date, timedelta
from .base import SaleEvent
# 쇼핑몰별 하루 평균 주문 건수(모의값) — 화면에 차이가 보이도록만 다르게 둔다.
_DAILY_ORDERS = {
"cafe24": 9, "naver": 14, "coupang": 18, "ohouse": 4, "gmarket": 6,
"kakao": 3, "gsshop": 2, "elevenst": 4, "lotteon": 2, "toss": 1,
}
_PRODUCTS = (
("스테인리스 냄비 20cm", 39_000), ("프라이팬 28cm", 45_900), ("밀폐용기 5종 세트", 29_800),
("도마 대형", 19_900), ("칼 블록 세트", 89_000), ("주방 가위", 12_900),
("냄비 받침", 8_900), ("전골 냄비", 59_000),
)
def generate(code: str, start: date, end: date) -> list[SaleEvent]:
events: list[SaleEvent] = []
base = _DAILY_ORDERS.get(code, 3)
d = start
while d <= end:
rng = random.Random(f"perf-sample:{code}:{d.isoformat()}")
weekend = d.weekday() >= 5
n = max(0, int(rng.gauss(base * (0.7 if weekend else 1.0), base * 0.35)))
for i in range(n):
name, price = rng.choice(_PRODUCTS)
qty = 1 if rng.random() < 0.8 else rng.randint(2, 3)
discount = rng.choice((0, 0, 0, 1000, 2000, 3000))
amount = max(0, price * qty - discount)
order_id = f"SAMPLE-{code}-{d:%Y%m%d}-{i:03d}"
events.append(SaleEvent(
event_type="SALE", external_event_id=f"{order_id}-S", external_order_id=order_id,
external_line_id="1", order_date=d, payment_date=d, event_date=d, amount=amount,
product_name=name, quantity=qty, discount_amount=discount, order_status="결제완료",
raw={"sample": True},
))
roll = rng.random()
if roll < 0.05: # 전체 취소(당일~2일 뒤)
cd = min(end, d + timedelta(days=rng.randint(0, 2)))
events.append(SaleEvent(
event_type="CANCEL", external_event_id=f"{order_id}-C", external_order_id=order_id,
external_line_id="1", order_date=d, payment_date=d, event_date=cd, amount=-amount,
product_name=name, quantity=-qty, order_status="취소완료", raw={"sample": True},
))
elif roll < 0.08 and qty > 1: # 부분 반품(1개, 3~7일 뒤)
rd = min(end, d + timedelta(days=rng.randint(3, 7)))
events.append(SaleEvent(
event_type="RETURN", external_event_id=f"{order_id}-R", external_order_id=order_id,
external_line_id="1", order_date=d, payment_date=d, event_date=rd, amount=-price,
product_name=name, quantity=-1, order_status="반품완료", raw={"sample": True},
))
d += timedelta(days=1)
return events
+414
View File
@@ -0,0 +1,414 @@
"""네이버 스마트스토어 — 네이버 커머스API.
인증(공식 방식): 애플리케이션 ID + 시크릿으로 전자서명 → OAuth2 client_credentials 토큰.
client_secret_sign = base64( bcrypt.hashpw("{client_id}_{timestamp(ms)}", client_secret) )
POST https://api.commerce.naver.com/external/v1/oauth2/token
(client_id, timestamp, client_secret_sign, grant_type=client_credentials, type=SELF | SELLER+account_id)
토큰은 약 3시간 — 암호화 저장(access_token·access_token_expires_at)해 두고 만료 5분 전에 새로 받는다.
커머스API센터 애플리케이션에 **API 호출 IP(이 서버 외부 IP)** 를 등록해야 호출된다.
매출 수집 — 스마트스토어센터 **판매분석 "판매금액(총)"** 과 같은 기준(2026-09-30 사용자 확인: 9/1 매출 4,455,600원.
판매금액은 할인(판매자·네이버 부담) 뒤 금액, 배송비 332,486원은 별도, 환불 346,340원은 환불일에 따로 빠져 판매금액(순)):
- 조건형 상품 주문 상세 조회 GET /v1/pay-order/seller/product-orders
?from=…&to=…&rangeType=PAYED_DATETIME&pageSize=&page= — 결제일 기준, 한 번에 24시간까지(하루씩 부른다),
from 부터 180일 안의 주문만. 응답에 주문·상품주문 상세가 바로 들어 있다(네이버 안내: 소량·조회용 권장 API).
- SALE = 주문 하나(`naver:{orderId}`), 날짜 = 결제일(order.paymentDate).
금액 = 상품주문들의 결제금액(productOrder.totalPaymentAmount) 합 — 배송비 제외.
- 결제 뒤 취소·반품된 상품주문도 결제일 매출에 그대로 둔다(판매금액(총)). 입금대기·미입금 취소만 뺀다.
그래서 지난 날짜 매출이 나중에 줄지 않는다. 환불(판매금액(순))은 아직 따로 만들지 않는다.
- 구매자 이름·연락처·주소는 저장하지 않는다.
"""
from __future__ import annotations
import base64
import re
import time
from datetime import date, datetime, timedelta
from typing import Any, Iterable
from .base import (
AdapterContext,
AdapterError,
ApiError,
AuthFailed,
CredentialField,
MarketplaceAdapter,
NotConfigured,
SaleEvent,
TokenExpired,
)
HOST = "https://api.commerce.naver.com/external"
TOKEN_PATH = "/v1/oauth2/token"
ORDERS_PATH = "/v1/pay-order/seller/product-orders"
EVENT_PREFIX = "naver:"
PAGE_SIZE = 100
MAX_PAGES = 200 # 하루 2만 건 — 무한 반복 방지
TOKEN_MARGIN_SEC = 300 # 만료 5분 전이면 새로 받는다
CALL_INTERVAL_SEC = 0.35 # 초당 호출 제한(넘으면 429) — 호출 사이 간격
RETRY_429 = 3
PROBE_MAX_DAYS = 31
# 매출에서 빼는 상품주문 상태 — 결제되지 않은 것만(입금대기·미입금 취소). 결제 뒤 취소·반품된 것은 판매분석
# "판매금액(총)"처럼 결제일 매출에 그대로 둔다(환불은 판매분석에서도 환불일에 따로 빠진다).
EXCLUDED_STATUS = frozenset({"PAYMENT_WAITING", "CANCELED_BY_NOPAYMENT"})
CLAIMED_STATUS = frozenset({"CANCELED", "RETURNED"}) # 결제 뒤 취소·반품 완료 — 원본 확인 표에 참고로 따로 보여 줌
STATUS_KO = {
"PAYMENT_WAITING": "입금대기", "PAYED": "결제완료", "DELIVERING": "배송중", "DELIVERED": "배송완료",
"PURCHASE_DECIDED": "구매확정", "EXCHANGED": "교환", "CANCELED": "취소", "RETURNED": "반품",
"CANCELED_BY_NOPAYMENT": "미입금취소",
}
# 원본 데이터 확인 — 개인정보로 보이는 항목은 값 없이 이름만. 금액·상태·날짜·상품명 등은 보인다.
PERSONAL = re.compile(r"orderer|receiver|shippingAddress|takingAddress|returnAddress|pickupAddress|collectAddress|"
r"name$|tel|phone|address|zip|mail|memo|customsClearance|buyer|recipient", re.IGNORECASE)
SAFE = re.compile(r"(productName|productOption|optionCode|productClass|productId|deliveryCompany|reason|Status|Type|"
r"Date|Amount|Price|Fee|Quantity|Count|Id)$")
NUMBER = re.compile(r"^-?\d+(\.\d+)?$")
def _won(value: Any) -> int:
try:
return int(round(float(str(value if value is not None else 0).replace(",", ""))))
except ValueError:
return 0
def _day(value: Any) -> date | None:
""""2026-09-29T10:11:12.0+09:00" → date(2026, 9, 29). 네이버 날짜는 한국 시간(+09:00)으로 온다."""
s = str(value or "")
m = re.match(r"(\d{4})-(\d{2})-(\d{2})", s)
if not m:
return None
try:
return date(int(m.group(1)), int(m.group(2)), int(m.group(3)))
except ValueError:
return None
def sign(client_id: str, client_secret: str, timestamp_ms: int) -> str:
"""커머스API 전자서명 — bcrypt(비밀번호 = "{client_id}_{timestamp}", 솔트 = 애플리케이션 시크릿) 을 base64."""
import bcrypt # 지연 import
try:
hashed = bcrypt.hashpw(f"{client_id}_{timestamp_ms}".encode("utf-8"), client_secret.encode("utf-8"))
except ValueError:
raise AuthFailed("애플리케이션 시크릿 형식이 올바르지 않습니다. 커머스API센터의 시크릿을 그대로 붙여 넣으세요.") from None
return base64.standard_b64encode(hashed).decode("ascii")
def product_order_items(body: Any) -> list[dict[str, Any]]:
"""조건형 조회 응답에서 상품주문 하나씩 {"order": {...}, "productOrder": {...}, ...} 로 꺼낸다.
응답 모양(data.contents[].content / data 목록 / 바로 목록)이 달라도 받아들인다."""
data = body.get("data", body) if isinstance(body, dict) else body
if isinstance(data, dict):
data = data.get("contents") or data.get("productOrders") or data.get("items") or []
out = []
for it in data if isinstance(data, list) else []:
if not isinstance(it, dict):
continue
c = it.get("content") if isinstance(it.get("content"), dict) else it
if isinstance(c.get("productOrder"), dict):
out.append(c)
return out
def has_next(body: Any, page: int, got: int) -> bool:
data = body.get("data") if isinstance(body, dict) else None
pg = data.get("pagination") if isinstance(data, dict) else None
if isinstance(pg, dict):
if "hasNext" in pg:
return bool(pg["hasNext"])
total = pg.get("totalPages") or pg.get("totalPage")
if total:
return page < int(total)
return got >= PAGE_SIZE
def flatten(obj: Any, prefix: str = "") -> dict[str, str]:
"""중첩 사전 → {"productOrder.totalPaymentAmount": "12000", …}. 목록은 건너뛴다(개수만)."""
out: dict[str, str] = {}
if isinstance(obj, dict):
for k, v in obj.items():
key = f"{prefix}.{k}" if prefix else str(k)
if isinstance(v, dict):
out.update(flatten(v, key))
elif isinstance(v, list):
out[key + "[]"] = str(len(v))
elif v is not None:
out[key] = str(v)
return out
def is_personal(key: str) -> bool:
last = key.rsplit(".", 1)[-1]
if "Address." in key or key.split(".")[0] in ("orderer",):
return True
return bool(PERSONAL.search(key)) and not SAFE.search(last)
def field_summary(records: list[dict[str, str]]) -> list[dict[str, Any]]:
"""항목별: 채워진 줄 수, 숫자면 합계, 개인정보 아니면 예시 값 하나."""
names: dict[str, dict[str, Any]] = {}
for r in records:
for k, v in r.items():
f = names.setdefault(k, {"name": k, "filled": 0, "numeric": True, "sum": 0.0, "sample": "",
"personal": is_personal(k)})
if v == "":
continue
f["filled"] += 1
if NUMBER.match(v) and f["numeric"]:
f["sum"] += float(v)
else:
f["numeric"] = False
if not f["sample"] and not f["personal"]:
f["sample"] = v[:40]
for f in names.values():
f["sum"] = int(round(f["sum"])) if f["numeric"] and f["filled"] else None
return sorted(names.values(), key=lambda f: f["name"])
def group_orders(items: Iterable[dict[str, Any]], start: date, end: date) -> dict[str, dict[str, Any]]:
"""상품주문 → 주문 하나로 합침(결제일이 [start, end] 이고 결제된 것 — 나중에 취소·반품된 것도 포함).
금액 = totalPaymentAmount 합(할인 뒤 상품 결제금액, 배송비 제외) = 판매분석 "판매금액(총)".
배송비·취소/반품분은 참고용(ship·claimed)으로만 모은다."""
orders: dict[str, dict[str, Any]] = {}
for c in items:
po, od = c.get("productOrder") or {}, c.get("order") or {}
oid = str(od.get("orderId") or po.get("orderId") or "")
day = _day(od.get("paymentDate") or po.get("paymentDate"))
status = str(po.get("productOrderStatus") or "")
if not oid or day is None or not (start <= day <= end) or status in EXCLUDED_STATUS:
continue
o = orders.setdefault(oid, {"orderId": oid, "_day": day, "amount": 0, "ship": 0, "claimed": 0, "qty": 0,
"discount": 0, "names": [], "opt": "", "statuses": [],
"order_day": _day(od.get("orderDate"))})
paid = _won(po.get("totalPaymentAmount"))
o["amount"] += paid
if status in CLAIMED_STATUS:
o["claimed"] += paid
o["ship"] += _won(po.get("deliveryFeeAmount")) - _won(po.get("deliveryDiscountAmount"))
o["qty"] += _won(po.get("quantity"))
o["discount"] += _won(po.get("productDiscountAmount"))
name = str(po.get("productName") or "")
if name and name not in o["names"]:
o["names"].append(name)
o["opt"] = o["opt"] or str(po.get("productOption") or "")
if status and status not in o["statuses"]:
o["statuses"].append(status)
return orders
class NaverAdapter(MarketplaceAdapter):
code = "naver"
name = "네이버 스마트스토어"
auth_type = "oauth"
implemented = True
replace_range = True
event_prefix = EVENT_PREFIX
docs_url = "https://apicenter.commerce.naver.com/"
note = ("커머스API센터에서 발급한 애플리케이션 ID/시크릿을 입력합니다. 애플리케이션의 API 호출 IP 에 "
"이 서버의 외부 IP 를 등록해야 호출됩니다.")
def __init__(self) -> None:
self._last_call = 0.0
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("client_id", "애플리케이션 ID(Client ID)"),
CredentialField("client_secret", "애플리케이션 시크릿(Client Secret)", secret=True),
CredentialField("account_id", "판매자 ID", required=False,
help="솔루션(SELLER) 방식으로 발급한 경우에만 입력 — 내 스토어 전용 애플리케이션은 비워 둡니다"),
CredentialField("access_token", "Access Token", secret=True, required=False, internal=True),
CredentialField("access_token_expires_at", "Access Token 만료", required=False, internal=True),
]
# ── 인증 ──────────────────────────────────────────────
def _token(self, ctx: AdapterContext, *, force: bool = False) -> str:
"""저장된 토큰이 5분 넘게 남았으면 그대로, 아니면 새로 받아 암호화 저장."""
if not force:
tok = ctx.credentials.get("access_token")
try:
exp = float(ctx.credentials.get("access_token_expires_at") or 0)
except ValueError:
exp = 0.0
if tok and exp - time.time() > TOKEN_MARGIN_SEC:
return tok
return self._issue_token(ctx)
def _issue_token(self, ctx: AdapterContext) -> str:
import httpx # 지연 import
client_id = ctx.credentials.get("client_id").strip()
client_secret = ctx.credentials.get("client_secret").strip()
if not client_id or not client_secret:
raise NotConfigured("애플리케이션 ID와 시크릿을 입력하세요.")
ts = int(time.time() * 1000)
form = {"client_id": client_id, "timestamp": str(ts), "grant_type": "client_credentials",
"client_secret_sign": sign(client_id, client_secret, ts), "type": "SELF"}
account_id = ctx.credentials.get("account_id").strip()
if account_id:
form.update(type="SELLER", account_id=account_id)
try:
res = httpx.post(f"{HOST}{TOKEN_PATH}", data=form, timeout=ctx.timeout_sec,
headers={"Accept": "application/json"})
except httpx.HTTPError as exc:
raise ApiError(f"네이버 커머스API 연결 실패: {type(exc).__name__}") from None
body = self._json(res)
if res.status_code >= 400 or not body.get("access_token"):
msg = self._err_text(body, res)
if res.status_code in (400, 401, 403):
raise AuthFailed(f"네이버 토큰 발급 실패({res.status_code}): {msg}. 애플리케이션 ID·시크릿과 "
"API 호출 IP(이 서버 외부 IP) 등록을 확인하세요.")
raise ApiError(f"네이버 토큰 발급 오류({res.status_code}): {msg}")
tok = str(body["access_token"])
expires_in = _won(body.get("expires_in")) or 3 * 3600
ctx.credentials.set("access_token", tok)
ctx.credentials.set("access_token_expires_at", str(int(time.time()) + expires_in))
return tok
def authenticate(self, ctx: AdapterContext) -> None:
super().authenticate(ctx)
self._token(ctx)
def refresh_token(self, ctx: AdapterContext) -> None:
self._token(ctx, force=True)
# ── 호출 ──────────────────────────────────────────────
@staticmethod
def _json(res: Any) -> dict[str, Any]:
try:
body = res.json()
except ValueError:
return {}
return body if isinstance(body, dict) else {"data": body}
@staticmethod
def _err_text(body: dict[str, Any], res: Any) -> str:
parts = [str(body.get(k)) for k in ("code", "message", "error", "error_description") if body.get(k)]
inv = body.get("invalidInputs")
if isinstance(inv, list) and inv:
parts.append("; ".join(str(i.get("message") or i) if isinstance(i, dict) else str(i) for i in inv[:3]))
return " ".join(parts)[:300] or res.text[:200].strip() or "응답 없음"
def _get(self, ctx: AdapterContext, path: str, params: dict[str, Any]) -> dict[str, Any]:
"""GET — 호출 간격 유지, 429 는 잠깐 쉬고 다시, 401 이면 토큰을 새로 받아 한 번 더."""
import httpx # 지연 import
retried_auth = False
for attempt in range(RETRY_429 + 1):
ctx.progress.check() # [업데이트 취소]면 여기서 멈춤
wait = CALL_INTERVAL_SEC - (time.monotonic() - self._last_call)
if wait > 0:
time.sleep(wait)
headers = {"Authorization": f"Bearer {self._token(ctx)}", "Accept": "application/json"}
try:
res = httpx.get(f"{HOST}{path}", params=params, headers=headers, timeout=ctx.timeout_sec)
except httpx.HTTPError as exc:
raise ApiError(f"네이버 커머스API 연결 실패: {type(exc).__name__}") from None
finally:
self._last_call = time.monotonic()
if res.status_code == 429 and attempt < RETRY_429:
time.sleep(1.0 * (2 ** attempt))
continue
if res.status_code == 401 and not retried_auth:
retried_auth = True
self._token(ctx, force=True)
continue
body = self._json(res)
if res.status_code == 401:
raise TokenExpired(f"네이버 인증 만료·거부(401): {self._err_text(body, res)}")
if res.status_code == 403:
raise AuthFailed(f"네이버 권한 거부(403): {self._err_text(body, res)}. 애플리케이션의 API 권한(주문)과 "
"API 호출 IP 등록을 확인하세요.")
if res.status_code >= 400:
raise ApiError(f"네이버 API 오류({res.status_code}): {self._err_text(body, res)}")
return body
raise ApiError("네이버 API 호출 제한(429)이 계속됩니다. 잠시 뒤 다시 시도하세요.")
def _day_items(self, ctx: AdapterContext, d: date) -> list[dict[str, Any]]:
"""결제일이 d(한국 시간 0시~23:59:59.999)인 상품주문 전체 — 모든 상태."""
params: dict[str, Any] = {
"from": f"{d.isoformat()}T00:00:00.000+09:00", "to": f"{d.isoformat()}T23:59:59.999+09:00",
"rangeType": "PAYED_DATETIME", "pageSize": PAGE_SIZE,
}
out: list[dict[str, Any]] = []
for page in range(1, MAX_PAGES + 1):
body = self._get(ctx, ORDERS_PATH, {**params, "page": page})
items = product_order_items(body)
out.extend(items)
if not items or not has_next(body, page, len(items)):
break
return out
def _items(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
ctx.progress.plan((end - start).days + 1, "일") # 진행 막대: 하루 = 한 단계
d = start
while d <= end:
rows = self._day_items(ctx, d)
ctx.progress.step(items=len(rows))
yield from rows
d += timedelta(days=1)
# ── 수집 ──────────────────────────────────────────────
def fetch_orders(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
yield from group_orders(self._items(ctx, start, end), start, end).values()
def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]:
oid, day = str(o.get("orderId") or ""), o.get("_day")
if not oid or day is None:
return []
names = o.get("names") or []
name = names[0] + (f" 외 {len(names) - 1}건" if len(names) > 1 else "") if names else ""
statuses = [STATUS_KO.get(s, s) for s in o.get("statuses") or []]
return [SaleEvent(
event_type="SALE", external_event_id=f"{EVENT_PREFIX}{oid}", external_order_id=oid,
order_date=o.get("order_day"), payment_date=day, event_date=day, amount=max(0, int(o.get("amount") or 0)),
product_name=name[:200], option_name=str(o.get("opt") or "")[:200], quantity=int(o.get("qty") or 0),
discount_amount=max(0, int(o.get("discount") or 0)), order_status="/".join(statuses)[:50],
)]
def test_connection(self, ctx: AdapterContext) -> str:
from app.timezone import today_kst # noqa: WPS433
# 입력한 새 값으로 시험할 수 있으니 저장된 토큰을 쓰지 않고 항상 새로 받는다.
super().authenticate(ctx)
self._token(ctx, force=True)
items = self._day_items(ctx, today_kst())
return f"네이버 커머스API 연결 정상(토큰 발급·주문 조회 확인, 오늘 결제 상품주문 {len(items)}건)."
# ── 원본 데이터 확인(설정 화면 "쇼핑몰 원본 데이터 확인") ─────────
def reconcile(self, ctx: AdapterContext, day: date, to: date | None = None) -> dict[str, Any]:
"""결제일 기준 기간(최대 31일)의 상품주문을 실제로 불러 항목별 합계·상태별 합계·날짜별 현재 규칙 매출을 돌려준다.
스마트스토어센터 화면 매출과 어느 항목이 맞는지 실데이터로 확정하는 용도. 개인정보 항목은 값 없이 이름만."""
self.authenticate(ctx)
to = min(max(to or day, day), day + timedelta(days=PROBE_MAX_DAYS - 1))
try:
items = list(self._items(ctx, day, to))
except AdapterError as exc:
return {"date": day.isoformat(), "to": to.isoformat(), "probes": [
{"key": "payed", "label": "결제일 기준 상품주문", "path": ORDERS_PATH, "ok": False, "error": exc.message[:300]}]}
by_status: dict[str, list[dict[str, Any]]] = {}
for c in items:
by_status.setdefault(str((c.get("productOrder") or {}).get("productOrderStatus") or "?"), []).append(c)
probes = [{"key": "payed", "label": "결제일 기준 상품주문(전체 상태)", "path": ORDERS_PATH + " (PAYED_DATETIME)",
"ok": True, "count": len(items), "fields": field_summary([flatten(c) for c in items])}]
for st, rows in sorted(by_status.items()):
probes.append({"key": f"status-{st}", "label": f"상태 {STATUS_KO.get(st, st)}({st})"
+ (" — 매출 제외(미결제)" if st in EXCLUDED_STATUS else
" — 결제 뒤 취소·반품(매출 포함)" if st in CLAIMED_STATUS else ""), "path": "productOrderStatus",
"ok": True, "count": len(rows),
"fields": [f for f in field_summary([flatten(c) for c in rows])
if f["sum"] is not None and f["name"].startswith("productOrder.")]})
days = []
orders = group_orders(items, day, to)
d = day
while d <= to:
day_orders = [o for o in orders.values() if o["_day"] == d]
days.append({"date": d.isoformat(), "orders": len(day_orders), "amount": sum(o["amount"] for o in day_orders),
"claimed": sum(o["claimed"] for o in day_orders), "ship": sum(o["ship"] for o in day_orders)})
d += timedelta(days=1)
return {"date": day.isoformat(), "to": to.isoformat(), "probes": probes, "days": days,
"rule": "결제일 기준 상품주문 totalPaymentAmount 합(할인 뒤, 배송비 제외, 결제 뒤 취소·반품분 포함, "
"미입금 제외) = 판매분석 '판매금액(총)'. 취소·반품분·배송비는 참고"}
@@ -0,0 +1,22 @@
"""오늘의집 — 파트너(판매자) API.
인증 방식·필드는 연동 단계에서 오늘의집 파트너 API 문서로 확정한다.
"""
from __future__ import annotations
from .base import CredentialField, MarketplaceAdapter
class OhouseAdapter(MarketplaceAdapter):
code = "ohouse"
name = "오늘의집"
auth_type = "api_key"
note = "입력 항목은 연동 단계에서 오늘의집 파트너 API 문서로 확정합니다."
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("seller_id", "판매자 ID"),
CredentialField("api_key", "API Key", secret=True),
CredentialField("api_secret", "API Secret", secret=True, required=False),
]
@@ -0,0 +1,41 @@
"""쇼핑몰 어댑터 목록 — 새 쇼핑몰은 여기 한 줄 + 어댑터 파일 하나.
DB(perf_marketplaces)에 행이 없으면 설정 화면에서 쓸 수 없으므로, 새 쇼핑몰을
추가할 때는 scripts/sql 의 seed(INSERT … ON CONFLICT DO NOTHING)에도 한 줄 넣는다.
"""
from __future__ import annotations
from .base import MarketplaceAdapter
from .cafe24 import Cafe24Adapter
from .coupang import CoupangAdapter
from .elevenst import ElevenstAdapter
from .gmarket import GmarketAdapter
from .gsshop import GsshopAdapter
from .kakao import KakaoAdapter
from .lotteon import LotteonAdapter
from .naver import NaverAdapter
from .ohouse import OhouseAdapter
from .toss import TossAdapter
_ADAPTERS: tuple[MarketplaceAdapter, ...] = (
Cafe24Adapter(),
NaverAdapter(),
CoupangAdapter(),
OhouseAdapter(),
GmarketAdapter(),
KakaoAdapter(),
GsshopAdapter(),
ElevenstAdapter(),
LotteonAdapter(),
TossAdapter(),
)
_BY_CODE = {a.code: a for a in _ADAPTERS}
def all_adapters() -> tuple[MarketplaceAdapter, ...]:
return _ADAPTERS
def get_adapter(code: str) -> MarketplaceAdapter | None:
return _BY_CODE.get(code)
+22
View File
@@ -0,0 +1,22 @@
"""토스쇼핑 — 판매자 API.
인증 방식·필드는 연동 단계에서 공식 문서로 확정한다.
"""
from __future__ import annotations
from .base import CredentialField, MarketplaceAdapter
class TossAdapter(MarketplaceAdapter):
code = "toss"
name = "토스쇼핑"
auth_type = "api_key"
note = "입력 항목은 연동 단계에서 토스쇼핑 판매자 API 문서로 확정합니다."
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("seller_id", "판매자 ID"),
CredentialField("api_key", "API Key", secret=True),
CredentialField("api_secret", "API Secret", secret=True, required=False),
]
+306
View File
@@ -0,0 +1,306 @@
"""③ 매출 계산 — 기간/주 계산, 수수료·반올림, 표·KPI 집계. DB·HTTP 와 무관한 순수 함수.
금액 규칙
- 모든 금액은 원 단위 정수(int). 부동소수점을 쓰지 않는다(수수료율만 Decimal).
- 수수료 = round_half_up(해당 일 쇼핑몰 매출 합계 × 그날 유효한 수수료율 / 100).
반올림은 `commission()` 한 곳에서만 한다. 취소/반품(음수)도 같은 규칙(0 에서 먼 쪽).
- 수수료 차감 매출 = 총매출 − 수수료.
- 수수료율은 이력(적용 시작일)으로 관리한다. 어떤 날의 요율 = 그날 이전(포함) 가장 최근
적용 시작일의 요율. 첫 요율보다 이전 날짜는 0%.
주 = 월요일 ~ 일요일.
"""
from __future__ import annotations
import calendar
from dataclasses import dataclass
from datetime import date, timedelta
from decimal import ROUND_HALF_UP, Decimal
from typing import Iterable, Mapping, Sequence
WEEKDAYS_KO = ("월", "화", "수", "목", "금", "토", "일")
PERIOD_KINDS = ("day", "week", "month", "year", "custom")
MAX_CUSTOM_DAYS = 366
# ════════════════════════════════════════════════════════════
# 금액
# ════════════════════════════════════════════════════════════
def commission(amount: int, rate_percent: Decimal) -> int:
"""수수료(원). 반올림 기준은 이 함수 한 곳 — ROUND_HALF_UP(0.5 는 0 에서 먼 쪽)."""
if not amount or not rate_percent:
return 0
value = Decimal(int(amount)) * Decimal(rate_percent) / Decimal(100)
return int(value.quantize(Decimal(1), rounding=ROUND_HALF_UP))
@dataclass
class Money:
gross: int = 0
commission: int = 0
@property
def net(self) -> int:
return self.gross - self.commission
def add(self, other: "Money") -> "Money":
self.gross += other.gross
self.commission += other.commission
return self
def as_dict(self) -> dict[str, int]:
return {"gross": self.gross, "commission": self.commission, "net": self.net}
def total(items: Iterable[Money]) -> Money:
out = Money()
for m in items:
out.add(m)
return out
RateTable = Mapping[str, Sequence[tuple[date, Decimal]]] # 쇼핑몰 → [(적용 시작일, 요율%)] 오름차순
def rate_on(rates: RateTable, code: str, d: date) -> Decimal:
current = Decimal(0)
for eff, rate in rates.get(code, ()):
if eff <= d:
current = Decimal(rate)
else:
break
return current
def build_cells(daily_amounts: Mapping[tuple[date, str], int], rates: RateTable) -> dict[tuple[date, str], Money]:
"""(날짜, 쇼핑몰) → 그날 매출 합계로 Money 를 만든다(수수료는 그날 요율)."""
return {
(d, code): Money(gross=int(amt), commission=commission(int(amt), rate_on(rates, code, d)))
for (d, code), amt in daily_amounts.items()
}
def pct_change(current: int, previous: int) -> float | None:
"""증감률(%). 비교 대상이 0 이하이면 의미 없는 값 대신 None."""
if previous <= 0:
return None
return round((current - previous) / previous * 100, 1)
# ════════════════════════════════════════════════════════════
# 기간
# ════════════════════════════════════════════════════════════
def week_start(d: date) -> date:
return d - timedelta(days=d.weekday())
def month_end(d: date) -> date:
return d.replace(day=calendar.monthrange(d.year, d.month)[1])
def _add_months(d: date, n: int) -> date:
y, m = divmod(d.month - 1 + n, 12)
year, month = d.year + y, m + 1
return date(year, month, min(d.day, calendar.monthrange(year, month)[1]))
def fmt_md(d: date) -> str:
return f"{d.month}/{d.day}"
def day_label(d: date) -> str:
"""일자별 표 날짜 — mm/dd(요일), 예: 09/01(화)."""
return f"{d.month:02d}/{d.day:02d}({WEEKDAYS_KO[d.weekday()]})"
@dataclass
class Period:
kind: str
anchor: date
start: date
end: date
label: str
prev_anchor: date
next_anchor: date
prev_label: str
next_label: str
@property
def days(self) -> int:
return (self.end - self.start).days + 1
def compare_range(self, today: date) -> tuple[date, date, str]:
"""직전 같은 길이 기간. 진행 중인 기간이면 같은 경과일수까지만(공정한 비교)."""
length = self.days
prev_start = self.start - timedelta(days=length)
if self.kind == "month":
prev_start = _add_months(self.start, -1)
elif self.kind == "year":
prev_start = self.start.replace(year=self.start.year - 1)
in_progress = self.start <= today < self.end
if in_progress:
elapsed = (today - self.start).days
prev_end = prev_start + timedelta(days=elapsed)
if self.kind == "month":
prev_end = min(prev_end, month_end(prev_start))
note = "같은 기간"
else:
if self.kind == "month":
prev_end = month_end(prev_start)
elif self.kind == "year":
prev_end = prev_start.replace(month=12, day=31)
else:
prev_end = self.start - timedelta(days=1)
note = ""
unit = {"day": "전일", "week": "전주", "month": "전월", "year": "전년"}.get(self.kind, "직전 기간")
return prev_start, prev_end, f"{unit} {note}".strip()
def resolve_period(
kind: str,
anchor: date,
*,
custom_from: date | None = None,
custom_to: date | None = None,
) -> Period:
kind = kind if kind in PERIOD_KINDS else "week"
if kind == "day":
return Period(kind, anchor, anchor, anchor,
f"{anchor.year}년 {anchor.month}월 {anchor.day}일 ({WEEKDAYS_KO[anchor.weekday()]})",
anchor - timedelta(days=1), anchor + timedelta(days=1), "전일", "다음날")
if kind == "week":
s = week_start(anchor)
e = s + timedelta(days=6)
label = (f"{s.year}년 {s.month}월 {s.day}일 ~ "
+ (f"{e.year}년 " if e.year != s.year else "") + f"{e.month}월 {e.day}일")
return Period(kind, anchor, s, e, label, s - timedelta(days=7), s + timedelta(days=7), "이전주", "다음주")
if kind == "month":
s = anchor.replace(day=1)
return Period(kind, anchor, s, month_end(s), f"{s.year}년 {s.month}월",
_add_months(s, -1), _add_months(s, 1), "이전달", "다음달")
if kind == "year":
s = date(anchor.year, 1, 1)
return Period(kind, anchor, s, date(anchor.year, 12, 31), f"{anchor.year}년",
date(anchor.year - 1, 1, 1), date(anchor.year + 1, 1, 1), "이전해", "다음해")
# custom
s = custom_from or anchor
e = custom_to or s
if e < s:
s, e = e, s
if (e - s).days + 1 > MAX_CUSTOM_DAYS:
e = s + timedelta(days=MAX_CUSTOM_DAYS - 1)
length = (e - s).days + 1
return Period("custom", s, s, e, f"{s.isoformat()} ~ {e.isoformat()}",
s - timedelta(days=length), e + timedelta(days=1), "이전", "다음")
def daterange(start: date, end: date) -> Iterable[date]:
d = start
while d <= end:
yield d
d += timedelta(days=1)
# ════════════════════════════════════════════════════════════
# 집계
# ════════════════════════════════════════════════════════════
def sum_range(cells: Mapping[tuple[date, str], Money], codes: Sequence[str], start: date, end: date) -> Money:
wanted = set(codes)
out = Money()
for (d, code), m in cells.items():
if code in wanted and start <= d <= end:
out.add(m)
return out
def by_code(cells: Mapping[tuple[date, str], Money], codes: Sequence[str], start: date, end: date) -> dict[str, Money]:
out = {c: Money() for c in codes}
for (d, code), m in cells.items():
if code in out and start <= d <= end:
out[code].add(m)
return out
def _row(kind: str, label: str, per_code: dict[str, Money], **extra) -> dict:
return {
"kind": kind,
"label": label,
"cells": {c: m.as_dict() for c, m in per_code.items()},
"total": total(per_code.values()).as_dict(),
**extra,
}
def main_table(period: Period, codes: Sequence[str], cells: Mapping[tuple[date, str], Money],
*, today: date, holidays: Mapping[str, str] | None = None) -> list[dict]:
"""일자 × 쇼핑몰 표. 일 행 + 주간합계(일요일 뒤 / 기간 끝) + 기간 합계.
연간 보기는 일 대신 월 행(1~12월)으로 줄인다.
"""
holidays = holidays or {}
rows: list[dict] = []
if period.kind == "year":
for m in range(1, 13):
s = date(period.start.year, m, 1)
e = month_end(s)
rows.append(_row("month", f"{m}월", by_code(cells, codes, s, e), future=s > today,
**{"from": s.isoformat(), "to": e.isoformat()}))
rows.append(_row("total", "연간 합계", by_code(cells, codes, period.start, period.end)))
return rows
week_codes: dict[str, Money] = {c: Money() for c in codes}
for d in daterange(period.start, period.end):
per_code = {c: cells.get((d, c), Money()) for c in codes}
iso = d.isoformat()
rows.append(_row("day", day_label(d), per_code, date=iso, weekday=d.weekday(),
holiday=holidays.get(iso, ""), future=d > today, today=d == today,
**{"from": iso, "to": iso}))
for c in codes:
week_codes[c].add(per_code[c])
if period.days > 1 and (d.weekday() == 6 or d == period.end):
ws = max(week_start(d), period.start)
label = "주간합계" if period.kind == "week" else f"주간합계 ({fmt_md(ws)}~{fmt_md(d)})"
rows.append(_row("week", label, week_codes, **{"from": ws.isoformat(), "to": d.isoformat()}))
week_codes = {c: Money() for c in codes}
if period.kind != "week" and period.days > 1:
rows.append(_row("total", "기간 합계", by_code(cells, codes, period.start, period.end)))
return rows
def month_summary(year: int, month: int, codes: Sequence[str], cells: Mapping[tuple[date, str], Money]) -> dict:
s = date(year, month, 1)
per = by_code(cells, codes, s, month_end(s))
tot = total(per.values())
rows = []
for c in codes:
m = per[c]
share = round(m.gross / tot.gross * 100, 1) if tot.gross > 0 else None
rows.append({"code": c, **m.as_dict(), "share": share})
rows.sort(key=lambda r: r["gross"], reverse=True)
return {"label": f"{year}년 {month}월", "rows": rows,
"total": {**tot.as_dict(), "share": 100.0 if tot.gross > 0 else None}}
def year_months(year: int, codes: Sequence[str], cells: Mapping[tuple[date, str], Money], *, today: date) -> dict:
rows = []
for m in range(1, 13):
s = date(year, m, 1)
future = s > today
money = sum_range(cells, codes, s, month_end(s))
rows.append({"month": m, "label": f"{m}월", "future": future,
**({"gross": None, "commission": None, "net": None} if future else money.as_dict())})
tot = sum_range(cells, codes, date(year, 1, 1), date(year, 12, 31))
return {"year": year, "rows": rows, "total": tot.as_dict()}
def daily_series(period: Period, codes: Sequence[str], cells: Mapping[tuple[date, str], Money]) -> list[dict]:
"""일별 추이 그래프용. 연간은 월별."""
if period.kind == "year":
out = []
for m in range(1, 13):
s = date(period.start.year, m, 1)
out.append({"label": f"{m}월", **sum_range(cells, codes, s, month_end(s)).as_dict()})
return out
return [{"label": fmt_md(d), "date": d.isoformat(), **sum_range(cells, codes, d, d).as_dict()}
for d in daterange(period.start, period.end)]
+126
View File
@@ -0,0 +1,126 @@
"""실적 모듈 공용 가드/서비스 생성 — router.py 가 쓴다(순환 import 방지로 분리).
권한(프론트에서 메뉴를 숨기는 것과 별개로 **서버에서** 항상 검사):
- 실적 대시보드/매출 업데이트/상세 조회 : 모듈 권한 `performance` (admin 은 자동)
- 실적 설정(수수료·API 인증정보·연결 테스트·테스트 데이터) : 관리자(is_admin)만
"""
from __future__ import annotations
from typing import Any
from fastapi import HTTPException, Request
from fastapi.responses import HTMLResponse, RedirectResponse
MODULE_KEY = "performance"
MODULE_NAME = "실적"
CONFIG_HELP = (
"실적 모듈이 아직 설정되지 않았습니다. "
"scripts/sql/performance_db_init.sql 로 performance_db 를 만들고 "
"PERFORMANCE_DB_URL 환경변수를 설정한 뒤 컨테이너를 재기동하세요."
)
def get_store(request: Request) -> Any:
return getattr(request.app.state, "performance_store", None)
def key_ring():
"""마스터 키 — 호출할 때마다 환경변수에서 읽는다(DB 에는 없다)."""
from .security.crypto import KeyRing # noqa: WPS433
return KeyRing.from_env()
def key_status() -> dict[str, Any]:
"""설정 화면용 — 키가 설정됐는지/버전만. 키 값은 절대 넣지 않는다."""
from .security.crypto import CryptoConfigError # noqa: WPS433
try:
ring = key_ring()
except CryptoConfigError as exc:
return {"ok": False, "message": str(exc), "current_version": None, "versions": []}
return {"ok": True, "message": "", "current_version": ring.current_version, "versions": ring.versions}
def services(request: Request, store: Any):
"""(CredentialService, SyncService)."""
from .credentials import CredentialService # noqa: WPS433
from .sync import SyncService # noqa: WPS433
creds = CredentialService(store, key_ring)
return creds, SyncService(store, creds, app_state=request.app.state)
def require_user(request: Request) -> dict[str, Any]:
from app.main import get_current_user_record # noqa: WPS433
from app.store import has_module # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
if not has_module(user, MODULE_KEY):
raise HTTPException(status_code=403, detail=f"{MODULE_NAME} 모듈 권한이 없습니다.")
return user
def require_admin(request: Request) -> dict[str, Any]:
from app.store import is_admin # noqa: WPS433
user = require_user(request)
if not is_admin(user):
raise HTTPException(status_code=403, detail="실적 설정은 관리자만 변경할 수 있습니다.")
return user
def require_store(request: Request, *, admin: bool = False) -> tuple[Any, dict[str, Any]]:
user = require_admin(request) if admin else require_user(request)
st = get_store(request)
if st is None:
raise HTTPException(status_code=503, detail=CONFIG_HELP)
return st, user
def guard(request: Request, *, admin: bool = False):
"""페이지 진입부. tuple(store, user) 이 아니면 그대로 응답으로 돌려준다."""
from app.main import get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin # noqa: WPS433
user = get_current_user_record(request)
if user is None:
return RedirectResponse(url="/login", status_code=303)
if not has_module(user, MODULE_KEY) or (admin and not is_admin(user)):
reason = "실적 설정은 관리자만 볼 수 있습니다." if admin else f"{MODULE_NAME} 접근 권한이 없습니다."
return render_template(request, "denied.html",
{"reason": reason, "user": user, "is_admin": is_admin(user)}, status_code=403)
st = get_store(request)
if st is None:
return render_config_needed(request, user)
return st, user
def render_config_needed(request: Request, user: dict[str, Any]) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
return render_template(
request, "denied.html",
{"reason": CONFIG_HELP, "user": user, "is_admin": is_admin(user),
"nav_items": build_erp_nav(user, active=MODULE_KEY)},
status_code=503,
)
def base_ctx(user: dict[str, Any], *, active_tab: str, page_title: str = "실적") -> dict[str, Any]:
from app.main import build_erp_nav # noqa: WPS433
from app.store import is_admin # noqa: WPS433
return {
"user": user,
"is_admin": is_admin(user),
"nav_items": build_erp_nav(user, active=MODULE_KEY),
"active_tab": active_tab,
"page_title": page_title,
"page_subtitle": "쇼핑몰 통합 매출",
}
+174
View File
@@ -0,0 +1,174 @@
"""② 쇼핑몰 API 인증정보 — 저장(암호화) / 화면용 요약 / 어댑터용 복호화 접근자 / 재암호화.
흐름: 설정 화면 입력 → 이 서비스(암호화) → perf_credentials(암호문)
어댑터 → CredentialAccessor.get() → 서버 안에서만 복호화
화면으로 돌려주는 값
- secret 항목: 값 있음/없음(has_value)만. 원문·일부·길이 모두 보내지 않는다.
- 일반 항목(Vendor ID 등): 확인용으로 원문을 보여 준다(이것도 DB 에는 암호문).
"""
from __future__ import annotations
from typing import Any, Callable
from .adapters.base import MarketplaceAdapter
from .security.crypto import KeyRing, decrypt, encrypt, needs_reencrypt
def aad_for(code: str, key: str) -> str:
"""암호문을 (쇼핑몰, 항목)에 묶는 추가 인증 데이터."""
return f"perf:{code}:{key}"
class CredentialAccessor:
"""어댑터 전용 — 서버 안에서만 복호화. 값은 처음 꺼낼 때 한 번 복호화해 둔다."""
def __init__(self, store: Any, code: str, ring_loader: Callable[[], KeyRing], *,
overrides: dict[str, str] | None = None, persist: bool = True, user: str = "") -> None:
self._store = store
self._code = code
self._ring_loader = ring_loader
self._rows = store.credential_rows(code) if store is not None else {}
self._cache: dict[str, str] = {}
self._overrides = {k: v for k, v in (overrides or {}).items() if v}
self._persist = persist
self._user = user
def has(self, key: str) -> bool:
return bool(self._overrides.get(key)) or key in self._rows
def get(self, key: str) -> str:
if key in self._overrides:
return self._overrides[key]
if key in self._cache:
return self._cache[key]
row = self._rows.get(key)
if not row:
return ""
value = decrypt(row["encrypted_value"], aad=aad_for(self._code, key), ring=self._ring_loader())
self._cache[key] = value
return value
def set(self, key: str, value: str) -> None:
"""어댑터가 새로 받은 토큰 등을 저장. 테스트(persist=False)면 메모리에만."""
self._cache[key] = value
if not self._persist or self._store is None:
return
ring = self._ring_loader()
self._store.upsert_credential(
self._code, key, encrypted_value=encrypt(value, aad=aad_for(self._code, key), ring=ring),
key_version=ring.current_version, user=self._user or "system",
)
self._rows[key] = {"encrypted_value": "", "key_version": ring.current_version}
def known_secrets(self) -> list[str]:
"""가리기(redact)용 — 지금까지 꺼낸 원문들."""
return [v for v in list(self._cache.values()) + list(self._overrides.values()) if v]
class CredentialService:
def __init__(self, store: Any, ring_loader: Callable[[], KeyRing]) -> None:
self._store = store
self._ring_loader = ring_loader
def accessor(self, code: str, *, overrides: dict[str, str] | None = None, persist: bool = True,
user: str = "") -> CredentialAccessor:
return CredentialAccessor(self._store, code, self._ring_loader, overrides=overrides,
persist=persist, user=user)
# ── 화면용 요약(비밀 원문 없음) ─────────────────────────
def describe(self, adapter: MarketplaceAdapter) -> dict[str, Any]:
rows = self._store.credential_rows(adapter.code)
fields = []
decrypt_error = ""
for f in adapter.visible_fields():
row = rows.get(f.key)
item: dict[str, Any] = {
"key": f.key, "label": f.label, "secret": f.secret, "required": f.required,
"help": f.help, "placeholder": f.placeholder, "has_value": row is not None,
"updated_at": row["updated_at"].isoformat(timespec="seconds") if row and row.get("updated_at") else "",
}
if row is not None and not f.secret:
try:
item["value"] = decrypt(row["encrypted_value"], aad=aad_for(adapter.code, f.key),
ring=self._ring_loader())
except Exception as exc: # noqa: BLE001 — 키 없음/손상: 값 없이 안내만
item["value"] = ""
decrypt_error = str(exc) if "환경변수" in str(exc) else "저장된 값을 복호화하지 못했습니다."
fields.append(item)
return {"fields": fields, "decrypt_error": decrypt_error,
"configured": all(x["has_value"] for x in fields if x["required"])}
def configured_codes(self, adapters: list[MarketplaceAdapter]) -> dict[str, bool]:
keys = self._store.credential_keys_by_code()
out = {}
for a in adapters:
if a.uses_shared_integration:
out[a.code] = True
continue
have = keys.get(a.code, set())
required = [f.key for f in a.visible_fields() if f.required]
out[a.code] = bool(required) and all(k in have for k in required)
return out
# ── 저장 ────────────────────────────────────────────────
def merged_values(self, adapter: MarketplaceAdapter, values: dict[str, str]) -> dict[str, str]:
"""검사용 — 새 입력 + (빈 칸은) 기존 값 존재 여부. 비밀 원문은 꺼내지 않고 표식만."""
rows = self._store.credential_rows(adapter.code)
merged = {}
for f in adapter.visible_fields():
v = (values.get(f.key) or "").strip()
merged[f.key] = v if v else ("__stored__" if f.key in rows else "")
return merged
def save(self, adapter: MarketplaceAdapter, values: dict[str, str], *, clear: list[str] | None = None,
user: str = "") -> list[str]:
"""빈 칸 = 기존 값 유지. clear 에 든 항목은 삭제. 저장한 항목 키 목록 반환."""
allowed = {f.key for f in adapter.visible_fields()}
ring = self._ring_loader()
saved = []
for key, raw in values.items():
if key not in allowed:
continue
v = (raw or "").strip()
if not v:
continue
self._store.upsert_credential(
adapter.code, key, encrypted_value=encrypt(v, aad=aad_for(adapter.code, key), ring=ring),
key_version=ring.current_version, user=user,
)
saved.append(key)
for key in clear or []:
if key in allowed and key not in saved:
self._store.delete_credential(adapter.code, key)
return saved
# ── 마스터 키 교체 후 재암호화 ─────────────────────────
def reencrypt_all(self) -> dict[str, int]:
"""예전 키 버전으로 된 암호문을 현재 키로 다시 암호화. (재암호화 수, 실패 수)."""
ring = self._ring_loader()
done = failed = 0
for row in self._store.all_credential_rows():
token = row["encrypted_value"]
if not needs_reencrypt(token, ring):
continue
code, key = row["marketplace_code"], row["credential_key"]
try:
plain = decrypt(token, aad=aad_for(code, key), ring=ring)
except Exception: # noqa: BLE001
failed += 1
continue
self._store.upsert_credential(
code, key, encrypted_value=encrypt(plain, aad=aad_for(code, key), ring=ring),
key_version=ring.current_version, user="rekey",
)
done += 1
return {"reencrypted": done, "failed": failed}
def key_versions_in_use(self) -> dict[int, int]:
counts: dict[int, int] = {}
for row in self._store.all_credential_rows():
v = int(row["key_version"])
counts[v] = counts.get(v, 0) + 1
return counts
+201
View File
@@ -0,0 +1,201 @@
"""④ 대시보드/설정 화면 데이터 조립 — 저장소 조회 + calc 계산 결과를 템플릿 컨텍스트로.
HTTP 와 무관하다(store 만 주입). 라우터는 파라미터 파싱·권한만 하고 여기로 넘긴다.
"""
from __future__ import annotations
from datetime import date, timedelta
from decimal import Decimal
from typing import Any, Mapping, Sequence
from . import calc
from .adapters.base import STATUS_LABELS
from .adapters.registry import all_adapters, get_adapter
def _sales_marketplaces(store: Any) -> list[dict[str, Any]]:
"""대시보드 열 = 사용 ON + 매출 집계 ON 인 쇼핑몰(설정 순서)."""
known = {a.code for a in all_adapters()}
return [m for m in store.list_marketplaces() if m["enabled"] and m["include_in_sales"] and m["code"] in known]
def display_status(marketplace: Mapping[str, Any], status_row: Mapping[str, Any] | None,
configured: bool) -> str:
if not marketplace.get("enabled"):
return "disabled"
adapter = get_adapter(marketplace["code"])
if adapter is not None and not adapter.uses_shared_integration and not configured:
return "not_configured"
return (status_row or {}).get("status") or "unknown"
def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
custom_from: date | None = None, custom_to: date | None = None,
selected: Sequence[str] = (), holidays: Mapping[str, str] | None = None,
configured: Mapping[str, bool] | None = None) -> dict[str, Any]:
markets = _sales_marketplaces(store)
all_codes = [m["code"] for m in markets]
codes = [c for c in all_codes if c in set(selected)] or all_codes
names = {m["code"]: m["name"] for m in markets}
short = {c: _short_name(names[c]) for c in all_codes}
period = calc.resolve_period(kind, anchor, custom_from=custom_from, custom_to=custom_to)
cmp_start, cmp_end, cmp_label = period.compare_range(today)
# 월·연 누적의 기준일 — 선택 기간이 오늘을 포함하면 오늘(이번주가 다음 달로 걸쳐도
# "이번달"), 지난 기간이면 기간 끝, 앞으로의 기간이면 기간 시작.
if period.end < today:
ref = period.end
elif period.start <= today:
ref = today
else:
ref = period.start
month_period = calc.resolve_period("month", ref)
year_period = calc.resolve_period("year", ref)
m_cmp_start, m_cmp_end, m_cmp_label = month_period.compare_range(today)
y_cmp_start, y_cmp_end, y_cmp_label = year_period.compare_range(today)
q_start = min(period.start, cmp_start, m_cmp_start, y_cmp_start)
q_end = max(period.end, year_period.end)
cells = calc.build_cells(store.daily_amounts(q_start, q_end, codes), store.rate_table())
cur = calc.sum_range(cells, codes, period.start, period.end)
prev = calc.sum_range(cells, codes, cmp_start, cmp_end)
mtd = calc.sum_range(cells, codes, month_period.start, month_period.end)
m_prev = calc.sum_range(cells, codes, m_cmp_start, m_cmp_end)
ytd = calc.sum_range(cells, codes, year_period.start, year_period.end)
y_prev = calc.sum_range(cells, codes, y_cmp_start, y_cmp_end)
has_prev = prev.gross != 0 or prev.commission != 0
period_word = {"day": "오늘" if period.start == today else "해당일", "week": "이번주" if period.start <= today <= period.end else "해당 주",
"month": "이번달" if period.start <= today <= period.end else "해당 월",
"year": "올해" if period.start <= today <= period.end else "해당 연도",
"custom": "선택 기간"}[period.kind]
kpis = [
{"key": "gross", "label": f"{period_word} 총매출", "value": cur.gross, "primary": True,
"delta": calc.pct_change(cur.gross, prev.gross), "cmp": cmp_label},
{"key": "net", "label": f"{period_word} 수수료 차감 매출", "value": cur.net, "primary": True,
"delta": calc.pct_change(cur.net, prev.net), "cmp": cmp_label},
{"key": "commission", "label": f"{period_word} 수수료", "value": cur.commission,
"delta": calc.pct_change(cur.commission, prev.commission) if has_prev else None, "cmp": cmp_label,
"invert": True},
{"key": "mtd", "label": f"{month_period.label} 누적 매출", "value": mtd.gross,
"delta": calc.pct_change(mtd.gross, m_prev.gross), "cmp": m_cmp_label},
{"key": "ytd", "label": f"{year_period.label} 누적 매출", "value": ytd.gross,
"delta": calc.pct_change(ytd.gross, y_prev.gross), "cmp": y_cmp_label},
]
share = calc.by_code(cells, codes, period.start, period.end)
statuses = store.statuses()
configured = configured or {}
problems = []
for m in markets:
if m["code"] not in codes:
continue
st = display_status(m, statuses.get(m["code"]), configured.get(m["code"], False))
if st in ("auth_failed", "token_expired", "api_error"):
problems.append({"code": m["code"], "name": m["name"], "label": STATUS_LABELS[st],
"error": (statuses.get(m["code"]) or {}).get("last_error", "")})
m_qs = "" if len(codes) == len(all_codes) else "".join(f"&m={c}" for c in codes)
def url(kind: str, anchor_d: date | None = None, start: date | None = None, end: date | None = None) -> str:
if kind == "custom":
return f"?period=custom&from={start.isoformat()}&to={end.isoformat()}{m_qs}"
return f"?period={kind}&d={anchor_d.isoformat()}{m_qs}"
if period.kind == "custom":
length = timedelta(days=period.days)
prev_url = url("custom", start=period.start - length, end=period.start - timedelta(days=1))
next_url = url("custom", start=period.end + timedelta(days=1), end=period.end + length)
else:
prev_url = url(period.kind, period.prev_anchor)
next_url = url(period.kind, period.next_anchor)
nav = {
"prev": prev_url, "next": next_url,
"quick": [
{"key": "day", "label": "오늘", "url": url("day", today),
"active": period.kind == "day" and period.start == today},
{"key": "week", "label": "이번주", "url": url("week", today),
"active": period.kind == "week" and period.start <= today <= period.end},
{"key": "month", "label": "이번달", "url": url("month", today),
"active": period.kind == "month" and period.start <= today <= period.end},
{"key": "year", "label": "올해", "url": url("year", today),
"active": period.kind == "year" and period.start <= today <= period.end},
],
"m_qs": m_qs,
}
return {
"nav": nav,
"period": period,
"period_kind": period.kind,
"today": today.isoformat(),
"codes": codes,
"all_codes": all_codes,
"names": names,
"short_names": short,
"selected_all": len(codes) == len(all_codes),
"kpis": kpis,
"table": calc.main_table(period, codes, cells, today=today, holidays=holidays),
"month": calc.month_summary(month_period.start.year, month_period.start.month, codes, cells),
"year": calc.year_months(year_period.start.year, codes, cells, today=today),
"chart_daily": calc.daily_series(period, codes, cells),
"chart_share": [{"code": c, "name": names[c], **share[c].as_dict()} for c in codes],
"problems": problems,
"last_update_at": store.last_update_at(),
"running": store.running_codes(),
"no_marketplaces": not all_codes,
}
def _short_name(name: str) -> str:
return {"네이버 스마트스토어": "네이버", "토스쇼핑": "토스"}.get(name, name)
def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapping[str, Any],
key_versions_in_use: Mapping[int, int], sample_count: int) -> dict[str, Any]:
from app.timezone import today_kst # noqa: WPS433
from .adapters.cafe24 import MARKET_MAP # noqa: WPS433
statuses = store.statuses()
rates = store.rate_table()
today = today_kst()
via_cafe24 = set(MARKET_MAP.values()) # 카페24 마켓 통합관리 경유로 매출이 들어오는 쇼핑몰
rows = []
by_code = {m["code"]: m for m in store.list_marketplaces()}
for adapter in all_adapters():
m = by_code.get(adapter.code)
if m is None:
continue
st_row = statuses.get(adapter.code) or {}
st = display_status(m, st_row, configured.get(adapter.code, False))
cur_rate = calc.rate_on(rates, adapter.code, today)
has_rate = bool(rates.get(adapter.code))
rows.append({
"code": adapter.code, "name": m["name"], "enabled": m["enabled"],
"include_in_sales": m["include_in_sales"],
"rate": _fmt_rate(cur_rate) if has_rate else "",
"rate_history": len(rates.get(adapter.code, ())),
"auth_type": adapter.auth_type, "shared": adapter.uses_shared_integration,
"implemented": adapter.implemented, "note": adapter.note, "docs_url": adapter.docs_url,
"configured": configured.get(adapter.code, False),
"via_cafe24": adapter.code in via_cafe24,
"status": st, "status_label": STATUS_LABELS.get(st, st),
"last_test_at": st_row.get("last_test_at"), "last_test_ok": st_row.get("last_test_ok"),
"last_sync_at": st_row.get("last_sync_at"), "last_success_sync_at": st_row.get("last_success_sync_at"),
"last_error": st_row.get("last_error") or "", "last_error_at": st_row.get("last_error_at"),
})
stale = {v: n for v, n in key_versions_in_use.items() if key_info.get("current_version") and v != key_info["current_version"]}
return {"rows": rows, "key_info": key_info, "key_versions_in_use": dict(key_versions_in_use),
"stale_key_rows": sum(stale.values()), "sample_count": sample_count,
"default_sample_from": today.replace(month=1, day=1).isoformat(),
"default_sample_to": today.isoformat()}
def _fmt_rate(rate: Decimal) -> str:
s = f"{Decimal(rate):f}"
if "." in s:
s = s.rstrip("0").rstrip(".")
return s
+385
View File
@@ -0,0 +1,385 @@
"""performance_db PostgreSQL 저장소.
- 드라이버: psycopg 3 (`psycopg[binary,pool]`) — 다른 모듈과 동일 패턴.
- 연결 정보: 환경변수 `PERFORMANCE_DB_URL`
(예: postgresql://performance_app:<pwd>@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)는 덮어쓴다 — 여러 번 동기화해도 중복 없음."""
rows = self._event_rows(code, events, is_sample)
if not rows:
return 0
with self._pool.connection() as conn:
with conn.transaction():
with conn.cursor() as cur:
cur.executemany(self._UPSERT_SQL, rows)
return len(rows)
def replace_events(self, code: str, start: date, end: date, events: Iterable[dict[str, Any]],
*, id_prefix: str = "") -> int:
"""기간(sales_date) 안 이 어댑터가 만든 실데이터(is_sample 아님)를 지우고 새로 넣는다 — 한 트랜잭션.
지우는 대상: 이 쇼핑몰(code)의 행 + (id_prefix 가 있으면) 다른 쇼핑몰 열로 보냈던 이 어댑터의 행
(external_event_id 가 id_prefix 로 시작). 다른 쇼핑몰의 직접 연동분·테스트 데이터는 건드리지 않는다.
실패하면 롤백되어 예전 데이터가 그대로 남는다."""
rows = self._event_rows(code, events, False)
with self._pool.connection() as conn:
with conn.transaction():
if id_prefix:
conn.execute(
"DELETE FROM perf_sales_events WHERE is_sample = FALSE AND sales_date BETWEEN %s AND %s "
"AND (marketplace_code = %s OR left(external_event_id, %s) = %s)",
(start, end, code, len(id_prefix), id_prefix),
)
else:
conn.execute(
"DELETE FROM perf_sales_events WHERE marketplace_code = %s AND is_sample = FALSE "
"AND sales_date BETWEEN %s AND %s",
(code, start, end),
)
if rows:
with conn.cursor() as cur:
cur.executemany(self._UPSERT_SQL, rows)
return len(rows)
@staticmethod
def _event_rows(code: str, events: Iterable[dict[str, Any]], is_sample: bool) -> list[tuple]:
"""행마다 집계할 쇼핑몰 = 사건의 marketplace_code(다른 쇼핑몰 대신 받은 주문), 없으면 code."""
return [
(e.get("marketplace_code") or code, e["event_type"], e["external_event_id"], e["external_order_id"],
e.get("external_line_id", ""),
e.get("order_date"), e.get("payment_date"), e["event_date"], e["sales_date"],
e.get("product_name", ""), e.get("option_name", ""), int(e.get("quantity") or 0),
int(e["amount"]), int(e.get("discount_amount") or 0), e.get("order_status", ""),
Jsonb(e.get("raw") or {}), is_sample)
for e in events
]
_UPSERT_SQL = """
INSERT INTO perf_sales_events
(marketplace_code, event_type, external_event_id, external_order_id, external_line_id,
order_date, payment_date, event_date, sales_date, product_name, option_name, quantity,
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()
"""
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 daily_breakdown(self, code: str, start: date, end: date, *, id_prefix: str = "") -> list[dict[str, Any]]:
"""쇼핑몰 화면(일별 매출내역) 대조용 — 날짜별 결제(SALE 합·건수)·환불(그 밖, 양수)·마지막 수집 시각.
id_prefix 가 있으면 이 어댑터가 다른 쇼핑몰 열로 보낸 사건까지 합친다(카페24 화면 합계와 같은 범위)."""
where = "(marketplace_code = %s OR left(external_event_id, %s) = %s)" if id_prefix else "marketplace_code = %s"
params: tuple = (code, len(id_prefix), id_prefix) if id_prefix else (code,)
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT sales_date, "
" COALESCE(SUM(amount) FILTER (WHERE event_type = 'SALE'), 0)::BIGINT AS paid, "
" COUNT(*) FILTER (WHERE event_type = 'SALE')::INT AS orders, "
" COALESCE(-SUM(amount) FILTER (WHERE event_type <> 'SALE'), 0)::BIGINT AS refund, "
" MAX(synced_at) AS synced_at "
f"FROM perf_sales_events WHERE is_sample = FALSE AND sales_date BETWEEN %s AND %s AND {where} "
"GROUP BY sales_date ORDER BY sales_date",
(start, end, *params),
).fetchall()
return [{"date": r["sales_date"].isoformat(), "paid": int(r["paid"]), "orders": int(r["orders"]),
"refund": int(r["refund"]), "synced_at": _iso(r["synced_at"])} for r in rows]
def list_events(self, code: str, start: date, end: date, *, limit: int = 500) -> list[dict[str, Any]]:
"""금액 클릭 상세(Drill-down). raw_data 는 보내지 않는다."""
with self._pool.connection() as conn:
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]
+201
View File
@@ -0,0 +1,201 @@
"""매출 업데이트 진행 상황 — 백그라운드 수집 작업(쇼핑몰별 진행 막대)을 메모리에 둔다.
- [매출 업데이트]·[과거 매출 가져오기]는 수집을 백그라운드 스레드로 돌리고 작업 번호를 바로 돌려준다.
화면은 GET /performance/api/sync/jobs/{id} 를 0.8초마다 불러 쇼핑몰별·전체 진행 막대를 그린다.
- 어댑터가 ctx.progress.plan()/step() 으로 알린 단계를 ShopProgress 가 모은다(쇼핑몰마다 단위가 다르다 —
네이버 "일", 11번가·카페24 "구간").
- 웹 프로세스 하나(uvicorn 단일 워커) 기준 — 워커를 여러 개로 늘리면 진행 상황을 DB 로 옮겨야 한다.
서버를 다시 켜면 진행 중 작업 정보는 사라진다(수집 결과는 DB 에 이미 저장된 만큼 남음).
- [업데이트 취소]: SyncJob.cancel() → 각 쇼핑몰이 다음 API 호출 직전(ShopProgress.check)에 Cancelled 로 멈춘다.
수집 중에 멈춘 쇼핑몰은 DB 에 아무것도 쓰지 않는다(저장은 수집이 끝난 뒤 한 트랜잭션). 저장 중이면 그 저장은 끝낸다.
아직 차례가 안 온 쇼핑몰은 "취소됨"으로 건너뛴다.
"""
from __future__ import annotations
import threading
import time
import uuid
from datetime import date
from typing import Any
from .adapters.base import Cancelled, Progress
MAX_JOBS = 20
_LOCK = threading.Lock()
_JOBS: dict[str, "SyncJob"] = {}
# 끝났지만 막대에서 빼는 쇼핑몰(수집할 수 없어 바로 끝난 것) — 전체 진행률 계산에서 제외
PASSIVE_STATUS = frozenset({"not_implemented", "not_configured"})
class ShopProgress(Progress):
"""쇼핑몰 하나의 진행 상황. state: waiting → running → saving → done | error | skipped | cancelled."""
def __init__(self, code: str, name: str, *, active: bool = True, job: "SyncJob | None" = None) -> None:
self.code, self.name, self.active, self.job = code, name, active, job
self.state = "waiting"
self.done = self.total = self.items = self.upserted = 0
self.unit = "단계"
self.status = self.label = self.message = ""
self.started_at = self.finished_at = 0.0
self._lock = threading.Lock()
# ── 어댑터가 부르는 쪽(Progress) ──
def plan(self, total: int, unit: str = "단계") -> None:
with self._lock:
self.total, self.unit, self.done = max(0, int(total)), unit or "단계", 0
def add(self, n: int) -> None:
with self._lock:
self.total += max(0, int(n))
def check(self) -> None:
if self.cancel_requested and self.state == "running":
raise Cancelled("사용자가 업데이트를 취소했습니다.")
@property
def cancel_requested(self) -> bool:
return bool(self.job is not None and self.job.cancel_requested)
def step(self, n: int = 1, *, items: int = 0) -> None:
self.check()
with self._lock:
self.done += max(0, int(n))
self.items += max(0, int(items))
if self.total and self.done > self.total: # 계획보다 많이 돌면 전체를 늘려 100% 를 넘지 않게
self.total = self.done
# ── sync 가 부르는 쪽 ──
def start(self) -> None:
with self._lock:
self.state, self.started_at = "running", time.time()
def saving(self) -> None:
with self._lock:
self.state = "saving"
def finish(self, *, upserted: int, message: str = "") -> None:
with self._lock:
self.state, self.upserted, self.message, self.status = "done", int(upserted), message, "ok"
if self.total:
self.done = self.total
self.finished_at = time.time()
def fail(self, *, status: str, label: str, message: str) -> None:
with self._lock:
self.state, self.status, self.label, self.message = "error", status, label, message
if status in PASSIVE_STATUS:
self.active = False
self.finished_at = time.time()
def cancelled(self) -> None:
with self._lock:
self.state, self.status, self.message = "cancelled", "cancelled", "취소됨"
self.finished_at = time.time()
def skip(self, message: str) -> None:
with self._lock:
self.state, self.status, self.message = "skipped", "running", message
self.finished_at = time.time()
@property
def finished(self) -> bool:
return self.state in ("done", "error", "skipped", "cancelled")
def fraction(self) -> float:
if self.finished:
return 1.0
if self.state == "saving":
return 0.98
if self.state == "running" and self.total:
return min(0.97, self.done / self.total)
return 0.0
def snapshot(self) -> dict[str, Any]:
with self._lock:
return {
"code": self.code, "name": self.name, "active": self.active, "state": self.state,
"done": self.done, "total": self.total, "unit": self.unit, "items": self.items,
"upserted": self.upserted, "status": self.status, "label": self.label, "message": self.message,
"fraction": round(self.fraction(), 4),
"elapsed": round((self.finished_at or time.time()) - self.started_at, 1) if self.started_at else 0,
}
class SyncJob:
def __init__(self, *, user: str, start: date | None, end: date | None) -> None:
self.id = uuid.uuid4().hex[:12]
self.user, self.start, self.end = user, start, end
self.created_at = time.time()
self.finished_at = 0.0
self.shops: list[ShopProgress] = []
self.error = ""
self.last_update_at: str | None = None
self.cancel_requested = False
self.cancelled_by = ""
self._lock = threading.Lock()
def set_targets(self, targets: list[tuple[str, str, bool]], start: date, end: date) -> dict[str, ShopProgress]:
with self._lock:
self.start, self.end = start, end
self.shops = [ShopProgress(code, name, active=active, job=self) for code, name, active in targets]
return {s.code: s for s in self.shops}
def cancel(self, user: str = "") -> None:
"""[업데이트 취소] — 돌고 있는 쇼핑몰은 다음 API 호출 직전에, 기다리는 쇼핑몰은 차례가 오면 멈춘다."""
with self._lock:
if not self.finished_at and not self.cancel_requested:
self.cancel_requested, self.cancelled_by = True, user
def finish(self, *, error: str = "", last_update_at: str | None = None) -> None:
with self._lock:
self.error, self.last_update_at, self.finished_at = error, last_update_at, time.time()
@property
def finished(self) -> bool:
return bool(self.finished_at)
def snapshot(self) -> dict[str, Any]:
with self._lock:
shops = [s.snapshot() for s in self.shops]
active = [s for s in shops if s["active"]]
return {
"id": self.id, "finished": self.finished, "error": self.error, "user": self.user,
"cancel_requested": self.cancel_requested,
"from": self.start.isoformat() if self.start else None, "to": self.end.isoformat() if self.end else None,
"elapsed": round((self.finished_at or time.time()) - self.created_at, 1),
"last_update_at": self.last_update_at, "shops": shops,
"overall": {
"shops": len(active),
"finished": sum(1 for s in active if s["state"] in ("done", "error", "skipped", "cancelled")),
"fraction": round(sum(s["fraction"] for s in active) / len(active), 4) if active else
(1.0 if self.finished else 0.0),
"items": sum(s["items"] for s in shops), "upserted": sum(s["upserted"] for s in shops),
},
}
def create_job(*, user: str, start: date | None, end: date | None) -> SyncJob:
job = SyncJob(user=user, start=start, end=end)
with _LOCK:
_JOBS[job.id] = job
if len(_JOBS) > MAX_JOBS: # 오래된 끝난 작업부터 정리
for jid, j in sorted(_JOBS.items(), key=lambda kv: kv[1].created_at):
if len(_JOBS) <= MAX_JOBS:
break
if j.finished:
del _JOBS[jid]
return job
def get_job(job_id: str) -> SyncJob | None:
with _LOCK:
return _JOBS.get(job_id)
def running_job() -> SyncJob | None:
"""지금 돌고 있는 작업(가장 최근). 없으면 None — 다른 사람이 누른 업데이트도 같이 보여 주려고."""
with _LOCK:
live = [j for j in _JOBS.values() if not j.finished]
return max(live, key=lambda j: j.created_at) if live else None
+411
View File
@@ -0,0 +1,411 @@
"""실적 모듈 라우터 (prefix=/performance).
화면
GET /performance/ 대시보드(모듈 권한)
GET /performance/settings 실적 설정(관리자)
JSON API — 모듈 권한
POST /performance/api/sync 매출 업데이트(사용 중인 쇼핑몰 전부, 쇼핑몰별 실패 격리)
background=true 면 백그라운드로 돌리고 작업 번호를 바로 돌려줌
GET /performance/api/sync/jobs/{id} 매출 업데이트 진행 상황(쇼핑몰별·전체 진행 막대)
GET /performance/api/sync/current 지금 돌고 있는 업데이트(없으면 null)
POST /performance/api/sync/jobs/{id}/cancel 업데이트 취소(시작한 사람 또는 관리자)
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 입력칸 + 저장 여부(비밀 원문 없음)
GET /performance/api/marketplaces/{code}/daily-check 일별 매출 비교(저장값 + 지금 API 값)
PUT /performance/api/marketplaces/{code}/credentials 저장(암호화)
POST /performance/api/marketplaces/{code}/test 연결 테스트(저장값 또는 새 입력값)
POST /performance/api/sample-data 테스트 데이터 생성/삭제
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
MAX_CHECK_DAYS = 62 # 쇼핑몰 화면 일별 비교(카페24 일별 매출내역 붙여넣기)
MAX_BACKFILL_DAYS = 366
MAX_USER_SYNC_DAYS = 92 # 관리자가 아니어도 가져올 수 있는 기간(이번달·직접선택 짧은 기간)
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:
"""from/to 가 없으면 최근 N일(PERFORMANCE_SYNC_DAYS). 기간 지정은 대시보드 [매출 업데이트](보고 있는 기간)와
설정 [과거 매출 가져오기]가 쓴다 — 모듈 권한자는 92일까지, 그보다 길면(최대 366일) 관리자만."""
store, user = common.require_store(request)
_, sync = common.services(request, store)
codes = [str(c) for c in (payload.get("codes") or []) if get_adapter(str(c))]
start = _parse_date(payload.get("from"), field="시작일")
end = _parse_date(payload.get("to"), field="종료일")
if start or end:
from app.store import is_admin # noqa: WPS433
end = end or today_kst()
start = start or end
if end < start:
start, end = end, start
if end > today_kst():
end = today_kst()
if start > end:
raise HTTPException(status_code=400, detail="앞으로의 기간은 가져올 수 없습니다.")
days = (end - start).days + 1
if days > MAX_BACKFILL_DAYS:
raise HTTPException(status_code=400, detail=f"한 번에 {MAX_BACKFILL_DAYS}일까지 가져올 수 있습니다.")
if days > MAX_USER_SYNC_DAYS and not is_admin(user):
raise HTTPException(status_code=403,
detail=f"{MAX_USER_SYNC_DAYS}일보다 긴 기간은 관리자만 가져올 수 있습니다.")
if payload.get("background"):
return JSONResponse(_start_background_sync(store, sync, start=start, end=end, codes=codes or None,
user=user["email"]))
results = sync.sync_all(start=start, end=end, codes=codes or None, user=user["email"])
return JSONResponse({"results": results, "last_update_at": store.last_update_at()})
def _start_background_sync(store: Any, sync: Any, *, start: date | None, end: date | None,
codes: list[str] | None, user: str) -> dict[str, Any]:
"""수집을 스레드로 돌리고 작업 번호를 바로 돌려준다. 이미 돌고 있는 업데이트가 있으면 새로 시작하지 않고
그 작업을 보여 준다(같은 쇼핑몰 동시 실행은 어차피 막혀 있다)."""
import logging # noqa: WPS433
import threading # noqa: WPS433
from . import jobs # noqa: WPS433
live = jobs.running_job()
if live is not None:
return {"job": live.snapshot(), "joined": True}
job = jobs.create_job(user=user, start=start, end=end)
def run() -> None:
error = ""
try:
sync.sync_all(start=start, end=end, codes=codes, user=user, job=job)
except Exception as exc: # noqa: BLE001 — 스레드 밖으로 새지 않게, 화면에는 "오류"로
logging.getLogger("performance.sync").exception("background sync failed")
error = f"업데이트 중 오류: {type(exc).__name__}"
last = None
try:
last = store.last_update_at()
except Exception: # noqa: BLE001
pass
job.finish(error=error, last_update_at=last)
threading.Thread(target=run, name=f"perf-sync-{job.id}", daemon=True).start()
return {"job": job.snapshot(), "joined": False}
@router.get("/api/sync/jobs/{job_id}")
def api_sync_job(request: Request, job_id: str) -> JSONResponse:
common.require_store(request)
from . import jobs # noqa: WPS433
job = jobs.get_job(job_id)
if job is None:
raise HTTPException(status_code=404, detail="진행 상황을 찾을 수 없습니다(서버가 다시 시작됐을 수 있습니다).")
return JSONResponse({"job": job.snapshot()})
@router.post("/api/sync/jobs/{job_id}/cancel")
def api_sync_cancel(request: Request, job_id: str) -> JSONResponse:
"""[업데이트 취소] — 시작한 사람 또는 관리자. 돌고 있는 쇼핑몰은 다음 API 호출 직전에 멈추고(저장 전이면 DB 그대로),
기다리는 쇼핑몰은 건너뛴다. 이미 저장이 끝난 쇼핑몰 결과는 그대로 남는다."""
from app.store import is_admin # noqa: WPS433
from . import jobs # noqa: WPS433
_, user = common.require_store(request)
job = jobs.get_job(job_id)
if job is None:
raise HTTPException(status_code=404, detail="진행 상황을 찾을 수 없습니다(서버가 다시 시작됐을 수 있습니다).")
if job.user and job.user != user["email"] and not is_admin(user):
raise HTTPException(status_code=403, detail="업데이트를 시작한 사람이나 관리자만 취소할 수 있습니다.")
job.cancel(user["email"])
return JSONResponse({"job": job.snapshot()})
@router.get("/api/sync/current")
def api_sync_current(request: Request) -> JSONResponse:
common.require_store(request)
from . import jobs # noqa: WPS433
job = jobs.running_job()
return JSONResponse({"job": job.snapshot() if job else None})
@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.get("/api/marketplaces/{code}/reconcile")
def api_reconcile(request: Request, code: str, date_: str = Query(..., alias="date"), to: str | None = None) -> JSONResponse:
"""쇼핑몰 화면(예: 카페24 일별 매출내역)과 비교용 — 그날 원천 금액 항목별 합계. DB 는 바꾸지 않는다."""
store, user = common.require_store(request, admin=True)
_code_or_404(store, code)
day = _parse_date(date_)
_, sync = common.services(request, store)
return JSONResponse(sync.reconcile(code, day, to=_parse_date(to, field="종료일"), user=user["email"]))
@router.get("/api/marketplaces/{code}/daily-check")
def api_daily_check(request: Request, code: str, from_: str = Query(..., alias="from"), to: str | None = None,
live: bool = False) -> JSONResponse:
"""쇼핑몰 화면 일별 매출과 날짜별 비교 — 저장값(db) + live=1 이면 지금 API 로 다시 계산한 값(저장 안 함)."""
store, user = common.require_store(request, admin=True)
_code_or_404(store, code)
start = _parse_date(from_)
end = _parse_date(to) or start
if end < start:
start, end = end, start
if (end - start).days + 1 > MAX_CHECK_DAYS:
raise HTTPException(status_code=400, detail=f"일별 비교는 {MAX_CHECK_DAYS}일 이내만 가능합니다.")
_, sync = common.services(request, store)
return JSONResponse(sync.daily_check(code, start, end, live=live, user=user["email"]))
@router.post("/api/sample-data")
def api_sample_data(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
store, _ = common.require_store(request, admin=True)
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()})
@@ -0,0 +1 @@
"""② API 인증정보 보안 — 암호화(crypto) · 비밀값 가리기(redact)."""
+161
View File
@@ -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
@@ -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
+235
View File
@@ -0,0 +1,235 @@
"""① 수집 서비스 — 쇼핑몰 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, Cancelled, 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 = "", progress: Any = None) -> dict[str, Any]:
"""progress: jobs.ShopProgress(매출 업데이트 창 진행 막대) — 없으면 알리지 않는다."""
adapter = get_adapter(code)
result: dict[str, Any] = {"code": code, "ok": False, "skipped": False, "fetched": 0, "upserted": 0}
if adapter is None:
if progress is not None:
progress.fail(status="api_error", label=STATUS_LABELS["api_error"], message="알 수 없는 쇼핑몰입니다.")
return {**result, "status": "api_error", "message": "알 수 없는 쇼핑몰입니다."}
if progress is not None and progress.cancel_requested: # [업데이트 취소] 뒤 차례가 온 쇼핑몰
progress.cancelled()
return {**result, "cancelled": True, "status": "cancelled", "message": "취소됨"}
run_id = self._store.start_run(code, trigger=trigger, range_from=start, range_to=end, user=user)
if run_id is None:
if progress is not None:
progress.skip("이미 다른 업데이트가 진행 중입니다.")
return {**result, "skipped": True, "status": "running", "message": "이미 업데이트 중입니다."}
if progress is not None:
progress.start()
ctx = None
try:
ctx = self._ctx(adapter, user=user)
if progress is not None:
ctx.progress = progress
fetched, events = adapter.collect(ctx, start, end)
if progress is not None:
progress.saving()
known = ctx.credentials.known_secrets()
rows = [event_row(ev, known) for ev in events]
# 다른 쇼핑몰 열로 보낸 사건 — 등록된 쇼핑몰이 아니면 이 쇼핑몰 열에 둔다(합계가 빠지지 않게).
registered = {m["code"] for m in self._store.list_marketplaces()}
for r in rows:
if r.get("marketplace_code") not in registered:
r["marketplace_code"] = code
if adapter.replace_range:
# 그 기간을 통째로 다시 받은 쇼핑몰 — 기간 안 예전 행을 지우고 새로 넣는다(한 트랜잭션).
rows = [r for r in rows if start <= r["sales_date"] <= end]
upserted = self._store.replace_events(code, start, end, rows, id_prefix=adapter.event_prefix)
else:
upserted = self._store.upsert_events(code, rows)
self._store.finish_run(run_id, ok=True, fetched=fetched, upserted=upserted)
self._store.record_sync(code, status="ok", ok=True)
if progress is not None:
progress.finish(upserted=upserted, message=f"{upserted}건 반영")
return {**result, "ok": True, "status": "ok", "fetched": fetched, "upserted": upserted,
"message": f"{upserted}건 반영"}
except Cancelled:
# 수집 중 취소 — 아직 아무것도 저장하지 않았다. 연결 상태(오류 표시)는 바꾸지 않는다.
self._store.finish_run(run_id, ok=False, error="업데이트 취소")
if progress is not None:
progress.cancelled()
return {**result, "cancelled": True, "status": "cancelled", "message": "취소됨"}
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)
if progress is not None:
progress.fail(status=status, label=STATUS_LABELS.get(status, status), message=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 = "", job: Any = None) -> list[dict[str, Any]]:
"""job: jobs.SyncJob — 주면 쇼핑몰마다 진행 상황(ShopProgress)을 채운다(매출 업데이트 창)."""
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 for a in all_adapters() if a.code in enabled and (not codes or a.code in codes)]
progress: dict[str, Any] = {}
if job is not None:
# 수집이 구현되고 인증정보가 있는 쇼핑몰만 막대로(active), 나머지는 "건너뜀" 한 줄로 — 바로 끝나는
# 쇼핑몰이 전체 진행률을 부풀리거나, 아직 차례가 안 와서 진행률을 낮추지 않게.
def ready(a: MarketplaceAdapter) -> bool:
if not a.implemented:
return False
try:
return a.is_configured(self._ctx(a, user=user))
except Exception: # noqa: BLE001 — 확인이 안 되면 일단 막대로(실제 결과는 수집 때 나온다)
return True
progress = job.set_targets([(a.code, a.name, ready(a)) for a in targets], start, end)
return [self.sync_marketplace(a.code, start, end, trigger=trigger, user=user, progress=progress.get(a.code))
for a in targets]
# ── 쇼핑몰 화면과 대조 ────────────────────────────────
def reconcile(self, code: str, day: date, *, to: date | None = None, user: str = "") -> dict[str, Any]:
"""어댑터가 지원하면(reconcile) 그날 원천 금액을 항목별로 합산해 돌려준다. DB 는 바꾸지 않는다."""
adapter = get_adapter(code)
if adapter is None or not hasattr(adapter, "reconcile"):
return {"ok": False, "message": "이 쇼핑몰은 대조 기능을 지원하지 않습니다."}
ctx = None
try:
ctx = self._ctx(adapter, user=user)
return {"ok": True, **(adapter.reconcile(ctx, day, to=to) if to else adapter.reconcile(ctx, day))}
except Exception as exc: # noqa: BLE001
status, message = self._failure(exc, ctx)
return {"ok": False, "status": status, "label": STATUS_LABELS.get(status, status), "message": message}
def daily_check(self, code: str, start: date, end: date, *, live: bool = False, user: str = "") -> dict[str, Any]:
"""쇼핑몰 화면 일별 매출과 날짜별로 맞춰 보는 용도. DB 는 바꾸지 않는다.
db = 지금 저장된 값(날짜별 결제·환불·결제 건수)
live = live=True 일 때 지금 API·현재 규칙으로 다시 계산한 값(매출 업데이트와 같은 계산, 저장 안 함).
db 만 틀리고 live 가 맞으면 → 예전에 받은 뒤 규칙·주문이 바뀐 것(다시 가져오면 해결)."""
adapter = get_adapter(code)
if adapter is None:
return {"ok": False, "message": "알 수 없는 쇼핑몰입니다."}
prefix = adapter.event_prefix if adapter.replace_range else ""
out: dict[str, Any] = {"ok": True, "db": self._store.daily_breakdown(code, start, end, id_prefix=prefix)}
if not live:
return out
ctx = None
try:
ctx = self._ctx(adapter, user=user)
_, events = adapter.collect(ctx, start, end)
except Exception as exc: # noqa: BLE001
status, message = self._failure(exc, ctx)
return {**out, "live_error": f"{STATUS_LABELS.get(status, status)} — {message}"}
days: dict[str, dict[str, Any]] = {}
for ev in events:
d = sales_date_for(ev)
if not (start <= d <= end):
continue
row = days.setdefault(d.isoformat(), {"date": d.isoformat(), "paid": 0, "orders": 0, "refund": 0})
if ev.event_type == "SALE":
row["paid"] += ev.amount
row["orders"] += 1
else:
row["refund"] -= ev.amount
out["live"] = sorted(days.values(), key=lambda r: r["date"])
return out
# ── 테스트(모의) 데이터 ────────────────────────────────
def generate_samples(self, start: date, end: date, codes: list[str]) -> int:
from .adapters import mock # noqa: WPS433
n = 0
for code in codes:
n += self._store.upsert_events(code, (event_row(ev) for ev in mock.generate(code, start, end)),
is_sample=True)
return n
@@ -0,0 +1,7 @@
{# 실적 모듈 탭 — 설정 탭은 관리자에게만(서버도 관리자만 허용). #}
<nav class="perf-tabs" aria-label="실적 메뉴">
<a class="perf-tab{% if active_tab == 'dashboard' %} is-active{% endif %}" href="/performance/">실적</a>
{% if is_admin %}
<a class="perf-tab{% if active_tab == 'settings' %} is-active{% endif %}" href="/performance/settings">설정</a>
{% endif %}
</nav>
@@ -0,0 +1,242 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930g" />{% endblock %}
{%- macro won(v) -%}
{%- if v is none -%}<span class="perf-na"></span>
{%- elif v == 0 -%}<span class="perf-zero">–</span>
{%- else -%}{{ "{:,}".format(v) }}{%- endif -%}
{%- endmacro -%}
{#- 한 칸에 총매출/수수료/차감매출 세 값을 넣고, 보기 전환은 CSS(data-metric)로. -#}
{%- macro m3(m) -%}
<span class="v v-gross">{{ won(m.gross) }}</span><span class="v v-commission">{{ won(m.commission) }}</span><span class="v v-net">{{ won(m.net) }}</span>
{%- endmacro -%}
{% block content %}
<section class="perf" id="perf-dash" data-metric="{{ metric }}">
{% include "performance/_tabs.html" %}
<!-- ── 기간 · 필터 · 업데이트 ── -->
<div class="perf-toolbar">
<div class="perf-quick" role="group" aria-label="기간 선택">
{% for q in nav.quick %}
<a class="perf-seg{% if q.active %} is-active{% endif %}" href="{{ q.url }}">{{ q.label }}</a>
{% endfor %}
<button type="button" class="perf-seg{% if period_kind == 'custom' %} is-active{% endif %}" id="perf-custom-btn">직접선택</button>
</div>
<div class="perf-nav">
<a class="perf-nav-btn" href="{{ nav.prev }}" title="{{ period.prev_label }}">‹ {{ period.prev_label }}</a>
<span class="perf-nav-label">{{ period.label }}</span>
<a class="perf-nav-btn" href="{{ nav.next }}" title="{{ period.next_label }}">{{ period.next_label }} ›</a>
</div>
<form class="perf-custom" id="perf-custom" method="get" action="/performance/"{% if period_kind != 'custom' %} hidden{% endif %}>
<input type="hidden" name="period" value="custom" />
<input class="erp-input perf-date" type="date" name="from" value="{{ period.start.isoformat() }}" required />
<span class="perf-muted">~</span>
<input class="erp-input perf-date" type="date" name="to" value="{{ period.end.isoformat() }}" required />
{% for c in codes %}{% if not selected_all %}<input type="hidden" name="m" value="{{ c }}" />{% endif %}{% endfor %}
<button class="erp-btn erp-btn-outline" type="submit">조회</button>
</form>
<details class="perf-filter" id="perf-filter">
<summary class="erp-btn erp-btn-outline">쇼핑몰: {% if selected_all %}전체{% else %}{{ codes | length }}곳{% endif %}</summary>
<form class="perf-filter-pop" method="get" action="/performance/">
<input type="hidden" name="period" value="{{ period_kind }}" />
{% if period_kind == 'custom' %}
<input type="hidden" name="from" value="{{ period.start.isoformat() }}" />
<input type="hidden" name="to" value="{{ period.end.isoformat() }}" />
{% else %}
<input type="hidden" name="d" value="{{ period.anchor.isoformat() }}" />
{% endif %}
{% for c in all_codes %}
<label class="perf-check"><input type="checkbox" name="m" value="{{ c }}"{% if c in codes %} checked{% endif %} /> {{ names[c] }}</label>
{% endfor %}
<div class="perf-filter-act">
<button type="button" class="erp-btn erp-btn-ghost" data-perf-check-all>전체</button>
<button type="submit" class="erp-btn erp-btn-primary">적용</button>
</div>
</form>
</details>
<div class="perf-update">
<span class="perf-muted" id="perf-last-update">마지막 업데이트
<b>{{ (last_update_at or '')[:16] | replace('T', ' ') or '—' }}</b></span>
<button type="button" class="erp-btn erp-btn-primary" id="perf-sync-btn"{% if running %} disabled{% endif %}
title="지금 보고 있는 기간({{ period.label }}, 오늘까지)의 매출을 쇼핑몰에서 다시 가져옵니다">
{% if running %}업데이트 중…{% else %}매출 업데이트{% endif %}
</button>
</div>
</div>
{% if no_marketplaces %}
<div class="perf-notice">매출에 포함된 쇼핑몰이 없습니다. {% if is_admin %}<a href="/performance/settings">실적 설정</a>에서 쇼핑몰 사용을 켜세요.{% endif %}</div>
{% endif %}
{% if problems %}
<div class="perf-notice is-warn" id="perf-problems">
<b>연결 오류</b>
{% for p in problems %}<span class="perf-problem" title="{{ p.error }}">{{ p.name }} · {{ p.label }}</span>{% endfor %}
<span class="perf-muted">— 해당 쇼핑몰은 마지막 정상 수집분까지만 반영됩니다. 나머지는 정상입니다.</span>
</div>
{% endif %}
<div class="perf-notice" id="perf-sync-result" hidden></div>
<!-- ── KPI ── -->
<div class="perf-kpis">
{% for k in kpis %}
<div class="perf-kpi{% if k.primary %} is-primary{% endif %}">
<div class="perf-kpi-label">{{ k.label }}</div>
<div class="perf-kpi-value">₩{{ "{:,}".format(k.value) }}</div>
<div class="perf-kpi-delta">
{% if k.delta is none %}<span class="perf-muted">{{ k.cmp }} 비교 없음</span>
{% else %}
{% set up = k.delta > 0 %}
<span class="perf-delta {% if k.delta == 0 %}is-flat{% elif up != (k.invert or false) %}is-up{% else %}is-down{% endif %}">
{% if k.delta > 0 %}▲{% elif k.delta < 0 %}▼{% else %}–{% endif %} {{ "%.1f" | format(k.delta | abs) }}%</span>
<span class="perf-muted">{{ k.cmp }} 대비</span>
{% endif %}
</div>
</div>
{% endfor %}
</div>
<!-- ── 일자 × 쇼핑몰 ── -->
<div class="erp-card perf-card">
<div class="perf-card-head">
<h2 class="perf-h">{% if period_kind == 'year' %}월별 × 쇼핑몰{% else %}일자별 × 쇼핑몰{% endif %}</h2>
<div class="perf-metric" role="group" aria-label="표시 기준">
<button type="button" class="perf-seg" data-metric="gross">총매출</button>
<button type="button" class="perf-seg" data-metric="commission">수수료</button>
<button type="button" class="perf-seg" data-metric="net">수수료 차감 매출</button>
</div>
</div>
<div class="erp-table-wrap perf-table-wrap">
<table class="perf-table perf-main">
<thead>
<tr>
<th class="perf-th-label">{% if period_kind == 'year' %}월{% else %}날짜{% endif %}</th>
{% for c in codes %}<th title="{{ names[c] }}">{{ short_names[c] }}</th>{% endfor %}
<th class="perf-th-total">{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}</th>
</tr>
</thead>
<tbody>
{% for r in table %}
<tr class="perf-row-{{ r.kind }}{% if r.weekday == 5 %} is-sat{% endif %}{% if r.weekday == 6 or r.holiday %} is-sun{% endif %}{% if r.today %} is-today{% endif %}{% if r.future %} is-future{% endif %}">
<th class="perf-td-label" scope="row"{% if r.holiday %} title="{{ r.holiday }}"{% endif %}>
{{ r.label }}{% if r.holiday %}<small class="perf-hol">{{ r.holiday }}</small>{% endif %}
</th>
{% for c in codes %}
{% set m = r.cells[c] %}
<td class="perf-num{% if r['from'] and (m.gross or m.commission) %} is-link{% endif %}"
{% if r['from'] %}data-code="{{ c }}" data-from="{{ r['from'] }}" data-to="{{ r['to'] }}"{% endif %}>{{ m3(m) }}</td>
{% endfor %}
<td class="perf-num perf-td-total">{{ m3(r.total) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
<!-- ── 그래프 ── -->
<div class="perf-grid2">
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">{% if period_kind == 'year' %}월별{% else %}일별{% endif %} 매출 추이</h2>
<span class="perf-muted perf-metric-name"></span></div>
<div class="perf-chart" id="perf-chart-daily"></div>
</div>
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">쇼핑몰별 비중</h2>
<span class="perf-muted">{{ period.label }}</span></div>
<div class="perf-chart" id="perf-chart-share"></div>
</div>
</div>
<!-- ── 월 누적 · 연간 누적 ── -->
<div class="perf-grid2">
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">{{ month.label }} 쇼핑몰별 누적 실적</h2></div>
<div class="erp-table-wrap">
<table class="perf-table">
<thead><tr><th class="perf-th-label">쇼핑몰</th><th>총매출</th><th>수수료</th><th>수수료 차감 매출</th><th>매출 비중</th></tr></thead>
<tbody>
{% for r in month.rows %}
<tr>
<th class="perf-td-label" scope="row">{{ names[r.code] }}</th>
<td class="perf-num">{{ won(r.gross) }}</td>
<td class="perf-num">{{ won(r.commission) }}</td>
<td class="perf-num">{{ won(r.net) }}</td>
<td class="perf-num perf-share">
{% if r.share is not none %}<span class="perf-bar" style="--w: {{ [r.share, 0] | max }}%"></span>{{ "%.1f" | format(r.share) }}%{% else %}<span class="perf-zero">–</span>{% endif %}
</td>
</tr>
{% endfor %}
</tbody>
<tfoot>
<tr class="perf-row-total">
<th class="perf-td-label" scope="row">합계</th>
<td class="perf-num">{{ won(month.total.gross) }}</td>
<td class="perf-num">{{ won(month.total.commission) }}</td>
<td class="perf-num">{{ won(month.total.net) }}</td>
<td class="perf-num">{% if month.total.share is not none %}100%{% else %}<span class="perf-zero">–</span>{% endif %}</td>
</tr>
</tfoot>
</table>
</div>
</div>
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">{{ year.year }}년 누적</h2></div>
<div class="perf-year-sum">
<div><span>총매출</span><b>₩{{ "{:,}".format(year.total.gross) }}</b></div>
<div><span>수수료</span><b>₩{{ "{:,}".format(year.total.commission) }}</b></div>
<div><span>수수료 차감 매출</span><b>₩{{ "{:,}".format(year.total.net) }}</b></div>
</div>
<div class="erp-table-wrap">
<table class="perf-table perf-year">
<thead><tr><th class="perf-th-label">월</th><th>총매출</th><th>수수료</th><th>수수료 차감 매출</th></tr></thead>
<tbody>
{% for r in year.rows %}
<tr class="{% if r.future %}is-future{% endif %}">
<th class="perf-td-label" scope="row">{{ r.label }}</th>
<td class="perf-num">{{ won(r.gross) }}</td>
<td class="perf-num">{{ won(r.commission) }}</td>
<td class="perf-num">{{ won(r.net) }}</td>
</tr>
{% endfor %}
</tbody>
<tfoot>
<tr class="perf-row-total">
<th class="perf-td-label" scope="row">합계</th>
<td class="perf-num">{{ won(year.total.gross) }}</td>
<td class="perf-num">{{ won(year.total.commission) }}</td>
<td class="perf-num">{{ won(year.total.net) }}</td>
</tr>
</tfoot>
</table>
</div>
</div>
</div>
<p class="perf-foot perf-muted">
매출 기준: 결제는 결제일, 취소·반품은 발생일에 반영(음수). 수수료는 그날 적용되는 쇼핑몰 수수료율로 계산하며
일·쇼핑몰 단위로 원 미만 반올림합니다. 금액을 누르면 주문 목록을 볼 수 있습니다.
</p>
</section>
<script type="application/json" id="perf-data">{{ {
"names": names,
"codes": codes,
"daily": chart_daily,
"share": chart_share,
"period_kind": period_kind,
"period_start": period.start.isoformat(),
"period_end": period.end.isoformat(),
"today": today
} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20260930zb" defer></script>{% endblock %}
@@ -0,0 +1,180 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20260930g" />{% endblock %}
{%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%}
{% block content %}
<section class="perf perf-settings" id="perf-settings">
{% include "performance/_tabs.html" %}
{% if not key_info.ok %}
<div class="perf-notice is-warn">
<b>암호화 마스터 키가 없습니다.</b> {{ key_info.message }}
— 키가 없으면 API 인증정보를 저장할 수 없습니다(수수료 설정·대시보드는 사용 가능).
</div>
{% endif %}
<div class="erp-card perf-card">
<div class="perf-card-head">
<h2 class="perf-h">쇼핑몰 설정</h2>
<span class="perf-muted">사용 · 매출 집계 · 수수료율은 바로 저장됩니다. API 인증정보는 [설정]에서 입력합니다.</span>
</div>
<div class="erp-table-wrap">
<table class="perf-table perf-set-table">
<thead>
<tr>
<th class="perf-th-label">쇼핑몰</th>
<th>사용</th>
<th>매출 집계</th>
<th>수수료율</th>
<th>API 설정</th>
<th>연결 상태</th>
<th>마지막 동기화</th>
<th></th>
</tr>
</thead>
<tbody>
{% for r in rows %}
<tr data-code="{{ r.code }}" data-name="{{ r.name }}">
<th class="perf-td-label" scope="row">{{ r.name }}</th>
<td class="perf-center">
<label class="perf-switch" title="사용 여부">
<input type="checkbox" data-field="enabled"{% if r.enabled %} checked{% endif %} /><span></span>
</label>
</td>
<td class="perf-center">
<label class="perf-switch" title="매출 집계에 포함">
<input type="checkbox" data-field="include_in_sales"{% if r.include_in_sales %} checked{% endif %} /><span></span>
</label>
</td>
<td class="perf-rate-cell">
<span class="perf-rate">{% if r.rate %}{{ r.rate }}%{% else %}<span class="perf-muted">미설정</span>{% endif %}</span>
<button type="button" class="erp-btn erp-btn-ghost erp-btn-sm" data-act="rate"
data-has-history="{{ 1 if r.rate_history else 0 }}">변경{% if r.rate_history > 1 %} · 이력 {{ r.rate_history }}{% endif %}</button>
</td>
<td>
{% if r.shared %}<span class="perf-pill">공통 연동</span>
{% elif r.configured %}<span class="perf-pill is-ok">설정완료</span>
{% else %}<span class="perf-pill">미설정</span>{% endif %}
{% if r.via_cafe24 %}<span class="perf-pill is-ok" title="카페24 마켓 통합관리로 들어온 이 쇼핑몰 주문을 카페24 수집 때 함께 반영합니다">카페24 경유</span>{% endif %}
</td>
<td>
<span class="perf-status st-{{ r.status }}"
title="마지막 연결 테스트: {{ when(r.last_test_at) }}{% if r.last_error %}&#10;최근 오류({{ when(r.last_error_at) }}): {{ r.last_error }}{% endif %}">
<i></i>{{ r.status_label }}</span>
{% if r.last_error and r.status not in ('ok', 'disabled') %}<div class="perf-err">{{ r.last_error }}</div>{% endif %}
</td>
<td class="perf-muted perf-nowrap" title="마지막 시도: {{ when(r.last_sync_at) }}">{{ when(r.last_success_sync_at) }}</td>
<td class="perf-nowrap">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-act="creds">설정</button>
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-act="test">연결 테스트</button>
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
<p class="perf-foot perf-muted">
수수료율은 <b>적용 시작일</b>부터 반영되고, 그 전 실적은 예전 요율로 계산됩니다(과거 실적이 바뀌지 않음).
상태에 마우스를 올리면 마지막 연결 테스트 시각과 최근 오류를 볼 수 있습니다.
</p>
</div>
<div class="perf-grid2">
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">인증정보 암호화</h2></div>
<dl class="perf-dl">
<dt>마스터 키</dt>
<dd>{% if key_info.ok %}<span class="perf-pill is-ok">설정됨 · 현재 v{{ key_info.current_version }}</span>
{% set olds = key_info.versions | reject('equalto', key_info.current_version) | list %}
{% if olds %}<span class="perf-muted">(예전 키 v{{ olds | join(', v') }} 보관 중)</span>{% endif %}
{% else %}<span class="perf-pill is-bad">미설정</span>{% endif %}</dd>
<dt>저장된 항목</dt>
<dd>{% for v, n in key_versions_in_use.items() %}v{{ v }}: {{ n }}개{% if not loop.last %}, {% endif %}{% else %}<span class="perf-muted">없음</span>{% endfor %}</dd>
</dl>
{% if stale_key_rows %}
<p class="perf-notice is-warn">예전 키로 암호화된 항목이 {{ stale_key_rows }}개 있습니다.
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" id="perf-rekey">현재 키로 다시 암호화</button></p>
{% endif %}
<p class="perf-foot perf-muted">
API 인증정보는 서버에서 AES-256-GCM 으로 암호화해 DB 에 저장합니다. 마스터 키(APP_ENCRYPTION_KEY)는 DB 가 아닌
서버 환경변수에만 있으며, 키를 잃으면 저장된 인증정보를 복구할 수 없으니 별도로 안전하게 보관하세요.
</p>
</div>
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">과거 매출 가져오기</h2></div>
<p class="perf-muted">[매출 업데이트]는 최근 며칠만 가져옵니다. 처음 연동했거나 빠진 기간이 있으면 기간을 지정해 한 번에
가져오세요(연동된 쇼핑몰만, 최대 366일). 같은 주문은 덮어써서 여러 번 해도 중복되지 않습니다.</p>
<div class="perf-sample-form">
<input class="erp-input perf-date" type="date" id="perf-backfill-from" value="{{ default_sample_from }}" />
<span class="perf-muted">~</span>
<input class="erp-input perf-date" type="date" id="perf-backfill-to" value="{{ default_sample_to }}" />
<button type="button" class="erp-btn erp-btn-primary" id="perf-backfill">가져오기</button>
</div>
<div class="perf-notice" id="perf-backfill-result" hidden></div>
</div>
<div class="erp-card perf-card perf-card-wide">
<div class="perf-card-head"><h2 class="perf-h">쇼핑몰 원본 데이터 확인</h2></div>
<p class="perf-muted">쇼핑몰 API 를 기간(최대 31일)으로 실제 불러, 받은 항목·금액 합계를 보여 줍니다(저장하지 않음).
쇼핑몰 관리자 화면에서 매출이 있던 날을 넣고 결과를 알려 주시면 그 항목으로 매출 수집을 맞춥니다.
이름·연락처·주소 같은 개인정보는 값을 보이지 않습니다.<br>
· <b>네이버</b>: 결제일 기준 상품주문 전체(상태별 합계 포함)와 날짜별 "현재 규칙 매출" — 스마트스토어센터 매출과 비교해 주세요.<br>
· <b>11번가</b>: 주문·클레임·정산 조회 주소별 동작 여부. 정산은 정산일 기준일 수 있어 매출이 있던 날부터 넉넉히(예: 3주).<br>
· <b>GS샵</b>: 매출 내역·배송비 내역(매출인식일 기준)의 항목별 합계 — 협력사 포털 매출 화면의 같은 기간 숫자와 비교해 주세요.</p>
<div class="perf-sample-form">
<select class="erp-input" id="perf-probe-code" aria-label="쇼핑몰">
<option value="naver">네이버 스마트스토어</option>
<option value="elevenst">11번가</option>
<option value="gsshop">GS샵</option>
</select>
<input class="erp-input perf-date" type="date" id="perf-probe-date" value="{{ default_sample_to }}" />
<span class="perf-muted">~</span>
<input class="erp-input perf-date" type="date" id="perf-probe-to" value="{{ default_sample_to }}" />
<button type="button" class="erp-btn erp-btn-outline" id="perf-probe">불러오기</button>
</div>
<div id="perf-probe-result"></div>
</div>
<div class="erp-card perf-card perf-card-wide">
<div class="perf-card-head"><h2 class="perf-h">카페24 매출 대조</h2></div>
<p class="perf-muted">카페24 관리자 → 통계 → 일별 매출내역과 같은 날짜를 비교합니다. 그날 결제 주문과 환불을 카페24 API 에서
바로 합산하며(저장하지 않음), 자체몰과 다른 마켓 연동 주문을 나눠 보여 줍니다.</p>
<div class="perf-sample-form">
<input class="erp-input perf-date" type="date" id="perf-recon-date" value="{{ default_sample_to }}" />
<button type="button" class="erp-btn erp-btn-outline" id="perf-recon">대조</button>
</div>
<div id="perf-recon-result"></div>
<h3 class="perf-h" style="margin:18px 0 6px">일별 한 번에 비교</h3>
<p class="perf-muted">카페24 일별 매출내역 표를 그대로 복사해 붙여 넣으면 날짜마다 결제합계·환불합계를 저장된 값과 비교합니다.
[API 값도 계산]을 켜면 지금 규칙으로 카페24에서 다시 계산한 값(저장 안 함)도 함께 보여 줘, 저장값만 틀린 날(다시 가져오면 해결)과
규칙이 틀린 날을 나눠 볼 수 있습니다. 날짜를 누르면 위 대조를 그날로 엽니다.</p>
<textarea class="erp-input perf-paste" id="perf-daily-paste" rows="5"
placeholder="2026-09-29(화) 47 116 2,475,300 … 2,477,800 158,000 2,319,800"></textarea>
<div class="perf-sample-form" style="margin-top:6px">
<label class="perf-muted"><input type="checkbox" id="perf-daily-live" /> API 값도 계산(느림)</label>
<button type="button" class="erp-btn erp-btn-outline" id="perf-daily-check">비교</button>
</div>
<div id="perf-daily-result"></div>
</div>
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">테스트 데이터</h2>
<span class="perf-muted">현재 {{ "{:,}".format(sample_count) }}건</span></div>
<p class="perf-muted">실제 API 연동 전 화면 확인용 모의 매출입니다(사용 중인 쇼핑몰 대상). 실제 데이터와 구분되어 한 번에 지울 수 있습니다.</p>
<div class="perf-sample-form">
<input class="erp-input perf-date" type="date" id="perf-sample-from" value="{{ default_sample_from }}" />
<span class="perf-muted">~</span>
<input class="erp-input perf-date" type="date" id="perf-sample-to" value="{{ default_sample_to }}" />
<button type="button" class="erp-btn erp-btn-outline" id="perf-sample-gen">생성</button>
<button type="button" class="erp-btn erp-btn-danger" id="perf-sample-del"{% if not sample_count %} disabled{% endif %}>모두 삭제</button>
</div>
</div>
</div>
</section>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20260930zb" defer></script>{% endblock %}
File diff suppressed because it is too large Load Diff
+151
View File
@@ -0,0 +1,151 @@
"""프로젝트 관리 — 현재 접근 권한의 공통 기준(서버).
라우터·마감 알림이 같은 규칙을 쓰도록 한 곳에 모은다. 모든 판단은 "지금" 기준이다 —
예전에 멤버였거나 담당자·멘션·협업자로 기록돼 있어도, 지금 권한이 없으면 보이지도
바꾸지도 알림을 받지도 않는다(기록 자체는 업무 이력으로 남긴다).
프로젝트
관리(=보기·작업 CRUD) : 관리자(is_admin) · 프로젝트 owner · 배정 멤버. 모두 `project` 모듈 권한이 있어야 한다.
작업
FULL : 원 소속 프로젝트를 관리할 수 있음 → 보기·수정·댓글·첨부·삭제(삭제는 추가로 생성자 규칙)
READ : 원 소속 권한은 없지만, 이 작업(또는 상위 작업)이 연결된(멀티호밍) 프로젝트를 관리할 수 있음
→ 그 작업의 상세·하위 작업 목록·댓글·첨부 보기만. 원 소속의 다른 작업·멤버는 보이지 않는다.
연결된 프로젝트 안에서의 섹션 이동(POST /links, 이미 연결된 경우)은 예전처럼 허용.
None : 권한 없음 → 403/목록에서 제외/알림·메일 대상 제외
"""
from __future__ import annotations
from typing import Any, Callable, Iterable
from . import store
FULL = "full"
READ = "read"
UserLookup = Callable[[str], "dict[str, Any] | None"]
def default_user_lookup(email: str) -> dict[str, Any] | None:
"""등록 사용자 레코드(app.main.user_store). 지연 import — 테스트는 lookup 을 직접 넘긴다."""
from app.main import user_store # noqa: WPS433
return user_store.get(store.norm_str(email, lower=True))
def _is_admin(user: dict[str, Any] | None) -> bool:
from app.store import is_admin # noqa: WPS433
return is_admin(user)
def can_use_module(user: dict[str, Any] | None) -> bool:
from app.store import has_module # noqa: WPS433
return bool(user) and has_module(user, "project")
def email_of(user: dict[str, Any] | None) -> str:
return store.norm_str((user or {}).get("email", ""), lower=True)
def can_manage_project(st: Any, user: dict[str, Any] | None, project_id: Any) -> bool:
"""프로젝트 관리(=보기·작업 CRUD) — 관리자 또는 owner/멤버. 모듈 권한이 없으면 False."""
if not can_use_module(user):
return False
if _is_admin(user):
return True
try:
pid = int(project_id)
except (TypeError, ValueError):
return False
return bool(st.is_member(project_id=pid, user_email=email_of(user)))
def visible_project_ids(st: Any, user: dict[str, Any]) -> set[int] | None:
"""관리할 수 있는 프로젝트 id 집합. 관리자는 None(=전체)."""
if _is_admin(user):
return None
if not can_use_module(user):
return set()
return {
int(p["id"]) for p in st.list_projects(include_archived=True, member_email=email_of(user))
}
def task_access(st: Any, user: dict[str, Any] | None, task: dict[str, Any] | None) -> str | None:
"""작업 하나에 대한 지금 권한: FULL / READ / None."""
if not task or not can_use_module(user):
return None
if can_manage_project(st, user, task.get("project_id")):
return FULL
for pid in link_scope(st, [int(task["id"])]).get(int(task["id"]), set()):
if can_manage_project(st, user, pid):
return READ
return None
def link_scope(st: Any, task_ids: Iterable[int]) -> dict[int, set[int]]:
"""작업 id → 이 작업 또는 상위 작업이 연결된 프로젝트 id 들. 연결 표가 없으면 빈 값."""
ids = [int(i) for i in task_ids]
if not ids:
return {}
try:
return st.task_link_scope(task_ids=ids)
except Exception: # noqa: BLE001 - 003 미적용(연결 기능 없음) → 연결로 보이는 작업 없음
return {}
def filter_visible_tasks(st: Any, user: dict[str, Any], tasks: list[dict[str, Any]],
*, key: str = "id") -> list[dict[str, Any]]:
"""목록에서 지금 볼 수 있는(FULL 또는 READ) 작업만 남긴다 — 내 작업·수신함·알림 공용."""
allowed = visible_project_ids(st, user)
if allowed is None:
return list(tasks)
ids = [int(t[key]) for t in tasks if t.get(key) is not None]
scope = link_scope(st, ids)
out = []
for t in tasks:
tid = t.get(key)
pid = t.get("project_id")
if pid is not None and int(pid) in allowed:
out.append(t)
elif tid is not None and scope.get(int(tid), set()) & allowed:
out.append(t)
return out
def email_task_access(st: Any, email: str, task: dict[str, Any],
lookup: UserLookup | None = None) -> str | None:
"""이메일(알림·멘션 대상)이 지금 이 작업을 볼 수 있는지. 등록 안 된 사람·모듈 권한 없는 사람은 None."""
rec = (lookup or default_user_lookup)(email)
if not rec:
return None
rec = {**rec, "email": rec.get("email") or email}
return task_access(st, rec, task)
def filter_recipients(st: Any, task: dict[str, Any], emails: Iterable[str],
lookup: UserLookup | None = None) -> list[str]:
"""알림·메일·멘션 대상 중 지금 이 작업을 볼 수 있는 사람만(순서 유지, 중복 제거)."""
out: list[str] = []
seen: set[str] = set()
for e in emails:
em = store.norm_str(e, lower=True)
if not em or em in seen:
continue
seen.add(em)
if email_task_access(st, em, task, lookup) is not None:
out.append(em)
return out
def can_assign(st: Any, email: str, project_id: Any, lookup: UserLookup | None = None) -> bool:
"""담당자·소유자 후보 — 등록된 사용자이고 project 모듈 권한이 있으며, 그 프로젝트를
관리할 수 있어야 한다(관리자 포함). 권한 없는 사람에게 작업 정보가 담긴 알림이 가지 않게."""
rec = (lookup or default_user_lookup)(email)
if not rec:
return False
rec = {**rec, "email": rec.get("email") or email}
return can_manage_project(st, rec, project_id)
+137 -5
View File
@@ -100,6 +100,7 @@ class ProjectStore:
ic = store.validate_project_icon(icon) ic = store.validate_project_icon(icon)
sd = store.validate_date(start_date) sd = store.validate_date(start_date)
dd = store.validate_date(due_date) dd = store.validate_date(due_date)
store.validate_date_range(sd, dd)
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
if parent_id is not None: if parent_id is not None:
@@ -158,15 +159,26 @@ class ProjectStore:
} }
sets: list[str] = [] sets: list[str] = []
params: list[Any] = [] params: list[Any] = []
clean: dict[str, Any] = {}
for key, fn in allowed.items(): for key, fn in allowed.items():
if key in fields: if key in fields:
clean[key] = fn(fields[key])
sets.append(f"{key} = %s") sets.append(f"{key} = %s")
params.append(fn(fields[key])) params.append(clean[key])
if not sets: if not sets:
existing = self.get_project(project_id=project_id) existing = self.get_project(project_id=project_id)
if existing is None: if existing is None:
raise KeyError(project_id) raise KeyError(project_id)
return existing return existing
if "start_date" in clean or "due_date" in clean:
# 한쪽만 바꿔도 기존 값과 합친 최종 상태로 검사한다.
existing = self.get_project(project_id=project_id)
if existing is None:
raise KeyError(project_id)
store.validate_date_range(
clean["start_date"] if "start_date" in clean else existing.get("start_date"),
clean["due_date"] if "due_date" in clean else existing.get("due_date"),
)
params.append(project_id) params.append(project_id)
with self._pool.connection() as conn: with self._pool.connection() as conn:
row = conn.execute( row = conn.execute(
@@ -605,7 +617,9 @@ class ProjectStore:
dd = store.validate_date(due_date) dd = store.validate_date(due_date)
sti = store.validate_time(start_time) sti = store.validate_time(start_time)
dti = store.validate_time(due_time) dti = store.validate_time(due_time)
store.validate_date_range(sd, dd, sti, dti)
assignee = store.norm_str(assignee_email, lower=True) assignee = store.norm_str(assignee_email, lower=True)
done_at = None
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
if parent_task_id is not None: if parent_task_id is not None:
@@ -636,6 +650,13 @@ class ProjectStore:
# 세션이 없어 해당 없음). # 세션이 없어 해당 없음).
if not assignee and stage_id is not None: if not assignee and stage_id is not None:
assignee, assignee_name = self._stage_default_assignee(conn, stage_id, project_id) assignee, assignee_name = self._stage_default_assignee(conn, stage_id, project_id)
# 완료 섹션에 바로 만든 작업은 완료 섹션으로 옮긴 것과 같이 완료 처리(완료 시각·이력).
if stage_id is not None:
done_row = conn.execute(
"SELECT is_done_stage FROM project_stages WHERE id = %s", (stage_id,)
).fetchone()
if done_row and done_row["is_done_stage"]:
done_at = now_kst()
nxt = conn.execute( nxt = conn.execute(
"SELECT COALESCE(MAX(sort_order), -1) + 1 AS n FROM tasks " "SELECT COALESCE(MAX(sort_order), -1) + 1 AS n FROM tasks "
"WHERE project_id = %s", "WHERE project_id = %s",
@@ -646,21 +667,26 @@ class ProjectStore:
INSERT INTO tasks INSERT INTO tasks
(project_id, stage_id, parent_task_id, title, description, (project_id, stage_id, parent_task_id, title, description,
assignee_email, assignee_name, priority, start_date, due_date, assignee_email, assignee_name, priority, start_date, due_date,
start_time, due_time, sort_order, created_by) start_time, due_time, sort_order, created_by, completed_at)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
RETURNING * RETURNING *
""", """,
( (
project_id, stage_id, parent_task_id, ttl, store.norm_str(description), project_id, stage_id, parent_task_id, ttl, store.norm_str(description),
assignee, store.norm_str(assignee_name), pr, sd, dd, assignee, store.norm_str(assignee_name), pr, sd, dd,
sti, dti, int(nxt["n"]), store.norm_str(created_by, lower=True), sti, dti, int(nxt["n"]), store.norm_str(created_by, lower=True), done_at,
), ),
).fetchone() ).fetchone()
if assignee: if assignee:
self._log(conn, project_id=project_id, task_id=row["id"], self._log(conn, project_id=project_id, task_id=row["id"],
actor=created_by, action=store.ACTION_ASSIGNED, actor=created_by, action=store.ACTION_ASSIGNED,
detail=f"{ttl} → {assignee}") detail=f"{ttl} → {assignee}")
return self.get_task(task_id=row["id"]) if done_at is not None:
self._log(conn, project_id=project_id, task_id=row["id"],
actor=created_by, action=store.ACTION_COMPLETED, detail=ttl)
out = self.get_task(task_id=row["id"])
out["_newly_completed"] = done_at is not None
return out
def move_subtask( def move_subtask(
self, *, task_id: int, parent_task_id: int, actor: str = "" self, *, task_id: int, parent_task_id: int, actor: str = ""
@@ -806,6 +832,15 @@ class ProjectStore:
if not sets: if not sets:
return {**prev, "_newly_assigned": None, "_newly_completed": False} return {**prev, "_newly_assigned": None, "_newly_completed": False}
# 날짜 범위 — 한쪽만 바꾸거나 지워도 기존 값과 합친 최종 상태로 검사.
if any(k in fields for k in ("start_date", "due_date", "start_time", "due_time")):
def final(key: str, fn: Any) -> Any:
return fn(fields[key]) if key in fields else prev.get(key)
store.validate_date_range(
final("start_date", store.validate_date), final("due_date", store.validate_date),
final("start_time", store.validate_time), final("due_time", store.validate_time),
)
params.append(task_id) params.append(task_id)
with self._pool.connection() as conn: with self._pool.connection() as conn:
with conn.transaction(): with conn.transaction():
@@ -1217,6 +1252,51 @@ class ProjectStore:
).fetchone() ).fetchone()
return self._serialize(row) return self._serialize(row)
def add_comment_with_attachments(
self, *, task_id: int, author_email: str, author_name: str, body: str,
files: list[dict[str, Any]], parent_id: int | None = None,
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
"""댓글과 첨부를 한 트랜잭션에 — 둘 중 하나라도 실패하면 아무것도 남지 않는다
(첨부 없이 빈 댓글만 남던 문제). files = [{filename, stored_name, content_type, size_bytes}].
본문이 비어도 되지만 첨부가 한 개 이상 있어야 한다."""
text = store.norm_str(body)
if not files and not text:
raise ValueError("댓글 내용이 비었습니다.")
author = store.norm_str(author_email, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
root = None
if parent_id:
p = conn.execute(
"SELECT id, task_id, parent_id FROM task_comments WHERE id = %s", (parent_id,)
).fetchone()
if not p or int(p["task_id"]) != int(task_id):
raise ValueError("답글을 달 댓글을 찾을 수 없습니다.")
root = int(p["parent_id"] or p["id"])
if root is not None:
row = conn.execute(
"INSERT INTO task_comments (task_id, author_email, author_name, body, parent_id) "
"VALUES (%s,%s,%s,%s,%s) RETURNING *",
(task_id, author, store.norm_str(author_name), text, root),
).fetchone()
else:
row = conn.execute(
"INSERT INTO task_comments (task_id, author_email, author_name, body) "
"VALUES (%s,%s,%s,%s) RETURNING *",
(task_id, author, store.norm_str(author_name), text),
).fetchone()
atts = []
for f in files:
atts.append(conn.execute(
"INSERT INTO task_attachments "
"(task_id, filename, stored_name, content_type, size_bytes, uploaded_by, comment_id) "
"VALUES (%s,%s,%s,%s,%s,%s,%s) RETURNING *",
(task_id, store.norm_str(f["filename"]), f["stored_name"],
store.norm_str(f.get("content_type") or "application/octet-stream"),
int(f["size_bytes"]), author, row["id"]),
).fetchone())
return self._serialize(row), [self._serialize(a) for a in atts]
def update_comment( def update_comment(
self, *, comment_id: int, requester: str, is_admin: bool, body: str self, *, comment_id: int, requester: str, is_admin: bool, body: str
) -> dict[str, Any]: ) -> dict[str, Any]:
@@ -1655,6 +1735,58 @@ class ProjectStore:
).fetchall() ).fetchall()
return [self._serialize(r) for r in rows] return [self._serialize(r) for r in rows]
def add_reminder_notification(
self, *, task_id: int, kind: str, due_date: str, recipient_email: str,
project_id: int | None, title: str, body: str,
) -> bool:
"""마감 알림 발송 기록 + 수신함 알림을 한 트랜잭션에. 처음이면 둘 다 넣고 True,
이미 보냈으면(UNIQUE) False. 알림 생성이 실패하면 발송 기록도 되돌려져 다음 실행에서
다시 시도된다(예전엔 기록만 남아 영영 안 갔다). 동시에 두 번 돌아도 UNIQUE 로 한 번만."""
rcpt = store.norm_str(recipient_email, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
row = conn.execute(
"INSERT INTO task_reminders (task_id, kind, due_date, recipient_email) "
"VALUES (%s,%s,%s,%s) ON CONFLICT DO NOTHING RETURNING id",
(task_id, kind, due_date, rcpt),
).fetchone()
if row is None:
return False
conn.execute(
"INSERT INTO project_notifications "
"(recipient_email, actor_email, project_id, task_id, type, title, body) "
"VALUES (%s,'',%s,%s,%s,%s,%s)",
(rcpt, project_id, task_id, kind, store.norm_str(title), store.norm_str(body)),
)
return True
def task_link_scope(self, *, task_ids: list[int]) -> dict[int, set[int]]:
"""작업 id → 이 작업 또는 그 상위 작업들이 연결(멀티호밍)된 프로젝트 id 집합.
연결된 프로젝트 멤버가 그 작업(과 하위 작업)을 읽기 전용으로 볼 수 있는지 판단한다."""
ids = sorted({int(i) for i in task_ids})
if not ids:
return {}
with self._pool.connection() as conn:
rows = conn.execute(
"""
WITH RECURSIVE chain AS (
SELECT id AS task_id, id AS anc_id, parent_task_id, 0 AS depth
FROM tasks WHERE id = ANY(%s)
UNION ALL
SELECT c.task_id, t.id, t.parent_task_id, c.depth + 1
FROM chain c JOIN tasks t ON t.id = c.parent_task_id
WHERE c.depth < 20
)
SELECT c.task_id, l.project_id
FROM chain c JOIN task_project_links l ON l.task_id = c.anc_id
""",
(ids,),
).fetchall()
out: dict[int, set[int]] = {}
for r in rows:
out.setdefault(int(r["task_id"]), set()).add(int(r["project_id"]))
return out
def record_reminder( def record_reminder(
self, *, task_id: int, kind: str, due_date: str, recipient_email: str, self, *, task_id: int, kind: str, due_date: str, recipient_email: str,
) -> bool: ) -> bool:
+28 -14
View File
@@ -5,10 +5,11 @@
· due_today — 오늘 마감 · due_today — 오늘 마감
· overdue — 마감이 지남(최근 7일 이내 마감분만 — 첫 적용 때 오래된 업무가 · overdue — 마감이 지남(최근 7일 이내 마감분만 — 첫 적용 때 오래된 업무가
한꺼번에 쏟아지지 않게, 연휴로 며칠 건너뛰어도 놓치지 않게) 한꺼번에 쏟아지지 않게, 연휴로 며칠 건너뛰어도 놓치지 않게)
수신자는 담당자. 담당자가 없으면 팔로워 전원. 수신자는 담당자. 담당자가 없으면 팔로워 전원. 단, 지금 그 작업을 볼 수 있는 사람만.
중복 방지: task_reminders(업무, 종류, 마감일, 수신자) UNIQUE — 같은 알림은 한 번만 중복 방지: task_reminders(업무, 종류, 마감일, 수신자) UNIQUE — 같은 알림은 한 번만
간다(재기동·여러 번 실행해도 안전). 마감일을 바꾸면 새 마감일 기준으로 다시 알린다. 간다(재기동·여러 번 실행해도 안전). 마감일을 바꾸면 새 마감일 기준으로 다시 알린다.
발송 기록과 수신함 알림은 한 트랜잭션이라, 알림 생성이 실패하면 다음 실행에 다시 시도된다.
실행 방식: 웹 프로세스 안의 데몬 스레드(start_reminder_thread). 5분마다 깨어나 실행 방식: 웹 프로세스 안의 데몬 스레드(start_reminder_thread). 5분마다 깨어나
"오늘 아직 안 돌았고, 설정 시각이 지났고, 영업일이면" 한 번 돈다. 여러 프로세스가 "오늘 아직 안 돌았고, 설정 시각이 지났고, 영업일이면" 한 번 돈다. 여러 프로세스가
@@ -33,7 +34,7 @@ from typing import Any
from app.timezone import now_kst from app.timezone import now_kst
from . import store from . import access, store
logger = logging.getLogger("project.reminders") logger = logging.getLogger("project.reminders")
@@ -87,8 +88,18 @@ def _title_for(kind: str, task: dict[str, Any], today: date) -> str:
return f"마감 지남({(today - due).days}일): {task['title']}" return f"마감 지남({(today - due).days}일): {task['title']}"
def run_due_reminders(st: Any, *, today: date | None = None) -> dict[str, int]: def run_due_reminders(
"""한 번 실행. 새로 만든 알림 수를 종류별로 돌려준다.""" st: Any, *, today: date | None = None, lookup: access.UserLookup | None = None,
) -> dict[str, int]:
"""한 번 실행. 새로 만든 알림 수를 종류별로 돌려준다.
- 수신자는 지금 그 작업을 볼 수 있는 사람만(access.filter_recipients) — 멤버에서 빠진 담당자·
협업자, 모듈 권한이 없어진 직원에게는 수신함 알림도 메일도 가지 않는다.
- 발송 기록(task_reminders)과 수신함 알림은 한 트랜잭션(add_reminder_notification) — 알림 생성이
실패하면 기록도 되돌려져 다음 실행에서 다시 시도된다. 같은 알림은 UNIQUE 로 한 번만(동시 실행 포함).
- 보장 범위: 수신함 알림까지. 메일(PROJECT_REMINDER_EMAIL)은 알림이 새로 만들어진 것만 요약해 한 번
보내며, 메일 발송 실패는 재시도하지 않는다(수신함 알림은 이미 남아 있다).
"""
today = today or now_kst().date() today = today or now_kst().date()
start = today - timedelta(days=OVERDUE_WINDOW_DAYS) start = today - timedelta(days=OVERDUE_WINDOW_DAYS)
end = next_workday(today) end = next_workday(today)
@@ -101,22 +112,25 @@ def run_due_reminders(st: Any, *, today: date | None = None) -> dict[str, int]:
if kind is None: if kind is None:
continue continue
assignee = store.norm_str(t.get("assignee_email"), lower=True) assignee = store.norm_str(t.get("assignee_email"), lower=True)
recipients = [assignee] if assignee else store.normalize_emails(t.get("followers") or []) wanted = [assignee] if assignee else store.normalize_emails(t.get("followers") or [])
try:
recipients = access.filter_recipients(st, t, wanted, lookup)
except Exception: # noqa: BLE001 - 권한 확인이 안 되면 이번엔 보내지 않는다(다음 실행에 재시도)
logger.warning("마감 알림 수신자 확인 실패: task=%s", t["id"])
continue
for rcpt in recipients: for rcpt in recipients:
if not st.record_reminder(
task_id=t["id"], kind=kind, due_date=t["due_date"][:10], recipient_email=rcpt,
):
continue # 이미 보냄
title = _title_for(kind, t, today) title = _title_for(kind, t, today)
try: try:
st.add_notification( created = st.add_reminder_notification(
recipient_email=rcpt, actor_email="", project_id=t["project_id"], task_id=t["id"], kind=kind, due_date=t["due_date"][:10], recipient_email=rcpt,
task_id=t["id"], type=kind, title=title, project_id=t["project_id"], title=title,
body=f"{t.get('project_name') or ''} · 마감 {t['due_date'][:10]}", body=f"{t.get('project_name') or ''} · 마감 {t['due_date'][:10]}",
) )
except Exception: # noqa: BLE001 except Exception: # noqa: BLE001 - 기록도 되돌려졌으니 다음 실행에서 다시 시도
logger.warning("마감 알림 생성 실패: task=%s", t["id"]) logger.warning("마감 알림 생성 실패(다음 실행에 재시도): task=%s", t["id"])
continue continue
if not created:
continue # 이미 보냄
counts[kind] += 1 counts[kind] += 1
digest.setdefault(rcpt, []).append((title, t)) digest.setdefault(rcpt, []).append((title, t))
File diff suppressed because it is too large Load Diff
+33 -3
View File
@@ -313,6 +313,30 @@ def validate_date(d: Any) -> str | None:
return v[:10] return v[:10]
DATE_RANGE_ERROR = "시작일이 마감일보다 늦을 수 없습니다."
TIME_RANGE_ERROR = "같은 날이면 시작 시각이 마감 시각보다 늦을 수 없습니다."
def validate_date_range(
start_date: Any, due_date: Any, start_time: Any = None, due_time: Any = None
) -> None:
"""최종 상태(부분 수정이면 기존 값 + 바꾼 값)의 날짜 범위 검사 — 프로젝트·작업 공용.
둘 다 있으면 start_date <= due_date. 같은 날이고 두 시각이 모두 있으면 start_time <= due_time.
한쪽이 비어 있는 입력은 허용. 값 형식 오류는 validate_date/validate_time 이 먼저 낸다.
"""
sd = validate_date(start_date)
dd = validate_date(due_date)
if sd and dd:
if sd > dd:
raise ValueError(DATE_RANGE_ERROR)
if sd == dd:
st = validate_time(start_time)
dt = validate_time(due_time)
if st and dt and st > dt:
raise ValueError(TIME_RANGE_ERROR)
def validate_time(t: Any) -> str | None: def validate_time(t: Any) -> str | None:
"""'HH:MM' 형식만 통과(초는 버림). 빈값/None 은 None(=종일).""" """'HH:MM' 형식만 통과(초는 버림). 빈값/None 은 None(=종일)."""
v = norm_str(t) v = norm_str(t)
@@ -334,11 +358,14 @@ def validate_time(t: Any) -> str | None:
# ════════════════════════════════════════════════════════════ # ════════════════════════════════════════════════════════════
GOAL_METRICS: tuple[str, ...] = ("sales", "roas") # 매출 · 로아스 GOAL_METRICS: tuple[str, ...] = ("sales", "roas") # 매출 · 로아스
GOAL_KINDS: tuple[str, ...] = ("target", "actual") # 목표 · 실적 GOAL_KINDS: tuple[str, ...] = ("target", "actual") # 목표 · 실적
# 업무 영역 줄 배경색 — 스프레드시트처럼 연한 색만(글자는 항상 진한 색). # 업무 영역 줄 배경색 — 스프레드시트처럼 연한 색 16가지(글자는 항상 진한 색, 8칸×2줄).
# 처음 8색(상품·마케팅·컨텐츠·유통 기본색 포함)은 예전 목록 그대로 들어 있다.
# 빈 문자열 = 색 없음(흰 배경, GOAL_NO_COLOR).
GOAL_AREA_COLORS: tuple[str, ...] = ( GOAL_AREA_COLORS: tuple[str, ...] = (
"#fbe1d5", "#d9f2d0", "#d4d4d4", "#f0cdec", "#fcd9d9", "#fde4c8", "#fbe1d5", "#fff2c2", "#eef5c8", "#d9f2d0", "#c9ecd9", "#d3f0ee",
"#dbe8fb", "#fff2c2", "#e3dcfb", "#d3f0ee", "#cfeaf7", "#dbe8fb", "#e3dcfb", "#f0cdec", "#fcdcec", "#eadcd0", "#d4d4d4", "#eef0f2",
) )
GOAL_NO_COLOR = ""
# 새 연도를 만들 때 이전 연도가 없으면 이 영역으로 시작한다(이전 연도가 있으면 그 구조를 복사). # 새 연도를 만들 때 이전 연도가 없으면 이 영역으로 시작한다(이전 연도가 있으면 그 구조를 복사).
DEFAULT_GOAL_AREAS: tuple[tuple[str, str, tuple[str, ...]], ...] = ( DEFAULT_GOAL_AREAS: tuple[tuple[str, str, tuple[str, ...]], ...] = (
("상품", "#fbe1d5", ("",)), ("상품", "#fbe1d5", ("",)),
@@ -401,7 +428,10 @@ def validate_goal_row_label(label: Any) -> str:
def validate_goal_color(color: Any) -> str: def validate_goal_color(color: Any) -> str:
"""영역 색 — 16색 중 하나, 빈값/"none" 은 색 없음(""), 목록 밖은 첫 색."""
v = norm_str(color).lower() v = norm_str(color).lower()
if v in ("", "none"):
return GOAL_NO_COLOR
return v if v in GOAL_AREA_COLORS else GOAL_AREA_COLORS[0] return v if v in GOAL_AREA_COLORS else GOAL_AREA_COLORS[0]
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -66,8 +66,9 @@
data-admin="{{ 'true' if is_admin else 'false' }}"> data-admin="{{ 'true' if is_admin else 'false' }}">
<thead> <thead>
<tr> <tr>
<th class="pj-goal-c1"></th> {# 오른쪽 끝을 끌어 이름 칸 너비 조절 — 브라우저에 기억(localStorage pj_goal_col_w) #}
<th class="pj-goal-c2"></th> <th class="pj-goal-c1"><span class="pj-goal-colresize" data-col="c1" title="끌어서 너비 조절"></span></th>
<th class="pj-goal-c2"><span class="pj-goal-colresize" data-col="c2" title="끌어서 너비 조절"></span></th>
<th class="pj-goal-year-col">연간</th> <th class="pj-goal-year-col">연간</th>
{% for mo in months %}<th class="{% if mo == this_month %}is-now{% endif %}">{{ mo }}월</th>{% endfor %} {% for mo in months %}<th class="{% if mo == this_month %}is-now{% endif %}">{{ mo }}월</th>{% endfor %}
</tr> </tr>
@@ -106,7 +107,7 @@
{# ── 업무 영역 — 영역마다 tbody 하나, 배경은 영역 색 ── #} {# ── 업무 영역 — 영역마다 tbody 하나, 배경은 영역 색 ── #}
{% for area in board.areas %} {% for area in board.areas %}
<tbody class="pj-goal-area" data-area-id="{{ area.id }}" style="--goal-bg: {{ area.color }}"> <tbody class="pj-goal-area" data-area-id="{{ area.id }}" style="--goal-bg: {{ area.color or '#fff' }}">
{% for row in area.rows %} {% for row in area.rows %}
<tr data-row-id="{{ row.id }}"> <tr data-row-id="{{ row.id }}">
{% if loop.first %} {% if loop.first %}
@@ -168,5 +169,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930a" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/project-help.css?v=20260926v" /> <link rel="stylesheet" href="/static/project-help.css?v=20260926v" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -119,7 +119,9 @@
<tr><td>작업·섹션·프로젝트 삭제</td><td><b>만든 사람만</b> 지울 수 있습니다(최고 관리자는 예외).</td></tr> <tr><td>작업·섹션·프로젝트 삭제</td><td><b>만든 사람만</b> 지울 수 있습니다(최고 관리자는 예외).</td></tr>
<tr><td>댓글 고치기·지우기</td><td>댓글을 쓴 사람(또는 관리자)만.</td></tr> <tr><td>댓글 고치기·지우기</td><td>댓글을 쓴 사람(또는 관리자)만.</td></tr>
<tr><td>새 프로젝트, 프로젝트 수정·순서 바꾸기</td><td>관리자 (<span class="pjh-ui">+</span> · <span class="pjh-ui">✎</span> · <span class="pjh-ui">⣿</span> 버튼이 관리자에게만 보입니다)</td></tr> <tr><td>새 프로젝트, 프로젝트 수정·순서 바꾸기</td><td>관리자 (<span class="pjh-ui">+</span> · <span class="pjh-ui">✎</span> · <span class="pjh-ui">⣿</span> 버튼이 관리자에게만 보입니다)</td></tr>
<tr><td>멤버 배정·제외</td><td>관리자</td></tr> <tr><td>멤버 배정·제외, 프로젝트 소유자 바꾸기</td><td>관리자</td></tr>
<tr><td>다른 프로젝트에서 연결돼 온 작업</td><td>원래 프로젝트 멤버가 아니면 <b>읽기만</b> — 내용·댓글·첨부는 보이지만 고치거나 댓글을 달 수 없습니다(연결된 보드 안에서 섹션 옮기기는 됩니다).</td></tr>
<tr><td>멤버에서 빠졌을 때</td><td>그 프로젝트의 작업은 내 작업·수신함·알림·검색에서 사라지고, 예전 링크로도 열리지 않습니다. 새 알림도 오지 않습니다.</td></tr>
<tr><td>휴지통 보기·복구, 전체 멤버, 대시보드의 담당자별 차트</td><td>관리자</td></tr> <tr><td>휴지통 보기·복구, 전체 멤버, 대시보드의 담당자별 차트</td><td>관리자</td></tr>
<tr><td>목표 보기</td><td>누구나 · <b>목표 입력·연도 추가·업무 영역 편집</b>은 관리자</td></tr> <tr><td>목표 보기</td><td>누구나 · <b>목표 입력·연도 추가·업무 영역 편집</b>은 관리자</td></tr>
</table> </table>
@@ -263,7 +265,7 @@
<tr><td><span class="pjh-ui"><span class="material-symbols-outlined">link</span>공유</span></td><td>이 작업의 주소를 복사합니다. 메신저로 보내면 받은 멤버가 바로 이 작업을 엽니다.</td></tr> <tr><td><span class="pjh-ui"><span class="material-symbols-outlined">link</span>공유</span></td><td>이 작업의 주소를 복사합니다. 메신저로 보내면 받은 멤버가 바로 이 작업을 엽니다.</td></tr>
<tr><td><span class="pjh-ui">✓ 완료로 표시</span></td><td>작업을 완료합니다. 다시 누르면 <span class="pjh-ui">↩ 완료 취소</span>.</td></tr> <tr><td><span class="pjh-ui">✓ 완료로 표시</span></td><td>작업을 완료합니다. 다시 누르면 <span class="pjh-ui">↩ 완료 취소</span>.</td></tr>
<tr><td><span class="pjh-ui">삭제</span></td><td>작업을 지웁니다(만든 사람만). 하위 작업이 있으면 함께 지울지 한 번 더 묻습니다. 지운 작업은 휴지통에 3개월 보관됩니다.</td></tr> <tr><td><span class="pjh-ui">삭제</span></td><td>작업을 지웁니다(만든 사람만). 하위 작업이 있으면 함께 지울지 한 번 더 묻습니다. 지운 작업은 휴지통에 3개월 보관됩니다.</td></tr>
<tr><td><span class="pjh-ui">저장됨</span></td><td>저장 버튼이 없습니다 — 고치는 즉시 저장되고, 버튼 줄 오른쪽에 <span class="pjh-ui">저장 중…</span> → <span class="pjh-ui">✓ 저장됨</span>이 잠깐 보입니다.</td></tr> <tr><td><span class="pjh-ui">저장됨</span></td><td>저장 버튼이 없습니다 — 고치는 즉시 저장되고, 버튼 줄 오른쪽에 <span class="pjh-ui">저장 중…</span> → <span class="pjh-ui">✓ 저장됨</span>이 잠깐 보입니다. 저장이 안 되면 <span class="pjh-ui">저장 실패 · 다시 시도</span>(눌러서 다시 저장)가 뜨고, 이 상태로 창을 닫거나 다른 작업을 열면 한 번 더 저장해 본 뒤 <b>버리고 넘어갈지 / 계속 편집할지</b> 묻습니다 — 모른 채 내용이 사라지지 않습니다. 이미지를 올리는 중이면 다 올라갈 때까지 기다렸다가 넘어갑니다.</td></tr>
</table> </table>
<div class="pjh-note"><span class="material-symbols-outlined">info</span> <div class="pjh-note"><span class="material-symbols-outlined">info</span>
<div><b>실시간 저장</b> — 제목은 칸을 벗어나거나 <kbd>Enter</kbd>, 설명은 입력을 멈추고 1초쯤 뒤(또는 칸을 벗어날 때), 담당자·섹션·우선순위·마감일은 바꾸는 즉시 저장됩니다. 새 작업은 <b>제목을 쓰는 순간</b> 만들어집니다(제목 없이 닫으면 만들어지지 않습니다). 협업자 · 하위 작업 · 첨부 파일 · 다른 프로젝트 추가 · 댓글도 누르는 즉시 저장됩니다.</div></div> <div><b>실시간 저장</b> — 제목은 칸을 벗어나거나 <kbd>Enter</kbd>, 설명은 입력을 멈추고 1초쯤 뒤(또는 칸을 벗어날 때), 담당자·섹션·우선순위·마감일은 바꾸는 즉시 저장됩니다. 새 작업은 <b>제목을 쓰는 순간</b> 만들어집니다(제목 없이 닫으면 만들어지지 않습니다). 협업자 · 하위 작업 · 첨부 파일 · 다른 프로젝트 추가 · 댓글도 누르는 즉시 저장됩니다.</div></div>
@@ -301,7 +303,8 @@
</ol> </ol>
<p>작업은 하나라서 어느 보드에서 고쳐도 모두 같이 바뀝니다.</p> <p>작업은 하나라서 어느 보드에서 고쳐도 모두 같이 바뀝니다.</p>
<h3>댓글</h3> <h3>댓글</h3>
<p>작업 창 맨 아래에 항상 고정된 댓글 칸에 쓰고 <kbd>Enter</kbd>(스크롤해도 그 자리에 있습니다). 칸 오른쪽 <span class="pjh-ui">☺</span>는 이모티콘, <span class="pjh-ui">@</span>는 멤버 태그입니다. 답글은 원 댓글 아래 들여 쓰여 <span class="pjh-ui">↳</span> 표시와 함께 보입니다. 내가 쓴 댓글은 <span class="pjh-ui">✎</span>로 고치고 <span class="pjh-ui">×</span>로 지웁니다. 댓글 속 웹 주소는 링크가 됩니다.</p> <p>작업 창 맨 아래에 항상 고정된 댓글 칸에 쓰고 <kbd>Enter</kbd>(스크롤해도 그 자리에 있습니다). 칸 오른쪽 <span class="pjh-ui">☺</span>는 이모티콘, <span class="pjh-ui">@</span>는 멤버 태그입니다. 답글은 원 댓글 아래 들여 쓰여 <span class="pjh-ui">↳</span> 표시와 함께 보입니다. 내가 쓴 댓글은 <span class="pjh-ui">✎</span>로 고치고 <span class="pjh-ui">×</span>로 지웁니다. 댓글 속 웹 주소는 링크가 됩니다. 댓글에 붙인 파일은 그 댓글 아래에 보이고(파일만 보낸 댓글도), 첨부 파일 목록에는 <span class="pjh-ui">댓글</span> 표시가 붙습니다.</p>
<p>댓글 대화창에서 파일을 보낼 때 보낼 수 없는 파일(빈 파일, 20MB 초과)이 있으면 댓글을 만들지 않고 그 파일만 빨갛게 표시합니다 — 빼고 다시 보내세요. 인터넷이 끊겨도 쓴 내용과 파일은 그대로 남아 다시 보낼 수 있고, 같은 댓글이 두 번 올라가지 않습니다. @태그는 이 작업을 볼 수 있는 사람만 고를 수 있습니다. 한글을 입력하는 중(조합 중)의 <kbd>Enter</kbd>는 글자 확정만 하고 보내지 않습니다.</p>
</section> </section>
<!-- 9. 작업 창의 하위 작업 --> <!-- 9. 작업 창의 하위 작업 -->
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -104,5 +104,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930a" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -100,5 +100,5 @@
"today": {{ today | tojson }} "today": {{ today | tojson }}
} }
</script> </script>
<script src="/static/project.js?v=20260930a" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host --> <!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host -->
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<!-- 타임라인 vis-timeline — self-host --> <!-- 타임라인 vis-timeline — self-host -->
@@ -265,6 +265,11 @@
<span class="pj-t-parent-title" id="pj-t-parent-title"></span> <span class="pj-t-parent-title" id="pj-t-parent-title"></span>
</button> </button>
<textarea id="pj-t-title" class="pj-t-title-input" rows="1" placeholder="작업 제목"></textarea> <textarea id="pj-t-title" class="pj-t-title-input" rows="1" placeholder="작업 제목"></textarea>
<!-- 다른 프로젝트에서 연결돼 온 작업을 원 소속 권한 없이 열었을 때 — 보기만 된다(서버도 변경 거절). -->
<div class="pj-readonly-note" id="pj-t-readonly" hidden>
<span class="material-symbols-outlined">visibility</span>
<span>다른 프로젝트(<b id="pj-t-readonly-home"></b>)에서 연결된 작업이라 읽기만 할 수 있습니다. 변경은 원 소속 프로젝트 멤버만 할 수 있습니다.</span>
</div>
<div class="pj-modal-body"> <div class="pj-modal-body">
<div class="pj-modal-col-main"> <div class="pj-modal-col-main">
@@ -491,5 +496,5 @@
</script> </script>
<script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script> <script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script>
<script src="/static/project.js?v=20260930a" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %} {% extends "erp_base.html" %}
{% block head_extra %} {% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20260930a" /> <link rel="stylesheet" href="/static/project.css?v=20260930g" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" /> <link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %} {% endblock %}
@@ -70,5 +70,5 @@
{% include "project/_side_modals.html" %} {% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %} {% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20260930a" defer></script> <script src="/static/project.js?v=20260930g" defer></script>
{% endblock %} {% endblock %}
+5
View File
@@ -54,6 +54,11 @@
color: var(--color-callout-red, #c22b10); color: var(--color-callout-red, #c22b10);
} }
/* 성공 알림(erpAlert(msg, { tone: "ok" })) — 초록 체크 */
.erp-dialog-icon.is-ok {
color: #0f8a3a;
}
/* 확인(질문)용은 붉은 경고색 대신 차분한 검정으로 */ /* 확인(질문)용은 붉은 경고색 대신 차분한 검정으로 */
.erp-dialog-ask .erp-dialog-icon { .erp-dialog-ask .erp-dialog-icon {
color: var(--color-rich-black, #0a0a0a); color: var(--color-rich-black, #0a0a0a);
+11 -2
View File
@@ -8,6 +8,7 @@
erpConfirm("지울까요?").then(function (ok) { if (ok) ... }); erpConfirm("지울까요?").then(function (ok) { if (ok) ... });
erpAlert("실패했습니다.").then(...) erpAlert("실패했습니다.").then(...)
erpPrompt("주소를 입력하세요", "https://").then(function (v) { if (v) ... }); // 취소면 null erpPrompt("주소를 입력하세요", "https://").then(function (v) { if (v) ... }); // 취소면 null
erpAlert("저장했습니다.", { tone: "ok" }) // 성공 알림 — 경고 삼각형 대신 초록 체크
창 제목은 기본 "No.1 King ERP 프로그램". 화면마다 바꾸려면 그 화면 스크립트에서 창 제목은 기본 "No.1 King ERP 프로그램". 화면마다 바꾸려면 그 화면 스크립트에서
window.ERP_DIALOG_TITLE = "..." 를 두거나, 한 번만 options.title 로 넘긴다. window.ERP_DIALOG_TITLE = "..." 를 두거나, 한 번만 options.title 로 넘긴다.
@@ -31,6 +32,14 @@
'<circle cx="12" cy="17.1" r="1.05" fill="currentColor"/>' + '<circle cx="12" cy="17.1" r="1.05" fill="currentColor"/>' +
"</svg>"; "</svg>";
// 성공(tone: "ok") — 원 안의 체크.
var ICON_OK =
'<svg width="32" height="32" viewBox="0 0 24 24" fill="none" aria-hidden="true">' +
'<circle cx="12" cy="12" r="9.2" stroke="currentColor" stroke-width="1.6"/>' +
'<path d="m7.6 12.3 3 3 5.8-6.2" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"' +
' stroke-linejoin="round"/>' +
"</svg>";
function titleOf(options) { function titleOf(options) {
return options.title || window.ERP_DIALOG_TITLE || TITLE; return options.title || window.ERP_DIALOG_TITLE || TITLE;
} }
@@ -54,8 +63,8 @@
body.className = "erp-dialog-body"; body.className = "erp-dialog-body";
var icon = document.createElement("span"); var icon = document.createElement("span");
icon.className = "erp-dialog-icon"; icon.className = "erp-dialog-icon" + (options.tone === "ok" ? " is-ok" : "");
icon.innerHTML = ICON; icon.innerHTML = options.tone === "ok" ? ICON_OK : ICON;
var text = document.createElement("p"); var text = document.createElement("p");
text.className = "erp-dialog-message"; text.className = "erp-dialog-message";
+267
View File
@@ -0,0 +1,267 @@
/* ════════════════════════════════════════════════════
실적(쇼핑몰 통합 매출) — 정보 밀도 높은 관리자 대시보드.
기존 ERP 토큰(erp.css :root) 위에서만 쓴다. 색은 증감·상태·주말에만.
════════════════════════════════════════════════════ */
/* 색 변수 — 창(.perf-modal)은 document.body 에 붙어 .perf 밖이라 같이 정의한다 */
.perf, .perf-modal {
--perf-line: var(--color-subtle-ash);
--perf-soft: #fafafa;
--perf-up: #0f8a3a;
--perf-down: var(--color-callout-red);
--perf-sat: #1d4ed8;
--perf-sun: var(--color-callout-red);
}
.perf {
display: flex; flex-direction: column; gap: 12px;
font-variant-numeric: tabular-nums;
}
/* 공통 .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-grid2 > .perf-card-wide { grid-column: 1 / -1; } /* 표가 넓은 카드(매출 대조)는 한 줄 전체 */
.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; }
/* 날짜 열 너비 고정(210px) — 공휴일 이름이 날짜 오른쪽에 붙는다 */
.perf-main thead th.perf-th-label, .perf-main .perf-td-label { width: 210px; min-width: 210px; max-width: 210px; box-sizing: border-box; overflow: hidden; text-overflow: ellipsis; }
.perf-row-day.is-sat .perf-td-label { color: var(--perf-sat); }
.perf-row-day.is-sun .perf-td-label { color: var(--perf-sun); }
.perf-row-day.is-today .perf-td-label::after { content: "오늘"; margin-left: 6px; font-size: 10px; padding: 0 5px; border-radius: 999px; background: var(--color-deep-black); color: #fff; vertical-align: 1px; }
.perf-row-day.is-future td, .perf-row-month.is-future td, .perf-year tr.is-future td { color: #c9c9c9; }
.perf-hol { display: inline; margin-left: 6px; font-size: 11px; font-weight: 400; }
.perf-row-week th, .perf-row-week td { background: #f3f3f3; font-weight: 600; border-bottom: 1px solid var(--perf-line); }
.perf-row-week .perf-td-total { background: #e9e9e9; }
.perf-row-total th, .perf-row-total td { background: var(--color-deep-black); color: #fff; font-weight: 600; border-bottom: 0; }
.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; }
}
.perf-table tr.perf-row-match > *{background:#e7f6ec;font-weight:600}
.perf-paste { width: 100%; min-height: 96px; font-family: ui-monospace, Consolas, monospace; font-size: 12px; white-space: pre; resize: vertical; box-sizing: border-box; }
.perf-table tr.perf-row-diff > * { background: #fff7f5; }
.perf-diff-bad { color: var(--perf-down); font-weight: 600; }
.perf-diff-ok { color: #0f8a3a; }
.perf-link { background: none; border: 0; padding: 0; color: inherit; font: inherit; text-decoration: underline dotted; cursor: pointer; }
/* 주문 내역 창 — 열 제목은 가운데·굵게·150%, 창을 스크롤해도 위에 고정 */
.perf-ev-wrap { overflow: visible; }
.perf-ev-table thead th, .perf-ev-table thead th.perf-th-label {
text-align: center; font-weight: 700; font-size: 18px; color: var(--color-deep-black, #111);
position: sticky; top: -12px; z-index: 2;
}
.perf-ev-table thead th { background: var(--perf-soft, #fafafa); box-shadow: 0 1px 0 var(--perf-line, #e5e5e5); }
/* 취소 행 — 행 전체를 기울임 + 취소선 + 회색 */
.perf-ev-table tr.is-cancel td { font-style: italic; text-decoration: line-through; color: #9a9a9a; }
/* ── 매출 업데이트 진행 창 — 쇼핑몰별·전체 진행 막대(runSyncWithProgress) ── */
.perf-prog-card { width: min(640px, 100%); }
.perf-prog-row {
display: grid; grid-template-columns: 150px 1fr 44px; align-items: center; column-gap: 10px; row-gap: 3px;
padding: 9px 0; border-bottom: 1px solid var(--perf-line);
}
.perf-prog-name { font-size: 13px; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.perf-prog-bar { height: 10px; border-radius: 999px; background: #eef0f3; overflow: hidden; }
.perf-prog-bar > span {
display: block; height: 100%; border-radius: inherit; background: var(--perf-sat);
transition: width .5s ease;
}
.perf-prog-pct { font-size: 12px; text-align: right; font-variant-numeric: tabular-nums; color: var(--color-midtone-gray); }
.perf-prog-text { grid-column: 2 / -1; font-size: 12px; color: var(--color-midtone-gray); overflow-wrap: anywhere; }
.perf-prog-row.is-done .perf-prog-bar > span { background: var(--perf-up); }
.perf-prog-row.is-error .perf-prog-bar > span { background: var(--perf-down); }
.perf-prog-row.is-error .perf-prog-text { color: var(--perf-down); }
.perf-prog-row.is-skip .perf-prog-bar > span { background: #b8bec7; }
/* 진행 중인 막대에 흐르는 빗금 — 멈춘 게 아니라는 표시 */
.perf-prog-row:not(.is-done):not(.is-error):not(.is-skip) .perf-prog-bar > span {
background-image: linear-gradient(45deg, rgba(255,255,255,.22) 25%, transparent 25%, transparent 50%,
rgba(255,255,255,.22) 50%, rgba(255,255,255,.22) 75%, transparent 75%, transparent);
background-size: 16px 16px; animation: perf-prog-flow 1s linear infinite;
}
@keyframes perf-prog-flow { from { background-position: 0 0; } to { background-position: 16px 0; } }
.perf-prog-row.is-total { border-bottom: none; border-top: 2px solid var(--perf-line); margin-top: 4px; padding-top: 12px; }
.perf-prog-row.is-total .perf-prog-name { font-weight: 700; }
.perf-prog-row.is-total .perf-prog-bar { height: 14px; }
.perf-prog-row.is-total .perf-prog-pct { font-weight: 700; color: inherit; }
@media (max-width: 560px) { .perf-prog-row { grid-template-columns: 1fr 44px; } .perf-prog-name { grid-column: 1 / -1; } .perf-prog-text { grid-column: 1 / -1; } }
/* [업데이트 취소] — 창 아래 왼쪽, 빨간 글자. 끝나면 숨김 */
.perf-prog-cancel { margin-right: auto; color: var(--perf-down); border-color: currentColor; }
.perf-prog-cancel[hidden] { display: none; }
.perf-prog-cancel:disabled { opacity: .6; cursor: default; }
File diff suppressed because it is too large Load Diff
+97 -20
View File
@@ -2010,37 +2010,53 @@ html.pj-ui-scale .pj-modal-chat { max-height: calc(92vh / var(--pj-z)); }
border-collapse: separate; border-spacing: 0; table-layout: fixed; font-size: 12.5px; border-collapse: separate; border-spacing: 0; table-layout: fixed; font-size: 12.5px;
color: var(--pj-ink); background: #fff; border: 1px solid #dfe2e6; border-radius: 10px; color: var(--pj-ink); background: #fff; border: 1px solid #dfe2e6; border-radius: 10px;
} }
/* 칸 너비는 여백·테두리 포함(border-box) — 안 그러면 padding 만큼 넓어진다 */
.pj-goal-table th, .pj-goal-table td { .pj-goal-table th, .pj-goal-table td {
box-sizing: border-box;
border-right: 1px solid #e6e8eb; border-bottom: 1px solid #e6e8eb; padding: 0; vertical-align: top; border-right: 1px solid #e6e8eb; border-bottom: 1px solid #e6e8eb; padding: 0; vertical-align: top;
} }
.pj-goal-table tr > :last-child { border-right: none; } .pj-goal-table tr > :last-child { border-right: none; }
.pj-goal-table thead th { .pj-goal-table thead th {
position: sticky; top: 0; z-index: 3; background: #f7f8f9; height: 32px; padding: 0 10px; position: sticky; top: 0; z-index: 3; background: #f7f8f9; height: 32px; padding: 0 10px;
font-weight: 700; text-align: left; vertical-align: middle; white-space: nowrap; font-weight: 700; text-align: center; vertical-align: middle; white-space: nowrap;
} }
.pj-goal-table thead th:not(.pj-goal-c1):not(.pj-goal-c2) { width: 150px; min-width: 150px; } .pj-goal-table thead th { width: 85px; min-width: 85px; max-width: 85px; } /* 1~12월 */
.pj-goal-table thead th.pj-goal-year-col { width: 210px; min-width: 210px; } .pj-goal-table thead th.pj-goal-year-col { width: 90px; min-width: 90px; max-width: 90px; }
.pj-goal-table thead th.is-now { color: var(--pj-accent-dark); box-shadow: inset 0 -2px 0 var(--pj-accent); } .pj-goal-table thead th.is-now { color: var(--pj-accent-dark); box-shadow: inset 0 -2px 0 var(--pj-accent); }
/* 왼쪽 고정 두 칸(구분·항목) — 너비는 머리 칸 오른쪽 끝을 끌어 조절(initGoals, localStorage
pj_goal_col_w). --goal-c1-w 가 c2 의 left 도 같이 정한다. */
.pj-goal-table { --goal-c1-w: 72px; --goal-c2-w: 72px; }
.pj-goal-c1, .pj-goal-c2 { .pj-goal-c1, .pj-goal-c2 {
position: sticky; z-index: 2; width: 72px; min-width: 72px; max-width: 72px; position: sticky; z-index: 2; background: #fff; text-align: center; font-weight: 700;
background: #fff; text-align: left; font-weight: 700;
} }
.pj-goal-c1 { left: 0; } .pj-goal-c1 { left: 0; width: var(--goal-c1-w); min-width: var(--goal-c1-w); max-width: var(--goal-c1-w); }
.pj-goal-c2 { left: 72px; font-weight: 600; color: #3b4048; } .pj-goal-c2 {
.pj-goal-table thead .pj-goal-c1, .pj-goal-table thead .pj-goal-c2 { z-index: 4; } left: var(--goal-c1-w); width: var(--goal-c2-w); min-width: var(--goal-c2-w); max-width: var(--goal-c2-w);
.pj-goal-table tbody th { padding: 7px 8px; } font-weight: 600; color: #3b4048;
}
.pj-goal-table thead th.pj-goal-c1 { z-index: 4; width: var(--goal-c1-w); min-width: var(--goal-c1-w); max-width: var(--goal-c1-w); }
.pj-goal-table thead th.pj-goal-c2 { z-index: 4; width: var(--goal-c2-w); min-width: var(--goal-c2-w); max-width: var(--goal-c2-w); }
.pj-goal-colresize {
position: absolute; top: 0; right: -4px; bottom: 0; width: 8px; z-index: 5; cursor: col-resize;
}
.pj-goal-colresize::after {
content: ""; position: absolute; top: 6px; bottom: 6px; left: 3px; width: 2px; border-radius: 2px; background: transparent;
}
.pj-goal-colresize:hover::after, .pj-goal-colresize.is-dragging::after { background: var(--pj-accent); }
html.pj-goal-resizing, html.pj-goal-resizing * { cursor: col-resize !important; user-select: none !important; }
.pj-goal-table tbody th { padding: 7px 8px; vertical-align: middle; } /* 왼쪽 이름은 세로 가운데 */
/* 숫자 지표 */ /* 숫자 지표 */
.pj-goal-kpi td { height: 32px; vertical-align: middle; } .pj-goal-kpi td { height: 32px; vertical-align: middle; }
.pj-goal-kpi td.is-now { background: #faf9ff; } .pj-goal-kpi td.is-now { background: #faf9ff; }
input.pj-goal-num, span.pj-goal-num { input.pj-goal-num, span.pj-goal-num {
display: block; width: 100%; box-sizing: border-box; height: 32px; padding: 0 10px; border: none; display: block; width: 100%; box-sizing: border-box; height: 32px; padding: 0 6px; border: none;
background: transparent; font: inherit; font-variant-numeric: tabular-nums; text-align: right; line-height: 32px; background: transparent; font: inherit; font-variant-numeric: tabular-nums; text-align: right; line-height: 32px;
} }
input.pj-goal-num:focus { outline: 2px solid var(--pj-accent); outline-offset: -2px; background: #fff; } input.pj-goal-num:focus { outline: 2px solid var(--pj-accent); outline-offset: -2px; background: #fff; }
.pj-goal-sum { padding: 0 10px !important; text-align: right; font-weight: 700; background: #fafafb; .pj-goal-sum { padding: 0 6px !important; text-align: right; font-weight: 700; background: #fafafb;
font-variant-numeric: tabular-nums; } font-variant-numeric: tabular-nums; }
.pj-goal-rate { padding: 0 10px !important; text-align: right; font-weight: 700; font-variant-numeric: tabular-nums; } .pj-goal-rate { padding: 0 6px !important; text-align: right; font-weight: 700; font-variant-numeric: tabular-nums; }
.pj-goal-rate.is-good { color: #1f8a4c; } .pj-goal-rate.is-good { color: #1f8a4c; }
.pj-goal-rate.is-low { color: #c2410c; } .pj-goal-rate.is-low { color: #c2410c; }
.pj-goal-kpi tr:last-child > * { border-bottom: 2px solid #d5d9de; } .pj-goal-kpi tr:last-child > * { border-bottom: 2px solid #d5d9de; }
@@ -2050,19 +2066,27 @@ input.pj-goal-num:focus { outline: 2px solid var(--pj-accent); outline-offset: -
.pj-goal-area > tr:first-child > * { border-top: 1px solid rgba(0, 0, 0, .12); } .pj-goal-area > tr:first-child > * { border-top: 1px solid rgba(0, 0, 0, .12); }
.pj-goal-area-name { font-size: 13px; font-weight: 800 !important; } .pj-goal-area-name { font-size: 13px; font-weight: 800 !important; }
.pj-goal-area-text, .pj-goal-row-text { display: block; word-break: keep-all; overflow-wrap: anywhere; } .pj-goal-area-text, .pj-goal-row-text { display: block; word-break: keep-all; overflow-wrap: anywhere; }
.pj-goal-tools { display: flex; flex-wrap: wrap; gap: 0; margin-top: 4px; opacity: 0; transition: opacity .12s; } /* 관리자 도구(✎ 색 ↑ ↓ + ×) — 이름 칸 아래에 떠 있는 작은 막대. 자리를 차지하지 않아야
이름이 세로 가운데에 온다. 칸 안에 붙어 있어 마우스를 막대로 옮겨도 사라지지 않는다. */
.pj-goal-area-name:hover, .pj-goal-row-label:hover, .pj-goal-area-name:focus-within, .pj-goal-row-label:focus-within { z-index: 6; }
.pj-goal-tools {
position: absolute; top: calc(100% - 6px); left: 50%; transform: translateX(-50%); z-index: 7;
display: flex; flex-wrap: nowrap; gap: 1px; padding: 3px; background: #ffe3c7; border: 1px solid #f6c69a;
border-radius: 10px; box-shadow: 0 4px 12px rgba(16, 24, 40, .14); /* 파스텔 주황 */
opacity: 0; pointer-events: none; transition: opacity .12s;
}
.pj-goal-area-name:hover .pj-goal-tools, .pj-goal-row-label:hover .pj-goal-tools, .pj-goal-area-name:hover .pj-goal-tools, .pj-goal-row-label:hover .pj-goal-tools,
.pj-goal-tools:focus-within { opacity: 1; } .pj-goal-tools:focus-within { opacity: 1; pointer-events: auto; }
.pj-goal-tools .pj-icon-btn { width: 20px; height: 20px; font-size: 13px; } .pj-goal-tools .pj-icon-btn { width: 30px; height: 30px; font-size: 20px; color: #8a4b14; border-radius: 7px; }
.pj-goal-tools .pj-icon-btn .material-symbols-outlined { font-size: 15px; } .pj-goal-tools .pj-icon-btn .material-symbols-outlined { font-size: 22px; }
.pj-goal-tools .pj-icon-btn:hover { background: rgba(255, 255, 255, .7); } .pj-goal-tools .pj-icon-btn:hover { background: #ffc98f; color: #5c2e06; }
textarea.pj-goal-text { textarea.pj-goal-text {
display: block; width: 100%; box-sizing: border-box; min-height: 46px; padding: 7px 9px; border: none; display: block; width: 100%; box-sizing: border-box; min-height: 46px; padding: 6px; border: none;
background: transparent; font: inherit; line-height: 1.5; color: inherit; resize: none; overflow: hidden; background: transparent; font: inherit; line-height: 1.5; color: inherit; resize: none; overflow: hidden;
} }
textarea.pj-goal-text:focus { outline: 2px solid var(--pj-accent); outline-offset: -2px; background: rgba(255, 255, 255, .75); } textarea.pj-goal-text:focus { outline: 2px solid var(--pj-accent); outline-offset: -2px; background: rgba(255, 255, 255, .75); }
textarea.pj-goal-text::placeholder { color: rgba(0, 0, 0, .3); } textarea.pj-goal-text::placeholder { color: rgba(0, 0, 0, .3); }
.pj-goal-text-ro { min-height: 46px; padding: 7px 9px; line-height: 1.5; white-space: pre-wrap; overflow-wrap: anywhere; } .pj-goal-text-ro { min-height: 46px; padding: 6px; line-height: 1.5; white-space: pre-wrap; overflow-wrap: anywhere; }
.pj-goal-area td.is-now { box-shadow: inset 2px 0 0 rgba(123, 104, 238, .35), inset -2px 0 0 rgba(123, 104, 238, .35); } .pj-goal-area td.is-now { box-shadow: inset 2px 0 0 rgba(123, 104, 238, .35), inset -2px 0 0 rgba(123, 104, 238, .35); }
.pj-goal-texttd.pj-goal-year-col { font-weight: 600; } .pj-goal-texttd.pj-goal-year-col { font-weight: 600; }
@@ -2073,10 +2097,63 @@ textarea.pj-goal-text::placeholder { color: rgba(0, 0, 0, .3); }
/* 영역 색 고르기 팝업(body 에 붙음) */ /* 영역 색 고르기 팝업(body 에 붙음) */
.pj-goal-colorpop { .pj-goal-colorpop {
position: fixed; z-index: 1000; display: grid; grid-template-columns: repeat(4, 26px); gap: 6px; position: fixed; z-index: 1000; display: grid; grid-template-columns: repeat(8, 26px); gap: 6px;
padding: 10px; background: #fff; border: 1px solid var(--pj-border); border-radius: 10px; padding: 10px; background: #fff; border: 1px solid var(--pj-border); border-radius: 10px;
box-shadow: 0 8px 24px rgba(16, 24, 40, .16); box-shadow: 0 8px 24px rgba(16, 24, 40, .16);
} }
.pj-goal-swatch { width: 26px; height: 26px; border-radius: 6px; border: 1px solid rgba(0, 0, 0, .12); cursor: pointer; padding: 0; } .pj-goal-swatch { width: 26px; height: 26px; border-radius: 6px; border: 1px solid rgba(0, 0, 0, .12); cursor: pointer; padding: 0; }
.pj-goal-swatch:hover { transform: scale(1.08); } .pj-goal-swatch:hover { transform: scale(1.08); }
.pj-goal-swatch.is-on { outline: 2px solid var(--pj-accent); outline-offset: 1px; } .pj-goal-swatch.is-on { outline: 2px solid var(--pj-accent); outline-offset: 1px; }
/* 맨 위 "색 없음" — 한 줄 전체, 흰 칸에 빨간 사선 */
.pj-goal-swatch-none {
grid-column: 1 / -1; display: flex; align-items: center; gap: 8px; height: 28px; padding: 0 8px;
border: 1px solid var(--pj-border); border-radius: 6px; background: #fff; color: var(--pj-ink);
font-size: 12.5px; cursor: pointer;
}
.pj-goal-swatch-none:hover { background: #f6f7f8; }
.pj-goal-swatch-none.is-on { outline: 2px solid var(--pj-accent); outline-offset: 1px; }
.pj-goal-swatch-x {
width: 16px; height: 16px; border: 1px solid rgba(0, 0, 0, .2); border-radius: 4px; background:
linear-gradient(to top right, transparent calc(50% - 1px), #e5484d calc(50% - 1px), #e5484d calc(50% + 1px), transparent calc(50% + 1px));
}
/* ════════════════════════════════════════════════════════════
권한·저장 안전장치(2026-09-30)
════════════════════════════════════════════════════════════ */
/* 읽기 전용 안내줄 — 다른 프로젝트에서 연결돼 온 작업(원 소속 권한 없음) */
.pj-readonly-note {
display: flex; align-items: center; gap: 6px; margin: 4px 0 8px; padding: 7px 10px;
border-radius: 8px; background: #f1f5fb; color: #34507a; font-size: 12.5px; line-height: 1.4;
}
.pj-readonly-note[hidden] { display: none; }
.pj-readonly-note .material-symbols-outlined { font-size: 17px; }
.pj-modal.is-readonly .pj-t-title-input { cursor: default; }
.pj-modal.is-readonly .pj-desc-editor { background: #fafbfc; }
.pj-subtask-row.is-readonly .pj-subtask-check,
.pj-subtask-row.is-readonly .pj-subtask-due,
.pj-subtask-row.is-readonly .pj-subtask-av { cursor: default; opacity: .7; }
/* 이 프로젝트 권한을 잃었을 때 화면 위 안내 */
.pj-access-lost {
margin: 0 0 10px; padding: 10px 14px; border-radius: 8px; background: #fdecea; color: #a1261b;
font-size: 13px; font-weight: 600;
}
.pj-access-lost a { color: inherit; text-decoration: underline; margin-left: 6px; }
/* 저장 실패 — 눌러서 다시 시도 */
.pj-autosave-state.is-retry { cursor: pointer; text-decoration: underline dotted; }
/* 작업 창 댓글의 첨부(파일만 있는 댓글도 보이게) */
.pj-comment-atts { display: flex; flex-wrap: wrap; gap: 6px; margin-top: 4px; }
.pj-comment-att { display: inline-flex; align-items: center; gap: 5px; text-decoration: none; color: var(--pj-ink); }
.pj-comment-att-file {
padding: 4px 8px; border: 1px solid var(--pj-border); border-radius: 6px; background: #fff; font-size: 12.5px;
}
.pj-comment-att-file:hover { background: #f6f7f8; }
.pj-comment-att-img img {
display: block; max-width: 160px; max-height: 120px; border-radius: 6px; border: 1px solid var(--pj-border);
object-fit: cover;
}
/* 첨부 파일 목록에서 댓글에 붙은 파일 표시 */
.pj-attach-from-comment {
margin-left: 6px; padding: 0 6px; border-radius: 999px; background: #eef0f2; color: #525860; font-size: 11px;
}
/* 댓글 대화창 — 보낼 수 없었던 파일(빈 파일·20MB 초과) */
.pj-chat-pending-chip.is-failed { border-color: #e5484d; background: #fdecea; color: #a1261b; }
+693 -146
View File
File diff suppressed because it is too large Load Diff
+1
View File
@@ -32,6 +32,7 @@ MODULE_KEYS: tuple[str, ...] = (
"dispatch", "dispatch",
"project", "project",
"cafe24", "cafe24",
"performance",
"expense_approver", "expense_approver",
"vacation_approver", "vacation_approver",
) )
+2 -2
View File
@@ -7,7 +7,7 @@
<link rel="stylesheet" href="/static/erp.css?v=20260615b" /> <link rel="stylesheet" href="/static/erp.css?v=20260615b" />
<link rel="stylesheet" href="/static/erp-shell.css?v=20260615b" /> <link rel="stylesheet" href="/static/erp-shell.css?v=20260615b" />
<link rel="stylesheet" href="/static/erp-attach-viewer.css" /> <link rel="stylesheet" href="/static/erp-attach-viewer.css" />
<link rel="stylesheet" href="/static/erp-dialog.css?v=20260928a" /> <link rel="stylesheet" href="/static/erp-dialog.css?v=20260930a" />
{% block head_extra %}{% endblock %} {% block head_extra %}{% endblock %}
</head> </head>
<body class="erp-body erp-app-body"> <body class="erp-body erp-app-body">
@@ -177,7 +177,7 @@
{# 공용 확인/경고 창. defer 를 쓰지 않는다 — 아래 {% block scripts %} 의 {# 공용 확인/경고 창. defer 를 쓰지 않는다 — 아래 {% block scripts %} 의
인라인 스크립트가 곧바로 erpConfirm/erpAlert 을 쓸 수 있어야 한다. #} 인라인 스크립트가 곧바로 erpConfirm/erpAlert 을 쓸 수 있어야 한다. #}
<script src="/static/erp-dialog.js?v=20260928a"></script> <script src="/static/erp-dialog.js?v=20260930a"></script>
<script src="/static/erp-attach-viewer.js" defer></script> <script src="/static/erp-attach-viewer.js" defer></script>
{% block scripts %}{% endblock %} {% block scripts %}{% endblock %}
</body> </body>
+6 -5
View File
@@ -306,10 +306,10 @@ code → access/refresh token 교환
cafe24_oauth_tokens 저장 cafe24_oauth_tokens 저장
``` ```
- scope 는 `app/integrations/cafe24/config.py` 의 `PRODUCT_SCOPES` = - scope 는 `app/integrations/cafe24/config.py` 의 `DEFAULT_SCOPES` =
`mall.read_product`, `mall.write_product`. `mall.read_product`, `mall.write_product`, `mall.read_order`(실적 모듈 매출 수집, 읽기만).
주문관리 추가 시 `ORDER_SCOPES` 를 합쳐 넘기고, 카페24 개발자센터 앱에서도 목록을 바꾸면 카페24 개발자센터 앱에도 그 권한이 있어야 하고(없으면 인증 거부),
권한을 추가한 뒤 **재인증**하면 된다. **재인증**해야 새 권한이 토큰에 붙는다. 재인증 전 기존 토큰은 예전 권한 그대로 계속 동작한다.
- access token 은 만료 2분 전부터 자동 갱신된다. 갱신은 토큰 행을 - access token 은 만료 2분 전부터 자동 갱신된다. 갱신은 토큰 행을
`SELECT ... FOR UPDATE` 로 잠근 채 수행 — web 컨테이너와 worker 컨테이너가 `SELECT ... FOR UPDATE` 로 잠근 채 수행 — web 컨테이너와 worker 컨테이너가
동시에 refresh 해서 한쪽 토큰이 무효화되는 것을 막는다(카페24는 refresh 동시에 refresh 해서 한쪽 토큰이 무효화되는 것을 막는다(카페24는 refresh
@@ -535,7 +535,8 @@ cafe24_oauth_tokens 저장
1. <https://developers.cafe24.com> 로그인 → 앱 생성 1. <https://developers.cafe24.com> 로그인 → 앱 생성
2. Redirect URI 를 `.env` 의 `CAFE24_REDIRECT_URI` 와 **정확히 동일하게** 등록 2. Redirect URI 를 `.env` 의 `CAFE24_REDIRECT_URI` 와 **정확히 동일하게** 등록
(운영: `https://dbx.no1king.freeddns.org/cafe24/oauth/callback`) (운영: `https://dbx.no1king.freeddns.org/cafe24/oauth/callback`)
3. 권한(Scope)에 `mall.read_product`, `mall.write_product` 체크 3. 권한(Scope)에 상품(Product) 읽기+쓰기, 주문(Order) 읽기 이상 체크
(`mall.read_product`, `mall.write_product`, `mall.read_order` — 주문은 실적 모듈이 매출 수집에 사용)
4. 발급된 Client ID / Client Secret 을 `.env` 에 기입 4. 발급된 Client ID / Client Secret 을 `.env` 에 기입
### 5-2. DB 초기화 (superuser 로 1회) ### 5-2. DB 초기화 (superuser 로 1회)
+39
View File
@@ -11,6 +11,7 @@
| `cupang_db` | 쿠팡 밀크런 출고 묶음 / 출고 라인 / 입고센터 / 박스 입수량 규칙 | | `cupang_db` | 쿠팡 밀크런 출고 묶음 / 출고 라인 / 입고센터 / 박스 입수량 규칙 |
| `malaysia_stock_db` | 말레이시아 창고 재고관리 — 창고/아이템/세트 BOM/입출고 이력/일일 재고조사 | | `malaysia_stock_db` | 말레이시아 창고 재고관리 — 창고/아이템/세트 BOM/입출고 이력/일일 재고조사 |
| `cafe24_db` | 카페24 연동 — OAuth 토큰/상품 캐시/상세페이지 버전/예약/감사·API 로그 | | `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:<APP_PWD>@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 하지 않음.
---
## 백업 / 복구 (안전 절차) ## 백업 / 복구 (안전 절차)
### 백업 ### 백업
+4
View File
@@ -120,6 +120,10 @@ docker compose down # 컨테이너 제거 (볼륨 유지)
| `VACATION_DB_URL` | 휴가 관리 DB DSN (예: `postgresql://vacation_app:<pwd>@postgres-db:5432/vacation_db`). **필수** — 미설정 시 모듈 비활성(설정 필요 안내). 권한키 `vacation`/`vacation_approver` | | `VACATION_DB_URL` | 휴가 관리 DB DSN (예: `postgresql://vacation_app:<pwd>@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` 로 지정 | | `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}/` 에 저장 | | `DATA_DIR` | 영구 데이터 경로 (Docker 볼륨 마운트). 첨부파일은 `$DATA_DIR/uploads/expense/{item_id}/` 에 저장 |
| `PERFORMANCE_DB_URL` | 실적 DB DSN (예: `postgresql://performance_app:<pwd>@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) |
--- ---
+249
View File
@@ -0,0 +1,249 @@
# 실적(쇼핑몰 통합 매출) 모듈
> `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`(연동 준비 중).
**연동 현황**: 카페24·11번가·네이버 스마트스토어·GS샵 = **구현됨**, 나머지 7개는 입력칸만 정의(수집은 `NotImplementedYet`). 쇼핑몰별 입력칸은
**연동 단계에서 공식 API 문서로 확정**한다.
### 카페24 (`adapters/cafe24.py`, 구현됨)
`auth_type="shared"` — 기존 `app/integrations/cafe24` OAuth 토큰(cafe24_db)과 클라이언트(재시도·429·토큰 자동 갱신)를
재사용한다. 토큰에 `mall.read_order` 가 있어야 한다(`DEFAULT_SCOPES` 포함, 권한 추가 후 카페24 상품관리 → 시스템에서 재연결).
**카페24 관리자 "일별 매출내역"과 같은 기준**으로 센다(처음의 품목 결제금액 방식은 배송비가 빠지고 환불 날짜 기준이 달라
화면과 맞지 않아 교체).
| 사건 | 조회 | 금액·날짜 |
|---|---|---|
| SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(실결제금액 + 적립금 + 예치금 + 네이버포인트), `initial_order_amount` + 주문 `naver_point`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) |
| CANCEL / RETURN(환불합계) | `GET /admin/refunds` `date_type=refund_date`, `status=T` | −(실제 환불액 + 적립금·예치금 환불), 환불완료일. 환불코드 R… = 반품, 그 밖 = 취소. 사건 ID = 환불코드 |
| CANCEL / RETURN(환불 목록 없는 취소·반품) | `GET /admin/orders` `date_type=cancel_date|return_complete_date`, `embed=items` — 품목 상태 C40~43/R40~43 이고 앞뒤 60일 환불 목록(완료일·접수일)에 그 주문이 없을 때 | −(판매가+옵션)×수량 − 품목 할인·쿠폰, 품목 취소일(반품은 반품완료일). 네이버페이 취소가 여기 해당 (네이버가 환불해 카페24 환불 목록에 없음). 사건 ID = `c24:{품목코드}-CL` (`unrefunded_claims`) |
- 할인 = 회원·세트상품·앱·마켓 기타·배송비 할인, 쿠폰 = 상품쿠폰 + 배송비쿠폰(`DISCOUNT_FIELDS`/`COUPON_FIELDS`).
- **기간 교체(`replace_range=True`)**: 결제·환불 모두 기간 안 날짜로 조회되므로 동기화 때 그 기간의 카페24 실데이터를 지우고
새로 넣는다(한 트랜잭션, 테스트 데이터 제외). 규칙이 바뀌어도 예전 행이 남지 않는다 → 규칙을 고친 뒤에는 같은 기간을
[과거 매출 가져오기]로 다시 받으면 된다.
- **주의 — `market_id` 는 외부 마켓만이 아니라 자체몰 주문 채널·간편결제도 담는다**(실데이터 확인 2026-09-30:
`mobile`=모바일웹, `NCHECKOUT`=네이버페이, `KAKAOPAY`=톡체크아웃). 이들은 `SELF_CHANNELS` 로 카페24 열.
대조 도구의 "주문 채널별" 표가 채널마다 자체몰 채널 / 외부 마켓 / 알 수 없는 채널(→ 카페24 열)을 보여 준다.
`MARKET_MAP` 에는 결제수단과 헷갈릴 수 있는 일반 이름(naver, kakao)을 넣지 않는다.
- **현재 `MARKET_MAP` 은 비어 있다** — 이 쇼핑몰은 카페24 마켓 통합관리를 쓰지 않는다(2026-09 사용자 확인). 카페24로 들어온
주문은 모두 카페24 열이고 설정 화면의 "카페24 경유" 표시도 나오지 않는다. 아래는 나중에 마켓 통합관리를 쓸 때의 동작.
- **마켓 연동 주문은 해당 쇼핑몰 열로**: 자체몰 채널은 카페24 열. 카페24 마켓 통합관리가 가져온
다른 마켓 주문은 `MARKET_MAP`(market_id 또는 order_place_id → 우리 쇼핑몰 코드)으로 네이버·쿠팡·11번가 등 열에 넣는다
(`SaleEvent.marketplace_code`). 연결표에 없는 마켓은 카페24 열 — **전체 합계는 항상 카페24 일별 매출내역과 같다**
(9/28 대조로 자체몰+마켓 합계가 모든 줄에서 일치 확인). 환불은 원 주문을 100건씩 조회해 같은 열로. 네이버페이는 자체몰.
- 카페24 가 만든 사건 ID 는 모두 `c24:` 접두어(`event_prefix`) — 다시 받을 때 카페24 열 + 다른 열의 `c24:` 행만 교체해
그 쇼핑몰의 **직접 연동분은 건드리지 않는다**. 어떤 쇼핑몰을 직접 API 로 연동하면 같은 주문을 두 번 받지 않도록 그 마켓을
`MARKET_MAP` 에서 빼야 한다. 설정 화면 API 설정 칸의 "카페24 경유" 표시 = 카페24 수집 때 함께 반영되는 쇼핑몰.
- 실제 market_id 값은 "카페24 매출 대조"의 마켓별 표(market_id / 주문경로 / 반영 열)로 확인하고, "(연결표 없음)"으로 나오는
마켓이 우리 쇼핑몰이면 `MARKET_MAP` 에 추가한다.
- 60일 단위 분할(한 호출 3개월 미만), orders limit 1000 / refunds limit 500 페이지. 개인정보는 저장하지 않는다.
- **카페24 매출 대조**(설정 화면, `GET /api/marketplaces/cafe24/reconcile?date=`): 그날 결제 주문·환불을 카페24 화면 열 순서대로
(주문수·품목수·상품구매금액·배송비·할인·쿠폰·결제합계·환불합계·순매출) 자체몰/다른 마켓으로 나눠 합산. 저장하지 않음.
카페24 화면과 다른 줄이 있으면 할인 항목 구성·마켓 포함 여부를 이 결과로 조정한다.
- **일별 한 번에 비교**(같은 카드, `GET /api/marketplaces/{code}/daily-check?from=&to=&live=1`, 최대 62일): 카페24 일별
매출내역 표를 붙여 넣으면(날짜 + 뒤 세 숫자 = 결제합계·환불합계·순매출, 첫 숫자 = 주문수) 날짜마다 저장값(`c24:` 사건 전체,
다른 마켓 열 포함)과 지금 API·현재 규칙으로 다시 계산한 값(`adapter.collect`, 저장 안 함)을 비교한다.
저장값만 틀림 → 예전 규칙으로 받은 것([다시 가져오기] 버튼), API 값도 틀림 → 규칙 차이(결제/환불) → 날짜 클릭으로 그날 대조.
날짜를 눌러 연 대조 표에는 붙여넣은 카페24 열(주문수·품목수·상품구매금액·배송비·할인·쿠폰·실결제·적립금·예치금·결제·환불·순매출)과
열별 차이가 같이 나온다.
- **결제합계 = 실결제금액 + 적립금 + 예치금 + 네이버포인트**(initial_order_amount 의 payment_amount·points_spent_amount·
credits_spent_amount + 주문의 naver_point). "상품구매금액 + 배송비 − 할인 − 쿠폰"은 할인 필드에 안 잡히는 차이가 있어 쓰지 않음
(2026-09-23: 카페24 1,874,738 = 1,713,128 + 10,110 + 151,500, 상품식 1,874,800). 네 값이 모두 0인 주문도 0원
(9/25 가상계좌·휴대폰 9,900 — 카페24도 0원).
- **환불 목록 없는 취소는 네이버페이(NCHECKOUT)만** 환불합계에 넣는다. 주문 전체가 취소·반품되면 배송비(− 배송비 할인·쿠폰)도
그 주문의 마지막 클레임 품목에 한 번 더한다. 톡체크아웃·자체몰의 환불 기록 없는 취소는 카페24 환불합계에 없음
(9/4: 98,700 + 네이버페이 19,900 + 배송비 3,500 = 122,100 / 9/16: 톡체크아웃 취소 9,900 제외 → 201,100).
### 11번가 (`adapters/elevenst.py`, 구현됨)
- 인증: 셀러오피스 Open API Key → 헤더 `openapikey`. **셀러 API 는 등록 IP 에서만** 호출된다(Seller API 정보 수정 →
IP 직접 입력에 운영 서버 외부 IP, 셀링툴 사방넷과 함께 사용 가능). 응답은 XML(euc-kr 선언 → 직접 디코딩).
- 없는 주소 = 500 + `-997 등록된 API 정보가 존재하지 않습니다`, 건 없음 = `-1 해당 건이 없습니다`(0건으로 처리).
- 상세 문서가 로그인 뒤에만 있어 설정 화면 **"11번가 원본 데이터 확인"**(`reconcile(day, to)`, 후보 주소별 동작·항목 합계,
개인정보 값 숨김)으로 실데이터를 보고 확정했다(2026-09-30).
- 주문 상태 목록 4개(`/rest/ordservices/complete|packaging|shipping|completed/{yyyyMMddHHmm}/{…}`)는 **지금 그 상태인 주문만**
준다. 배송완료 목록에 구매확정 주문도 남는다. 취소·반품된 주문은 목록에서 빠지고 `/rest/claimservice/canceledorders|…` 에 있다.
- SALE = **주문 하나**(`11st:{ordNo}`), 날짜 = 결제일.
- **정산된 주문**: 정산 내역(`/rest/settlement/settlementList/{yyyyMMdd}/{yyyyMMdd}`, 정산확정일 `stlDy` 기준 → 기간 뒤 45일
(오늘까지)을 더 불러 결제일 `ordStlEndDt` 로 거름)의 **판매금액합계 `selPrcAmt` 합**. 셀러오피스 "판매 상세내역"과 같고
배송비(도서산간 등)가 별도 줄로 들어 있다 — 9/10 주문 83,800 + 배송비 줄 3,000 = 86,800(주문 목록 `dlvCst` 는 0).
- **정산 전 주문**: 주문 상태 목록의 `ordAmt`(판매금액, 11번가 부담 쿠폰 전) + 배송비(`dlvCst` 최댓값 한 번). 기간 뒤 30일을 더
불러 주문일로 거른다. 정산되면 다음 업데이트 때 정산 값으로 바뀐다.
- `ordAmt − ordPayAmt` = 정산 `cupnAmt` = 11번가 부담 할인(`discount_amount`). 수수료는 판매금액 기준(34,900 × 13% = 4,537).
- `replace_range` — 기간을 통째로 다시 받아 취소·반품된 주문이 매출에서 빠진다(취소 사건을 따로 만들지 않음 → 지난 날짜
금액이 나중에 줄 수 있음). 구매자 이름·아이디·연락처는 저장하지 않는다.
### 네이버 스마트스토어 (`adapters/naver.py`, 구현됨)
- 인증: 커머스API센터 애플리케이션 ID·시크릿 → 전자서명 `client_secret_sign = base64(bcrypt.hashpw("{client_id}_{timestamp ms}",
client_secret))` → `POST https://api.commerce.naver.com/external/v1/oauth2/token`(form: client_id·timestamp·client_secret_sign·
grant_type=client_credentials·type=SELF, 판매자 ID 입력 시 type=SELLER+account_id). 토큰(약 3시간)은 `access_token`·
`access_token_expires_at`(internal, 암호화)으로 저장해 만료 5분 전까지 재사용, 401 이면 한 번 새로 받아 다시 호출.
[연결 테스트]는 입력값으로 시험하므로 항상 새 토큰. **애플리케이션의 API 호출 IP 에 운영 서버 외부 IP 등록 필요.**
의존성 `bcrypt`(requirements.txt).
- 수집: 조건형 상품 주문 상세 조회 `GET /v1/pay-order/seller/product-orders?from=&to=&rangeType=PAYED_DATETIME&pageSize=100&page=`
— 한 번에 **24시간까지**(하루씩 0시~23:59:59.999 +09:00), from 부터 180일 안 주문만(네이버 안내, GitHub discussions #1875·#2380).
응답 모양은 `data.contents[].content.{order, productOrder, …}` 로 보고 목록·`content` 유무가 달라도 받는다(`product_order_items`),
다음 쪽은 `pagination.hasNext`(없으면 100건 꽉 차면). 호출 간격 0.35초, 429 는 1·2·4초 쉬고 다시.
- **매출 규칙 = 스마트스토어센터 판매분석 "판매금액(총)"**(2026-09-30 사용자 확인): 판매분석 9/1 매출 4,455,600원 = 판매금액(총) —
할인(판매자·네이버 부담) 뒤 금액, **배송비(332,486원)는 별도**, 결제 뒤 취소·반품도 결제일에 포함하고 환불(346,340원)은 **환불일**에
따로 빼서 판매금액(순) 4,109,260원(예: 9/1 결제 0원인 상품에 환불 5건 75,040원). 주방세제 2.3L 16,640 = 17,900 − 네이버 부담 1,260.
처음 규칙(취소·반품 빼고 배송비 더함)은 4,245,300원으로 달랐다.
- SALE = 주문 하나(`naver:{orderId}`), 날짜 = 결제일(`order.paymentDate`), 금액 = 상품주문 `totalPaymentAmount` 합(배송비 제외),
할인 = `productDiscountAmount` 합. 결제 뒤 취소·반품(`CANCELED`·`RETURNED`)도 포함, 입금대기·미입금 취소만 뺀다
→ 지난 날짜 매출이 나중에 줄지 않는다. `replace_range`.
- 환불(판매금액(순))은 아직 사건으로 만들지 않는다 — 필요하면 클레임 완료일 기준 CANCEL/RETURN 을 추가.
- 설정 화면 **"쇼핑몰 원본 데이터 확인"**(네이버 선택): 결제일 기준 상품주문 전체의 항목별 합계, 상태별 합계, 날짜별
매출·그중 결제 뒤 취소/반품(참고)·배송비(참고). 개인정보(주문자·수령인·주소·연락처·메모)는 값 없이 이름만.
### GS샵 (`adapters/gsshop.py`, 구현됨)
- 문서: 협력사 포털 → 제휴 API → 개발가이드(`partners.gsshop.com/api/apiDevGuide`, 본문은 `/docs/withgs-api-docs.html` Redoc).
- 인증: 헤더 `supCd`(협력사코드) + `token` = base64(AES256(`yyyyMMddHHmmss` + 협력사코드)), 키는 제휴 API 메인 화면(로그인 후).
키 = 포털 제휴 API 메인의 **운영 KEY**(개발 KEY 아님). 문서에 암호화 모드·키를 바이트로 쓰는 법이 없어 키 변형(글자 그대로 /
16진수 풀기 / 앞 32자, `key_variants`) × 모드(CBC·IV=키 앞 16 → ECB → CBC·IV=0) 순서로 시도하고 통과한 조합을 기억.
토큰이 틀리면 **HTTP 200** + `{"result":"fail","code":"401 UNAUTHORIZED"}`. 운영 주소 `withgs-api.gsshop.com`(문서 예시
`atwithgs-api` 는 테스트용 — 두 곳 모두 응답). 입력칸 키는 처음 만든 `vendor_code`·`api_key` 그대로(라벨만 협력사코드·AES256 키).
- 매출: `GET /api/v2/settlement/out/sales/period?supCode&fromDate&toDate&pageIdx&rowsPerPage` — **매출인식일** 기준, 한 번에 10일,
쪽당 1만 건, `{data, hasMorePage, totalCount}`. 배송비는 `/shippingFee/period`. 응답 줄 항목 이름이 문서 예시에 없어
("property1") 실데이터로 확인(2026-09-30, 9/3): `saleAwareDt`·`ordNo`·`ordItemNo`·`ordType`(SALE…)·`prdNm`·`chrQty`·
`salePrice`(할인 전, 줄 합계)·`dcTotAmt`·`custChrAmt`(= salePrice − dcTotAmt, 고객 결제금액)·`supGiveAmt`(협력사 지급액).
9/3: 211,100 − 19,528 = 191,572, 지급 179,435, 배송비 내역 7,000.
- **주문일 기준 조회 API 는 없다** — 협력사 포털 주문 통계(총주문금액·주문일, 할인 후 금액: 45,900 × 85% = 39,015)와는 날짜 기준이
달라 날마다 똑같이 맞지 않는다(매출인식일 = 정산 기준).
- **매출 규칙**: 매출 내역 한 줄 = 사건(`gs:{ordNo}-{ordItemNo}-{ordType}-{saleAwareDt}`), 날짜 = 매출인식일,
금액 = **`supGiveAmt`(협력사 지급액)** = 협력사 포털 주문 통계의 금액(2026-09-30 확인: 6호세트 포털 176,715 ÷ 9 = 19,635 = API
supGiveAmt 19,635 — 판매가 23,100·고객 결제 20,330. 7호세트 45,900 × 85%, 주부체험 9,900 × 90% — 상품마다 GS 수수료율이 다름).
9/1~9/29 지급액 4,972,689 vs 포털 순주문 4,823,074 — 남는 차이는 주문일 ↔ 매출인식일·취소분. 이미 GS 수수료를 뺀 금액이라
**GS샵 수수료율은 0%**. 배송비 제외, `ordType` 이 SALE 이 아니면 RETURN 음수. `replace_range`.
원본 데이터 확인에 날짜별 현재 규칙 매출·취소/반품·배송비(참고).
### 연동 단계 체크리스트(쇼핑몰마다)
- 공식 문서로 인증 방식·호출 제한·페이지네이션·주문 상태 코드·취소/반품 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)일.
- **대시보드 [매출 업데이트]** = 지금 보고 있는 기간(오늘까지)을 `POST /api/sync {from, to}` 로 다시 가져온다
("이번달"이면 1일~오늘). 모듈 권한자는 92일까지, 더 긴 기간(올해 등, 최대 366일)은 관리자만.
- **과거 매출 가져오기**(설정 화면, 관리자): 같은 API 로 임의 기간(최대 366일). 같은 사건은 덮어써서 여러 번 해도 중복 없음.
- **진행 창**(두 버튼 공통, `runSyncWithProgress`): `POST /api/sync {…, background: true}` → 수집을 스레드로 돌리고 작업 번호를
바로 돌려줌 → 화면이 `GET /api/sync/jobs/{id}` 를 0.8초마다 불러 **쇼핑몰별 막대 + 전체 막대**를 그린다(`jobs.py`, 메모리 보관 —
uvicorn 단일 워커 기준, 서버 재시작 시 진행 정보만 사라짐). 어댑터가 `ctx.progress.plan(전체, 단위)`/`step(items=)`/`add(n)` 로
알린다 — 네이버 = 일, 11번가 = 7일 구간(정산 + 주문 상태 4개), 카페24 = 60일 구간(결제·환불·환불 없는 취소 2종, 대조 필요 시 +).
상태: 대기 → 수집 중 n/전체 · 받은 자료 → 저장 중 → 완료 n건 반영 | 실패 | 건너뜀. 수집이 없거나 인증정보가 없는 쇼핑몰은
막대에서 빼고 "건너뜀" 한 줄(전체 진행률에 안 넣음). 전체 = 막대 쇼핑몰 진행률 평균. 이미 돌고 있는 업데이트가 있으면 새로 시작하지
않고 그 진행 상황을 보여 준다(`GET /api/sync/current`). 창을 닫아도 수집은 계속된다.
- **[업데이트 취소]**(진행 창 왼쪽 아래, 시작한 사람·관리자, `POST /api/sync/jobs/{id}/cancel`): 돌고 있는 쇼핑몰은 다음 API 호출
직전(`ctx.progress.check()` → `Cancelled`)에 멈추고 **저장하지 않는다**(저장은 수집이 끝난 뒤 한 트랜잭션이라 기존 매출 그대로),
차례가 안 온 쇼핑몰은 "취소됨"으로 건너뛴다. 이미 저장이 끝난 쇼핑몰 결과는 남고, 저장 중이던 쇼핑몰은 그 저장을 끝낸다.
취소된 실행은 `perf_sync_runs` 에 failed + "업데이트 취소", 연결 상태(`perf_connection_status`)는 바꾸지 않는다.
- 카페24 **환불합계 규칙(확정, 2026-09-29 실데이터)**: 카페24 "일별 매출내역" 환불합계 = 환불 목록의 (실제 환불액 + 적립금·예치금 환불)
+ 환불 목록에 없는 취소·반품(네이버페이 등, 취소일 기준). 9/26 = 178,220 + 1,080 + 네이버페이 취소 96,500 = 275,800,
9/27 = 145,000 + 네이버페이 55,800 = 200,800 으로 일치. 대조 도구에 환불합계 후보(값 입력 시 일치 줄 강조)·환불 건별·
취소/반품 완료 품목·그날 결제 주문 중 줄어든 주문 표가 있어 규칙이 어긋나면 이것으로 다시 찾는다.
- 같은 쇼핑몰 동시 실행 금지: `perf_sync_runs` 의 `status='running'` 부분 유니크 인덱스(30분 넘은 running 은 정리).
- 쇼핑몰 하나 실패 → 그 쇼핑몰만 상태 오류(`perf_connection_status`), 나머지 계속. 대시보드는 저장된 데이터로 계속 표시하고
상단에 오류 쇼핑몰만 표시.
- 중복 방지: `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/네트워크 없이 검증한다.
+79 -7
View File
@@ -33,11 +33,13 @@
| 연결 env | `PROJECT_DB_URL` (미설정 시 "설정 필요" 안내, 앱은 죽지 않음) | | 연결 env | `PROJECT_DB_URL` (미설정 시 "설정 필요" 안내, 앱은 죽지 않음) |
| 진입 권한 | 권한키 `project` (관리자 페이지 토글로 직원별 부여, admin 자동) | | 진입 권한 | 권한키 `project` (관리자 페이지 토글로 직원별 부여, admin 자동) |
| 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) | | 멤버 배정 후보 | `project` 권한 보유 등록 사용자 자동 목록 (`GET /project/api/assignable-users`) |
| 생성 권한 | **프로젝트·섹션·작업(하위 작업 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. | | 생성 권한 | **프로젝트·섹션·작업(하위 작업 포함) 생성은 로그인해 이 모듈에 접근할 수 있는 사용자 누구나.** 프로젝트를 만든 사람은 자동으로 owner 가 되어 그 프로젝트를 관리(`_can_manage`)할 수 있다. 다른 사람을 owner 로 지정해 만드는 건 관리자만(비관리자가 `owner_email` 을 남으로 보내면 403) |
| 수정/이동 권한 | 서브프로젝트·작업·섹션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 admin(`_require_manage`) | | 소유자 변경 | **관리자만**(2026-09-30). owner 는 멤버에서 빠져도 관리 권한이 남으므로, 일반 멤버가 스스로를 owner 로 바꿔 권한 회수를 피할 수 없게 `PUT /api/projects/{id}` 의 `owner_email` 변경은 비관리자 403(같은 값은 무시). 새 owner 는 `project` 권한이 있는 등록 사용자여야 한다(아니면 400) |
| 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/섹션/작업/활동/스냅샷 API 도 멤버·owner·admin 만(`_require_manage`). 비멤버는 403. `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 작업만 돌려준다 | | 수정/이동 권한 | 서브프로젝트·작업·섹션 CRUD(이름변경·완료토글·순서변경 등) = 그 프로젝트의 배정 멤버 또는 owner 또는 admin(`_require_manage`). 작업 API 는 `_require_task(write=True)` = 원 소속 프로젝트 권한(FULL) |
| 입력 검증 | URL 의 섹션이 URL 의 프로젝트 것인지(`_stage_of_project`), 작업 생성/수정·연결 시 섹션이 그 프로젝트 것인지(`stage_in_project`), 하위 작업의 부모가 같은 프로젝트인지 확인 — 권한은 URL 의 project_id 로 보므로 이걸 안 보면 남의 프로젝트를 건드릴 수 있다 | | 조회 권한 | 프로젝트 화면(`/p/{id}`)·멤버/섹션/작업/활동/스냅샷 API 도 멤버·owner·admin 만(`_require_manage`). 비멤버는 403. `GET /api/users/tasks` 를 프로젝트 없이 부르면 내가 볼 수 있는 프로젝트의 작업만 돌려준다. 연결된(멀티호밍) 작업은 연결된 프로젝트 멤버에게 **읽기 전용**(6-10) |
| 삭제 권한 | **프로젝트·섹션·작업 모두 "만든 사람만"**(슈퍼관리자 예외, 생성자 정보 없는 과거 데이터는 admin 허용) — `_can_delete` 하나로 통일 | | 지금 권한 기준 | 모든 판단은 **지금** 권한(`app/modules/project/access.py`) — 멤버에서 빠진 사람은 예전 담당자·멘션·협업자 기록이 있어도 내 작업·수신함·알림·검색·상세·공유 링크·댓글·첨부에서 그 작업이 보이지 않고, 새 알림·메일도 받지 않는다(기록은 이력으로 남김) |
| 입력 검증 | URL 의 섹션이 URL 의 프로젝트 것인지(`_stage_of_project`), 작업 생성/수정·연결 시 섹션이 그 프로젝트 것인지(`stage_in_project`), 하위 작업의 부모가 같은 프로젝트인지 확인 — 권한은 URL 의 project_id 로 보므로 이걸 안 보면 남의 프로젝트를 건드릴 수 있다. 새 담당자는 그 프로젝트를 볼 수 있는 사람만(400). 날짜 범위(시작 ≤ 마감, 같은 날이면 시작 시각 ≤ 마감 시각)는 부분 수정도 기존 값과 합친 최종 상태로 검사(400) |
| 삭제 권한 | **프로젝트·섹션·작업 모두 "만든 사람만"**(슈퍼관리자 예외, 생성자 정보 없는 과거 데이터는 admin 허용) — `_can_delete` 하나로 통일. **그리고 지금 그 프로젝트 권한이 있어야 한다**(멤버에서 빠진 생성자는 403, DB·휴지통 변화 없음) |
| 멤버 배정 | 여전히 관리자(`is_admin`) 전용. 비관리자가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) | | 멤버 배정 | 여전히 관리자(`is_admin`) 전용. 비관리자가 "새 프로젝트" 모달을 열면 멤버 선택란은 안내 문구만 뜨고 시도하지 않는다(불필요한 403 방지) |
| 메일 알림 | `app/mail.py` (stdlib smtplib). 작업 배정/완료 시 관리자에게 발송 | | 메일 알림 | `app/mail.py` (stdlib smtplib). 작업 배정/완료 시 관리자에게 발송 |
@@ -487,11 +489,11 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
(`initGoalSide`, localStorage `pj_goal_open`, 목표 화면에선 항상 펼침). 연도 목록은 `router._goal_years_nav` (`initGoalSide`, localStorage `pj_goal_open`, 목표 화면에선 항상 펼침). 연도 목록은 `router._goal_years_nav`
(`goal_years` 최근 연도 먼저 + **올해는 항상**, 013 미적용이면 올해만) — 사이드바를 그리는 모든 화면 컨텍스트에 `goal_years`. (`goal_years` 최근 연도 먼저 + **올해는 항상**, 013 미적용이면 올해만) — 사이드바를 그리는 모든 화면 컨텍스트에 `goal_years`.
- 연도를 누르면 `/project/goals/{연도}`(`goals.html`) — 스프레드시트 같은 한 표. 머리 줄(연간·1~12월)과 왼쪽 두 칸은 고정, - 연도를 누르면 `/project/goals/{연도}`(`goals.html`) — 스프레드시트 같은 한 표. 머리 줄(연간·1~12월)과 왼쪽 두 칸은 고정,
이번 달 열 강조. 이번 달 열 강조. 월 칸 너비 85px·연간 90px(여백 포함, `box-sizing: border-box`), 머리·왼쪽 이름 가운데 정렬(왼쪽 이름은 세로도 가운데 — 관리자 도구는 칸 아래에 떠 있는 막대라 자리를 차지하지 않음). 왼쪽 이름 두 칸(구분·항목)은 머리 칸 오른쪽 끝을 끌어 너비 조절(48~320px, 더블클릭 = 72px) — 브라우저별 localStorage `pj_goal_col_w`, CSS 변수 `--goal-c1-w`·`--goal-c2-w`.
- **숫자 지표** `goal_metrics`(year·metric `sales|roas`·kind `target|actual`·month 1~12·value NUMERIC(18,2)) — - **숫자 지표** `goal_metrics`(year·metric `sales|roas`·kind `target|actual`·month 1~12·value NUMERIC(18,2)) —
매출 목표/실적/달성, 로아스 목표/실적. 매출 연간 = 월 합계, 달성률 = 실적÷목표(월별, 연간은 실적이 있는 달의 목표 합계 대비)는 매출 목표/실적/달성, 로아스 목표/실적. 매출 연간 = 월 합계, 달성률 = 실적÷목표(월별, 연간은 실적이 있는 달의 목표 합계 대비)는
화면에서 계산(저장 안 함). 매출 단위 글자는 `goal_years.sales_unit`. 화면에서 계산(저장 안 함). 매출 단위 글자는 `goal_years.sales_unit`.
- **업무 영역** `goal_areas`(연도별, 이름·색 `store.GOAL_AREA_COLORS` 8색·순서) → `goal_rows`(영역 안 줄, 최소 1줄 — 마지막 줄은 - **업무 영역** `goal_areas`(연도별, 이름·색 `store.GOAL_AREA_COLORS` 연한 16색 + 색 없음(빈 값 = 흰 배경)·순서) → `goal_rows`(영역 안 줄, 최소 1줄 — 마지막 줄은
못 지움) → `goal_cells`(row × month, **0 = 연간**, 빈 글 = 행 삭제). 영역 색이 줄 전체 배경. 못 지움) → `goal_cells`(row × month, **0 = 연간**, 빈 글 = 행 삭제). 영역 색이 줄 전체 배경.
- 권한: 조회는 `project` 권한자 전원, **입력·구조 변경은 관리자만**(`_require_admin`, 화면도 관리자에게만 입력칸·도구). - 권한: 조회는 `project` 권한자 전원, **입력·구조 변경은 관리자만**(`_require_admin`, 화면도 관리자에게만 입력칸·도구).
- 연도 추가(`POST /api/goals/years {year}`)는 가장 가까운 이전 연도(없으면 다음 연도)의 영역·줄 구조를 글 없이 복사, - 연도 추가(`POST /api/goals/years {year}`)는 가장 가까운 이전 연도(없으면 다음 연도)의 영역·줄 구조를 글 없이 복사,
@@ -507,6 +509,76 @@ description 을 항상 HTML로 취급하기 때문). 두 번 실행하면 이중
영역 색은 팝업(body 에 붙임)에서 바로 바뀜. 목표 테이블은 live-version 트리거에 넣지 않았다(입력 중 새로고침 방지). 영역 색은 팝업(body 에 붙임)에서 바로 바뀜. 목표 테이블은 live-version 트리거에 넣지 않았다(입력 중 새로고침 방지).
- 추후: 매출 실적을 실적 모듈(`performance_db`)에서 월별로 자동으로 채우기. - 추후: 매출 실적을 실적 모듈(`performance_db`)에서 월별로 자동으로 채우기.
## 6-10. 권한·저장 안전장치 (2026-09-30 점검 반영, 새 마이그레이션·환경변수 없음)
**권한 공통 기준 — `access.py`** (라우터·마감 알림이 같은 규칙)
- 프로젝트 관리 = 관리자 · owner · 배정 멤버, 모두 `project` 모듈 권한이 있어야 한다(`can_manage_project`).
- 작업 권한 `task_access`: **FULL** = 원 소속 프로젝트 관리 가능 / **READ** = 원 소속 권한은 없지만 이 작업(또는 상위 작업)이
연결된 프로젝트를 관리 가능(`task_link_scope`, 재귀 CTE) / 없음. 라우터 `_require_task(write=)` 가 FULL/READ 를 검사.
- READ 로 되는 것: 작업 상세(`access:"read"`)·하위 작업 목록·댓글 목록·첨부 목록/다운로드/미리보기·공유 링크(연결된 프로젝트
화면으로 이동). 안 되는 것: 제목·설명·담당자·완료·섹션(원 소속)·댓글/답글/반응·첨부 추가/삭제·협업자·삭제·하위 작업 변경.
이미 연결된 작업을 연결된 프로젝트 안에서 섹션 이동(`POST /links`)은 예전처럼 허용, 새 연결은 양쪽 권한. 상세의 `links` 는
내가 볼 수 있는 프로젝트만(다른 연결 프로젝트 이름도 숨김), `followers` 는 READ 면 null. 원 소속의 다른 작업·멤버는 계속 403.
- 목록·배지·알림: 내 작업(`_my_visible_tasks`/`_my_open_count`)·수신함 태그(`_safe_mentions`)·알림(`_visible_notifications`)을
지금 권한으로 거른다(FULL 또는 READ). 기존 기록은 지우지 않는다.
- 알림·메일·멘션 수신자: `filter_recipients` — 지금 그 작업을 볼 수 있는 등록 사용자만(담당자·협업자여도 권한을 잃었으면 제외).
@태그는 볼 수 없는 사람(비멤버·권한 회수·미등록 이메일)을 기록·알림·자동 협업자 등록 없이 건너뛰고 응답 `mention_skipped` 로
알려 준다(payload 에 이메일을 직접 넣어도 같음). 멘션이 권한을 만들지 않는다. 태그 후보 `GET /api/all-users?task_id=`.
- 새 담당자는 그 프로젝트를 볼 수 있는 사람만(`_check_assignee`, 400). 비우거나 예전 값 유지는 허용.
- 댓글 수정·삭제도 지금 원 소속 권한이 있어야 한다(작성자라도 멤버에서 빠지면 403). 첨부는 본인 댓글에만 붙일 수 있다.
**저장·동기화**
- 작업 창 세대(`taskGen`): 창을 열 때마다 +1. 상세·하위 작업·연결·첨부·댓글·담당자 후보·저장 결과는 요청 때 세대를 잡고, 돌아왔을
때 다르면 반영하지 않는다(A→B, A→B→A). 하위 작업·연결 블록도 자체 `ctxSeq` 로 늦은 응답을 버리고, 추가·연결은 누른 순간의
작업 id 로 보낸다. 설명 이미지 업로드는 시작한 작업·세대가 바뀌었으면 설명에 넣지 않는다(파일은 원래 작업 첨부로 남음).
- 자동 저장(`saveField`)은 성공/실패를 돌려준다. 실패한 칸은 `failedFields` 에 남고 "저장 실패 · 다시 시도"(눌러 재시도).
닫기·Esc·다른 작업 열기(`openTaskModal` → `settleBeforeLeave`)는 이미지 업로드·만들기·저장 큐가 끝나길 기다리고 실패한 칸을
한 번 더 보낸 뒤, 그래도 실패하면 "버리고 넘어가기 / 계속 편집"을 묻는다. 버리기를 고를 때만 초안을 버린다(`discardTaskEdits`).
저장 성공 뒤 화면 다시 그리기 오류는 저장 실패로 표시하지 않는다. 미저장(실패·대기·업로드 중)일 때만 페이지 이탈 경고.
- 읽기 전용 작업 창: 제목·설명·담당자·섹션·우선순위·마감일 잠금, 완료·삭제·댓글 입력·첨부 추가·서식 도구·하위 작업 추가·
연결 추가/해제 숨김, 안내줄 `#pj-t-readonly`. 댓글 대화창도 `GET /comments` 의 `access` 로 입력칸을 숨긴다.
- 실시간 동기화(`initLiveRefresh`): `observed`(서버에서 본 버전)와 `applied`(화면에 반영 성공한 버전)를 나눈다. 반영이
성공해야 applied 를 올리고, 실패하면 다음 주기(8→16→32→60초)에 같은 버전을 다시 받는다. 동기화 중엔 겹쳐 돌지 않고, 늦게 온
응답은 버린다(`syncSeq`). 프로젝트 화면은 `GET /api/projects/{id}/snapshot?scope=all` — 화면이 들고 있는 범위(볼 수 있는 모든
최상위 프로젝트의 작업·섹션·프로젝트 목록)를 통째로 바꿔 끼운다(다른 프로젝트의 생성·삭제·섹션 변경·권한 회수 반영, 멀티호밍은
`context_project_id` 별 한 행). 이 프로젝트 권한을 잃으면(403) 작업을 비우고 창을 닫고 안내줄 `.pj-access-lost`.
- 날짜: 업무 기준 "오늘" = 한국시간(`kstTodayIso`, UTC+9 고정) — 대시보드 지연 수·마감 색·오늘/내일·내 작업 필터가 브라우저
시간대와 무관하게 서버(`today_kst`)·마감 알림과 같다.
**댓글 파일** — 파일이 있는 댓글은 `POST /api/tasks/{id}/comments/files`(multipart: `files[]`·`body`·`parent_id`·`mentions`(JSON)·
`client_token`) 한 요청으로, 댓글+첨부를 한 트랜잭션(`add_comment_with_attachments`)에 만든다. 빈 파일·20MB 초과가 하나라도
있으면 아무것도 만들지 않고 400 `detail.failed=[{index,name,reason}]` → 화면은 그 파일만 빨갛게 표시하고 입력·파일을 유지.
DB 실패면 방금 쓴 파일도 지운다. 글 댓글(`POST /comments`)은 본문 필수 — 예전 `has_attachment` 플래그는 받지 않는다.
`client_token` 으로 같은 댓글의 재전송(응답 유실·연타·동시 요청)은 10분간 첫 결과를 돌려준다(웹 프로세스 메모리, 단일 워커 기준).
작업 창 댓글 목록도 댓글별 첨부(이미지 미리보기·파일명 다운로드, 이스케이프)를 보여 주고, 첨부 파일 목록엔 "댓글" 표시.
**마감 알림** — `add_reminder_notification`: 발송 기록(`task_reminders`)과 수신함 알림을 한 트랜잭션에. 알림 생성이 실패하면
기록도 되돌려져 다음 실행에서 다시 시도, 동시 실행도 UNIQUE 로 한 번만. 수신자는 지금 볼 수 있는 사람만. 보장 범위는 수신함
알림까지 — 메일(`PROJECT_REMINDER_EMAIL`)은 새로 만든 알림만 요약해 보내고 메일 실패는 재시도하지 않는다.
**완료 섹션에 바로 만든 작업** — `create_task` 가 완료 섹션이면 `completed_at`·완료 이력(1건)을 넣고, 라우터가 완료 섹션 이동과
같은 완료 알림(`_notify_completed`)을 보낸다. 섹션 없는 하위 작업·수동 완료/취소는 그대로.
**테스트** — `tests/test_project_module.py`(로컬 테스트용 PostgreSQL + FastAPI TestClient, `PROJECT_TEST_DB_URL` 가
localhost 일 때만), `tests/js/project_ui.test.js`(jsdom, `python tests/js/render_project.py` 후 실행, `PJ_TEST_TZ` 로 해외 시간대).
프런트 테스트 훅은 `window.__PJ_TEST__` 가 있을 때만 열린다.
**기존 데이터 점검(조회만 — 운영 교정은 따로 승인 후)**
```sql
-- 시작일 > 마감일(프로젝트·작업), 같은 날 시각 역전
SELECT id, name, start_date, due_date FROM projects WHERE start_date > due_date;
SELECT id, project_id, title, start_date, due_date, start_time, due_time FROM tasks
WHERE start_date > due_date OR (start_date = due_date AND start_time > due_time);
-- 본문도 첨부도 없는 빈 댓글(예전 파일 업로드 실패 흔적)
SELECT c.id, c.task_id, c.author_email, c.created_at FROM task_comments c
WHERE btrim(c.body) = '' AND NOT EXISTS (SELECT 1 FROM task_attachments a WHERE a.comment_id = c.id);
-- 완료 섹션에 있는데 미완료인 작업(예전 완료 섹션 직접 생성)
SELECT t.id, t.title FROM tasks t JOIN project_stages s ON s.id = t.stage_id
WHERE s.is_done_stage AND t.completed_at IS NULL;
```
교정안: 날짜 역전은 담당자와 확인해 한쪽을 고치고, 빈 댓글은 작성자 확인 후 삭제, 완료 섹션 미완료는 완료로 표시하거나 섹션을 옮긴다.
권한을 잃은 사람의 담당자·멘션·협업자 기록은 지우지 않아도 된다(화면·알림은 이미 지금 권한으로 거른다).
## 7. 추후 단계 ## 7. 추후 단계
작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성 · 하위 작업의 하위 작업(다단계 중첩, 작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성 · 하위 작업의 하위 작업(다단계 중첩,
+3 -1
View File
@@ -21,13 +21,14 @@
| 쿠팡 밀크런 | 쿠팡 출고 일정 관리 (`app/modules/cupang/`) — 월간 달력 / 출고 묶음(헤더+라인) / 상자 입수량 자동계산 / 로켓 매출 관리 / 엑셀 내보내기. 상품은 `itemcode_db` 읽기 전용 참조 | | 쿠팡 밀크런 | 쿠팡 출고 일정 관리 (`app/modules/cupang/`) — 월간 달력 / 출고 묶음(헤더+라인) / 상자 입수량 자동계산 / 로켓 매출 관리 / 엑셀 내보내기. 상품은 `itemcode_db` 읽기 전용 참조 |
| 휴가 (준비중) | 연차/반차/특별휴가 신청·잔여일수 관리 | | 휴가 (준비중) | 연차/반차/특별휴가 신청·잔여일수 관리 |
| 말레이시아 재고 | 말레이시아 창고 재고관리 (`app/modules/malaysia/`) — 낱개 입출고/조정, 세트 BOM, 일일 재고조사(세트 분해 자동 반영), 현재고 현황. 상품명은 `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`) ### 권한 키 (`MODULE_KEYS`)
| 키 | 종류 | 설명 | | 키 | 종류 | 설명 |
| --- | --- | --- | | --- | --- | --- |
| `corm` / `order` | 접근 | 외부 모듈 진입 | | `corm` / `order` | 접근 | 외부 모듈 진입 |
| `expense` / `vacation` / `cupang` / `malaysia` | 접근 | 내부 모듈 진입 | | `expense` / `vacation` / `cupang` / `malaysia` / `performance` | 접근 | 내부 모듈 진입 (`performance` 설정 화면·API 는 추가로 `admin` 필요) |
| `expense_approver` | 결재 | 개인경비 승인/반려/정산 | | `expense_approver` | 결재 | 개인경비 승인/반려/정산 |
| `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) | | `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) |
@@ -91,6 +92,7 @@ app/modules/<name>/
| `cupang_db` | 쿠팡 밀크런 출고/입고센터/박스규칙 (`CUPANG_DB_URL` 필수, JSON 폴백 없음) | | `cupang_db` | 쿠팡 밀크런 출고/입고센터/박스규칙 (`CUPANG_DB_URL` 필수, JSON 폴백 없음) |
| `vacation_db` | 휴가 신청/공휴일/연차잔여 (`VACATION_DB_URL` 필수, JSON 폴백 없음) | | `vacation_db` | 휴가 신청/공휴일/연차잔여 (`VACATION_DB_URL` 필수, JSON 폴백 없음) |
| `malaysia_stock_db` | 말레이시아 창고 재고/세트BOM/재고조사 (`MALAYSIA_STOCK_DB_URL` 필수, JSON 폴백 없음) | | `malaysia_stock_db` | 말레이시아 창고 재고/세트BOM/재고조사 (`MALAYSIA_STOCK_DB_URL` 필수, JSON 폴백 없음) |
| `performance_db` | 실적 — 쇼핑몰 설정/수수료 이력/인증정보(암호문)/매출 사건 (`PERFORMANCE_DB_URL` 필수, JSON 폴백 없음) |
> 신규 DB가 필요하면 **승인 요청 후** 생성하며, 이름은 `_db`로 끝낸다. 상세는 `DATABASES.md`. > 신규 DB가 필요하면 **승인 요청 후** 생성하며, 이름은 `_db`로 끝낸다. 상세는 `DATABASES.md`.
+2
View File
@@ -12,6 +12,8 @@ pdfplumber>=0.11
pillow>=10.0 pillow>=10.0
# 카페24 OAuth 토큰 암호화 저장(Fernet) — app/integrations/cafe24/crypto.py # 카페24 OAuth 토큰 암호화 저장(Fernet) — app/integrations/cafe24/crypto.py
cryptography>=42.0 cryptography>=42.0
# 네이버 커머스API 토큰 전자서명(client_secret_sign) — app/modules/performance/adapters/naver.py
bcrypt>=4.1
google-api-python-client>=2.100 google-api-python-client>=2.100
google-auth>=2.30 google-auth>=2.30
# refresh token 발급 스크립트(scripts/google_sheets_authorize.py) 전용 # refresh token 발급 스크립트(scripts/google_sheets_authorize.py) 전용
+223
View File
@@ -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:<APP_PWD>@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;
+425
View File
@@ -0,0 +1,425 @@
// 프로젝트 관리 화면(project/project.html + static/project.js) UI 회귀 테스트 — jsdom.
// 서버 응답은 가짜(fetch 대체)로, 지연·실패·순서 역전을 직접 만든다. 실제 브라우저 레이아웃·입력기는 아니다.
//
// python tests/js/render_project.py # 템플릿 렌더 → tests/js/.out/project_render.html
// npm install jsdom # (최초 1회)
// TZ=America/Los_Angeles node tests/js/project_ui.test.js # 해외 시간대 브라우저 흉내
//
// 성공하면 마지막 줄 ALL PASS, 실패하면 항목명과 종료코드 1.
// Git Bash 는 윈도우 프로그램에 TZ 를 넘기지 않아 PJ_TEST_TZ 로도 받는다(날짜 객체를 만들기 전에 설정).
if (process.env.PJ_TEST_TZ) process.env.TZ = process.env.PJ_TEST_TZ;
const fs = require("fs");
const path = require("path");
const { JSDOM } = require("jsdom");
const WATCHDOG = setTimeout(function () { console.log("TIMEOUT — 어딘가에서 멈춤"); process.exit(2); }, 90000);
const ROOT = path.join(__dirname, "..", "..");
const html = fs.readFileSync(path.join(__dirname, ".out", "project_render.html"), "utf8");
const JS = fs.readFileSync(path.join(ROOT, "app", "static", "project.js"), "utf8");
const fails = [];
function check(name, cond, extra) {
if (cond) console.log("PASS " + name);
else { console.log("FAIL " + name + (extra !== undefined ? " → " + JSON.stringify(extra) : "")); fails.push(name); }
}
function deferred() {
let resolve, reject;
const p = new Promise(function (a, b) { resolve = a; reject = b; });
return { promise: p, resolve: resolve, reject: reject };
}
function makeEnv() {
const dom = new JSDOM(html, { runScripts: "dangerously", pretendToBeVisual: true, url: "http://localhost/project/p/1" });
const w = dom.window, d = w.document;
w.__PJ_TEST__ = true;
w.HTMLCanvasElement.prototype.getContext = function () { return null; };
w.URL.createObjectURL = function () { return "blob:x"; };
w.URL.revokeObjectURL = function () {};
w.Image = function () { const self = this; Object.defineProperty(self, "src", { set: function () { setTimeout(function () { if (self.onerror) self.onerror(); }, 0); } }); };
w.console.error = function () {};
let confirmAnswer = false;
w.erpConfirm = function () { env.confirms++; return Promise.resolve(confirmAnswer); };
w.erpAlert = function (m) { env.alerts.push(m); };
w.alert = function (m) { env.alerts.push(m); };
// 8초 이상 타이머(실시간 새로고침)는 붙잡아 두고 테스트가 직접 돌린다.
const realSetTimeout = w.setTimeout.bind(w);
const slow = [];
w.setTimeout = function (fn, ms) {
if (ms >= 8000) { slow.push({ fn: fn, ms: ms }); return 999000 + slow.length; }
return realSetTimeout(fn, ms);
};
const env = {
w: w, d: d, calls: [], routes: [], slow: slow, confirms: 0, alerts: [],
setConfirm: function (v) { confirmAnswer = v; },
route: function (method, re, fn) { env.routes.unshift({ method: method, re: re, fn: fn }); },
runSlow: async function () { const t = slow.shift(); if (t) { t.fn(); await settle(); } return t; },
};
w.fetch = async function (url, opts) {
const method = (opts && opts.method) || "GET";
let body = opts && opts.body;
if (typeof body === "string") { try { body = JSON.parse(body); } catch (_) {} }
env.calls.push({ method: method, url: String(url), body: body });
if (process.env.PJ_TEST_TRACE && method === "PUT") console.log(" TRACE PUT", url, new Error().stack.split("\n").slice(2, 7).join(" | "));
for (const r of env.routes) {
if (r.method === method && r.re.test(String(url))) {
const out = await r.fn(String(url), body);
if (out === "NETWORK") throw new TypeError("Failed to fetch");
const status = out.status || 200;
return { ok: status < 400, status: status, statusText: "x", json: async function () { return out.body; } };
}
}
return { ok: true, status: 200, statusText: "OK", json: async function () { return {}; } };
};
return env;
}
function settle(n) {
return new Promise(function (r) { let i = 0; (function spin() { if (i++ >= (n || 30)) return r(); setImmediate(spin); })(); });
}
function detail(id, title, extra) {
return Object.assign({ id: id, title: title, project_id: 1, stage_id: 11, description: "", priority: "normal",
assignee_email: "", subtasks: [], links: [], followers: [], access: "full", completed_at: null }, extra || {});
}
function baseRoutes(env) {
env.route("GET", /\/project\/api\/tasks\/\d+\/attachments/, function () { return { body: { attachments: [] } }; });
env.route("GET", /\/project\/api\/tasks\/\d+\/comments/, function () { return { body: { comments: [], events: [], features: {} } }; });
env.route("GET", /\/project\/api\/projects\/\d+\/members/, function () { return { body: { members: [{ user_email: "me@test.local" }] } }; });
env.route("GET", /\/project\/api\/projects$/, function () { return { body: { projects: [] } }; });
env.route("GET", /\/project\/api\/all-users/, function () { return { body: { users: [] } }; });
env.route("GET", /\/project\/api\/live-version/, function () { return { body: { ts: "v1" } }; });
env.route("GET", /\/project\/api\/tasks\/101$/, function () { return { body: { task: detail(101, "작업 A") } }; });
env.route("GET", /\/project\/api\/tasks\/102$/, function () { return { body: { task: detail(102, "작업 B") } }; });
}
async function boot(env) {
// jsdom 이 문서를 다 읽고 DOMContentLoaded 를 보낸 뒤에 넣는다 — 먼저 넣으면 초기화가 두 번 돈다.
if (env.d.readyState === "loading") {
await new Promise(function (r) { env.d.addEventListener("DOMContentLoaded", r); });
}
// jsdom 의 <select>·일부 입력은 내부 Proxy 라 value 를 재정의(enhance*)하면 쓰기가 막힌다(실제 브라우저는
// 문제없음, 기존 코드 그대로). 테스트에서는 버튼 보강을 건너뛰고 원래 입력칸으로 시험한다.
env.d.querySelectorAll("select").forEach(function (s) { s.dataset.pjEnhanced = "1"; });
env.d.querySelectorAll("input[type=date]").forEach(function (i) { i.dataset.pjDate = "1"; });
env.w.eval(JS);
env.d.dispatchEvent(new env.w.Event("DOMContentLoaded"));
await settle();
return env.w.__pjProject;
}
function taskOf(P, id) { return P.state().tasks.find(function (t) { return t.id === id && t.context_project_id === 1; }); }
function subsText(d) { // 하위 작업 제목은 입력칸 값이다
return Array.from(d.querySelectorAll("#pj-subtask-list .pj-subtask-title")).map(function (i) { return i.value; }).join("|") ||
d.getElementById("pj-subtask-list").textContent;
}
function wait(ms) { return new Promise(function (r) { setTimeout(r, ms); }); } // 창 닫기 애니메이션(0.32초) 대기
function titleVal(d) { return d.getElementById("pj-t-title").value; }
(async function () {
// ── [05] 한국시간 기준 오늘 ─────────────────────────────
{
const env = makeEnv(); baseRoutes(env); await boot(env);
const H = env.w.__pjHelpers;
const kst = function (y, m, d, hh, mm) { return Date.UTC(y, m - 1, d, hh - 9, mm); };
check("[05] KST 00:00 → 그날", H.kstTodayIso(kst(2026, 9, 30, 0, 0)) === "2026-09-30");
check("[05] KST 08:59(UTC 전날) → 그날", H.kstTodayIso(kst(2026, 9, 30, 8, 59)) === "2026-09-30");
check("[05] KST 09:00 → 그날", H.kstTodayIso(kst(2026, 9, 30, 9, 0)) === "2026-09-30");
check("[05] KST 23:59 → 그날", H.kstTodayIso(kst(2026, 9, 30, 23, 59)) === "2026-09-30");
const realNow = env.w.Date.now;
env.w.Date.now = function () { return kst(2026, 9, 30, 8, 30); };
const y = H.dueInfo("2026-09-29", false), t = H.dueInfo("2026-09-30", false);
check("[05] 해외 시간대(" + (process.env.TZ || "기본") + ")·한국 오전에도 전날 마감=지남", y.cls === "is-overdue" && y.text === "어제", y);
check("[05] 오늘 마감은 지남이 아님", t.cls === "is-soon" && t.text === "오늘", t);
env.w.Date.now = realNow;
}
// ── [09] A→B 전환 중 늦은 A 응답이 B 를 덮지 않는다 ───────────
{
const env = makeEnv(); baseRoutes(env);
const dA = deferred();
env.route("GET", /\/project\/api\/tasks\/101$/, function () { return dA.promise; });
env.route("GET", /\/project\/api\/tasks\/102$/, function () { return { body: { task: detail(102, "작업 B", { subtasks: [{ id: 902, title: "B-sub", project_id: 1 }] }) } }; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await P.openTaskModal(taskOf(P, 102));
await settle();
dA.resolve({ body: { task: detail(101, "작업 A", { subtasks: [{ id: 901, title: "A-sub", project_id: 1 }] }) } });
await settle();
check("[09] 늦은 A 상세가 B 의 하위 작업 목록을 덮지 않음", subsText(d).includes("B-sub") && !subsText(d).includes("A-sub"), subsText(d));
env.route("POST", /\/project\/api\/projects\/1\/tasks$/, function (u, b) { return { status: 201, body: { task: detail(903, b.title, { parent_task_id: b.parent_task_id }) } }; });
d.getElementById("pj-subtask-input").value = "새 하위";
d.getElementById("pj-subtask-add").click();
await settle();
const post = env.calls.filter(function (c) { return c.method === "POST" && /projects\/1\/tasks$/.test(c.url); }).pop();
check("[09] B 화면에서 추가한 하위 작업은 B 에 붙음", post && post.body.parent_task_id === 102, post && post.body);
}
// A→B→A — 같은 작업을 다시 열어도 이전 요청은 버린다
{
const env = makeEnv(); baseRoutes(env);
const dOld = deferred(); let n = 0;
env.route("GET", /\/project\/api\/tasks\/101$/, function () {
n++;
if (n === 1) return dOld.promise;
return { body: { task: detail(101, "작업 A", { subtasks: [{ id: 911, title: "A-new", project_id: 1 }] }) } };
});
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await P.openTaskModal(taskOf(P, 102));
await P.openTaskModal(taskOf(P, 101));
await settle();
dOld.resolve({ body: { task: detail(101, "작업 A", { subtasks: [{ id: 910, title: "A-old", project_id: 1 }] }) } });
await settle();
check("[09] A→B→A 에서 첫 A 의 늦은 응답은 버림", subsText(d).includes("A-new") && !subsText(d).includes("A-old"), subsText(d));
}
// 이미지 업로드 중 A→B 전환 — 업로드가 끝나 A 설명에 들어가고 저장된 뒤에 B 가 열린다
{
const env = makeEnv(); baseRoutes(env);
const up = deferred();
env.route("POST", /\/project\/api\/tasks\/101\/attachments$/, function () { return up.promise; });
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) { return { body: { task: Object.assign(detail(101, "작업 A"), b) } }; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101));
await settle();
const box = d.getElementById("pj-t-desc");
const file = new env.w.File(["x"], "a.png", { type: "image/png" });
const ev = new env.w.Event("paste", { bubbles: true, cancelable: true });
Object.defineProperty(ev, "clipboardData", { value: { items: [{ type: "image/png", getAsFile: function () { return file; } }], getData: function () { return ""; } } });
box.dispatchEvent(ev);
await settle();
const switching = P.openTaskModal(taskOf(P, 102));
await settle();
check("[09] 업로드 중에는 B 로 넘어가지 않고 기다림", d.getElementById("pj-t-id").value === "101");
up.resolve({ status: 201, body: { attachment: { id: 55 } } });
await switching; await settle();
const put = env.calls.filter(function (c) { return c.method === "PUT" && /tasks\/101$/.test(c.url) && c.body.description; }).pop();
check("[09] 업로드된 이미지는 A 설명에 넣어 A 에 저장", !!put && put.body.description.includes("/attachments/55/inline"), put && put.body);
check("[09] 그 다음 B 가 열리고 B 설명엔 이미지 없음", d.getElementById("pj-t-id").value === "102" && !box.innerHTML.includes("/attachments/55/"));
}
// ── [10] 저장 실패 후 닫기 — 유실 없이 재시도/버리기 선택 ─────────
{
const env = makeEnv(); baseRoutes(env);
let putStatus = 500; const puts = [];
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) {
puts.push(b);
return putStatus >= 400 ? { status: putStatus, body: { detail: "서버 오류" } } : { body: { task: Object.assign(detail(101, "작업 A"), b) } };
});
const P = await boot(env); const d = env.d; const modal = d.getElementById("pj-modal-task");
await P.openTaskModal(taskOf(P, 101)); await settle();
const ta = d.getElementById("pj-t-title");
ta.value = "작업 A2"; ta.dispatchEvent(new env.w.Event("blur")); await settle();
check("[10] 실패한 칸 기록 + '저장 실패 · 다시 시도' 표시", P.state().failed.includes("title") && d.getElementById("pj-autosave-state").textContent.includes("저장 실패"), P.state().failed);
check("[10] 저장 안 된 상태면 페이지 이탈 경고 대상", P.state().unsaved === true);
env.setConfirm(false); // 계속 편집
await P.attemptClose(); await settle();
check("[10] 닫기 때 재시도해도 실패 → 묻고, '계속 편집'이면 창·입력 유지", !modal.hidden && titleVal(d) === "작업 A2" && env.confirms === 1);
putStatus = 200;
await P.attemptClose(); await settle(); await wait(400);
check("[10] 다시 닫기 → 재시도 성공 후 닫힘", modal.hidden && puts[puts.length - 1].title === "작업 A2", { hidden: modal.hidden, last: puts[puts.length - 1] });
check("[10] 저장된 상태에서는 이탈 경고 없음", P.state().unsaved === false);
}
{
// 403·지연 + Escape + 버리기, A 실패가 B 상태를 오염시키지 않음
const env = makeEnv(); baseRoutes(env);
const dPut = deferred();
env.route("PUT", /\/project\/api\/tasks\/101$/, function () { return dPut.promise; });
const P = await boot(env); const d = env.d; const modal = d.getElementById("pj-modal-task");
await P.openTaskModal(taskOf(P, 101)); await settle();
d.getElementById("pj-t-priority").value = "high";
d.getElementById("pj-t-priority").dispatchEvent(new env.w.Event("change")); await settle();
d.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Escape", bubbles: true })); await settle();
check("[10] 저장 중 Esc → 저장이 끝날 때까지 창 유지", !modal.hidden);
env.setConfirm(true); // 버리고 넘어가기
const opening = P.openTaskModal(taskOf(P, 102)); await settle();
dPut.resolve({ status: 403, body: { detail: "권한 없음" } });
await opening; await settle();
check("[10] 403 실패 → 버리기 선택 후 B 열림", d.getElementById("pj-t-id").value === "102" && !modal.hidden);
check("[10] A 의 실패가 B 상태를 오염시키지 않음", P.state().failed.length === 0 && d.getElementById("pj-autosave-state").textContent === "", P.state().failed);
}
{
// 네트워크 단절 → 계속 편집, 복구 후 표시줄 클릭으로 재시도
const env = makeEnv(); baseRoutes(env);
let net = false; const puts = [];
env.route("PUT", /\/project\/api\/tasks\/101$/, function (u, b) { puts.push(b); return net ? { body: { task: Object.assign(detail(101, "작업 A"), b) } } : "NETWORK"; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
d.getElementById("pj-t-due").value = "2026-10-10";
d.getElementById("pj-t-due").dispatchEvent(new env.w.Event("change")); await settle();
check("[10] 네트워크 오류 → 마감일 칸 실패로 남음", P.state().failed.includes("due"));
net = true;
const stEl = d.getElementById("pj-autosave-state");
const stBefore = stEl.dataset.state;
stEl.click(); await settle();
check("[10] '다시 시도' → 같은 값으로 재전송 성공", P.state().failed.length === 0 && puts[puts.length - 1].due_date === "2026-10-10",
{ stBefore: stBefore, failed: P.state().failed, puts: puts });
}
// ── [16] 한글 조합 Enter ─────────────────────────────────
{
const env = makeEnv(); baseRoutes(env);
const dPost = deferred();
env.route("POST", /\/project\/api\/tasks\/101\/comments$/, function () { return dPost.promise; });
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
const inp = d.getElementById("pj-comment-input");
inp.value = "안녕하세요";
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true }));
const ev229 = new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true });
Object.defineProperty(ev229, "keyCode", { value: 229 });
inp.dispatchEvent(ev229);
await settle();
const posts = function () { return env.calls.filter(function (c) { return c.method === "POST" && /101\/comments$/.test(c.url); }); };
check("[16] 조합 중 Enter(isComposing·229)는 댓글 전송 안 함", posts().length === 0);
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
inp.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }));
await settle();
check("[16] 조합이 끝난 Enter 연타 → 한 번만 전송", posts().length === 1 && posts()[0].body.client_token, posts().length);
dPost.resolve({ status: 201, body: { comment: { id: 1, body: "안녕하세요" }, mention_skipped: [] } }); await settle();
const sub = d.getElementById("pj-subtask-input");
await settle(); sub.value = "하위";
sub.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true })); await settle();
check("[16] 하위 작업 칸도 조합 중 Enter 는 추가 안 함", !env.calls.some(function (c) { return c.method === "POST" && /projects\/1\/tasks$/.test(c.url); }));
const cm = d.getElementById("pj-cm-input");
env.w.__pjChat.open(101); await settle();
cm.value = "채팅";
cm.dispatchEvent(new env.w.KeyboardEvent("keydown", { key: "Enter", isComposing: true, bubbles: true, cancelable: true })); await settle();
check("[16] 댓글 대화창도 조합 중 Enter 는 전송 안 함", posts().length === 1);
}
// ── [03] 파일 댓글 — 실패 파일 표시·유지, 성공 시 비움 ───────────
{
const env = makeEnv(); baseRoutes(env);
let mode = "fail";
env.route("POST", /\/project\/api\/tasks\/101\/comments\/files$/, function () {
if (mode === "fail") return { status: 400, body: { detail: { message: "보낼 수 없는 파일이 있어 댓글을 등록하지 않았습니다.", failed: [{ index: "1", name: "b.png", reason: "빈 파일" }] } } };
if (mode === "net") return "NETWORK";
return { status: 201, body: { comment: { id: 5, body: "" }, attachments: [], mention_skipped: [] } };
});
const P = await boot(env); const d = env.d;
env.w.__pjChat.open(101); await settle();
const cm = d.getElementById("pj-cm-input");
function pasteImg(name, content) {
const f = new env.w.File(content, name, { type: "image/png" });
const ev = new env.w.Event("paste", { bubbles: true, cancelable: true });
Object.defineProperty(ev, "clipboardData", { value: { items: [{ type: "image/png", getAsFile: function () { return f; } }], getData: function () { return ""; } } });
cm.dispatchEvent(ev);
}
pasteImg("a.png", ["aaa"]); pasteImg("b.png", []);
await settle();
d.getElementById("pj-cm-send").click(); await settle();
const chips = function () { return Array.from(d.querySelectorAll("#pj-cm-pending .pj-chat-pending-chip")); };
check("[03] 서버가 거절한 파일만 빨간 표시, 두 파일 모두 남음", chips().length === 2 && chips()[1].classList.contains("is-failed") && !chips()[0].classList.contains("is-failed"));
const sent = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); });
check("[03] 파일은 본문과 한 요청으로(빈 댓글을 먼저 만들지 않음)", sent.length === 1 && !env.calls.some(function (c) { return c.method === "POST" && /101\/comments$/.test(c.url); }));
mode = "net";
d.getElementById("pj-cm-send").click(); await settle();
check("[03] 네트워크 오류 → 파일·입력 유지", chips().length === 2);
const tok1 = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); }).pop().body.get("client_token");
mode = "ok";
d.getElementById("pj-cm-send").click(); await settle();
const tok2 = env.calls.filter(function (c) { return /comments\/files$/.test(c.url); }).pop().body.get("client_token");
check("[03] 응답을 못 받은 재전송은 같은 client_token(서버가 한 번만 만듦)", tok1 && tok1 === tok2);
check("[03] 성공하면 대기 파일 비움", chips().length === 0);
}
// ── [14] 작업 창 댓글에 파일 표시 ─────────────────────────
{
const env = makeEnv(); baseRoutes(env);
env.route("GET", /\/project\/api\/tasks\/101\/comments/, function () {
return { body: { comments: [{ id: 7, body: "", author_email: "me@test.local", created_at: "2026-09-30T10:00" },
{ id: 8, body: "답글", parent_id: 7, author_email: "me@test.local", created_at: "2026-09-30T10:01" }],
events: [], features: { replies: true } } };
});
env.route("GET", /\/project\/api\/tasks\/101\/attachments/, function () {
return { body: { attachments: [{ id: 70, comment_id: 7, filename: "<b>x</b>.pdf", content_type: "application/pdf", size_bytes: 10 },
{ id: 71, comment_id: 8, filename: "r.png", content_type: "image/png", size_bytes: 10 },
{ id: 72, comment_id: null, filename: "plain.txt", content_type: "text/plain", size_bytes: 10 }] } };
});
const P = await boot(env); const d = env.d;
await P.openTaskModal(taskOf(P, 101)); await settle();
const list = d.getElementById("pj-comment-list");
check("[14] 파일만 있는 댓글에 파일 표시", list.querySelector('a[href="/project/api/attachments/70/download"]') !== null);
check("[14] 파일명은 이스케이프(태그로 해석 안 됨)", !list.querySelector(".pj-comment-atts b") && list.textContent.includes("<b>x</b>.pdf"));
check("[14] 답글의 파일은 답글에", !!list.querySelector(".pj-comment-item.is-reply img[src='/project/api/attachments/71/inline']"));
check("[14] 댓글 아닌 첨부는 댓글에 안 섞임", !list.innerHTML.includes("attachments/72/"));
check("[14] 첨부 목록에 '댓글' 표시", d.getElementById("pj-attach-list").textContent.includes("댓글"));
}
// ── [12] 연결된 작업은 읽기 전용 ─────────────────────────
{
const env = makeEnv(); baseRoutes(env);
env.route("GET", /\/project\/api\/tasks\/301$/, function () {
return { body: { task: detail(301, "연결된 작업", { project_id: 3, project_name: "비밀", access: "read", followers: null, subtasks: [{ id: 3011, title: "읽기 하위", project_id: 3 }] }) } };
});
const P = await boot(env); const d = env.d;
const linked = P.state().tasks.find(function (t) { return t.id === 301; });
await P.openTaskModal(linked); await settle();
check("[12] 제목·담당자 편집 불가", d.getElementById("pj-t-title").readOnly && d.getElementById("pj-t-assignee").disabled);
check("[12] 읽기 전용 안내 표시", !d.getElementById("pj-t-readonly").hidden);
check("[12] 댓글 입력·완료·삭제 숨김", d.getElementById("pj-comment-dock").hidden && d.getElementById("pj-toggle-complete").hidden && d.getElementById("pj-delete-task").hidden);
check("[12] 하위 작업 추가 칸 숨김, 목록은 보임", d.querySelector(".pj-subtask-form").hidden && subsText(d).includes("읽기 하위"));
d.getElementById("pj-t-title").value = "바꿈";
d.getElementById("pj-t-title").dispatchEvent(new env.w.Event("blur")); await settle();
const puts12 = env.calls.filter(function (c) { return c.method === "PUT"; });
check("[12] 읽기 전용이면 저장 요청을 보내지 않음(뒤늦은 403 없음)", puts12.length === 0, puts12);
}
// ── [13][01] 실시간 동기화 — 실패 후 같은 버전 재시도, 전체 범위 반영, 권한 회수 ──
{
const env = makeEnv(); baseRoutes(env);
let ver = "v1", snapMode = "fail";
const dSnap = deferred();
env.route("GET", /\/project\/api\/live-version/, function () { return { body: { ts: ver } }; });
env.route("GET", /\/snapshot\?scope=all/, function () {
if (snapMode === "fail") return { status: 500, body: { detail: "잠시 오류" } };
if (snapMode === "slow") return dSnap.promise;
if (snapMode === "gone") return { status: 403, body: { detail: "권한 없음" } };
return { body: { scope: "all", project: { id: 1, name: "P1" },
projects: [{ id: 1, name: "P1", color: "#4573d2", status: "active" }],
tasks: [{ id: 101, title: "작업 A(새 제목)", project_id: 1, context_project_id: 1, stage_id: 11, stage_name: "할 일" },
{ id: 150, title: "다른 사람이 만든 작업", project_id: 1, context_project_id: 1, stage_id: 13, stage_name: "검토" }],
stages_by_project: { "1": [{ id: 11, project_id: 1, name: "할 일" }, { id: 13, project_id: 1, name: "검토" }] },
stages: [{ id: 11, project_id: 1, name: "할 일" }, { id: 13, project_id: 1, name: "검토" }],
members: [{ user_email: "me@test.local" }] } };
});
const P = await boot(env); const d = env.d;
const st = function () { return env.w.pjLiveRefreshState(); };
const poll = function () { return env.w.__pjLivePoll(); };
const nextDelay = function () { const t = env.slow.filter(function (s) { return s.fn === env.w.__pjLivePoll; }).pop(); return t && t.ms; };
check("[13] 처음 본 버전 = 반영된 버전", st().observed === "v1" && st().applied === "v1");
ver = "v2";
await poll(); await settle();
check("[13] 스냅샷 실패 → 반영 버전은 그대로(v1), 실패 1", st().observed === "v2" && st().applied === "v1" && st().failures === 1, st());
check("[13] 실패 뒤 다음 확인은 늘어난 간격(16초)", nextDelay() === 16000, nextDelay());
snapMode = "ok";
await poll(); await settle();
check("[13] 같은 버전 다음 요청 성공 → v2 반영", st().applied === "v2" && st().failures === 0, st());
const s = P.state();
check("[01] 다른 프로젝트(P2) 작업·사이드바 항목 제거(권한 회수)", !s.tasks.some(function (t) { return t.project_id === 2; }) && !s.projectsMeta.some(function (p) { return p.id === 2; }));
check("[01] 새 작업·새 섹션 반영", s.tasks.some(function (t) { return t.id === 150; }) && s.boardStages.includes("검토"));
check("[01] 제목 변경 반영", s.tasks.find(function (t) { return t.id === 101; }).title === "작업 A(새 제목)");
// 동기화 중 버전이 또 바뀌면 끝난 뒤 한 번 더
snapMode = "slow"; ver = "v3";
const firstPoll = poll();
await settle();
ver = "v4";
const snapsBefore = env.calls.filter(function (c) { return /snapshot/.test(c.url); }).length;
await poll(); // 동기화가 도는 중에 또 확인 — 겹쳐 받지 않는다
const snapsDuring = env.calls.filter(function (c) { return /snapshot/.test(c.url); }).length;
dSnap.resolve({ body: { tasks: [], projects: [{ id: 1, name: "P1", status: "active" }], stages_by_project: {}, stages: [], members: [] } });
await firstPoll; await settle();
check("[13] 동기화 중 새 버전(v4) — 겹쳐 돌지 않고 반영 버전은 v3", st().applied === "v3" && st().observed === "v4" && snapsDuring === snapsBefore, { st: st(), snapsBefore: snapsBefore, snapsDuring: snapsDuring });
snapMode = "ok";
await poll(); await settle();
check("[13] 다음 주기에 v4 반영", st().applied === "v4", st());
snapMode = "gone"; ver = "v5";
await poll(); await settle();
check("[01][02] 이 프로젝트 권한 회수 → 작업 비우고 안내", !!d.querySelector(".pj-access-lost") && P.state().tasks.length === 0);
}
clearTimeout(WATCHDOG);
console.log(fails.length ? "\nFAILED: " + fails.join(", ") : "\nALL PASS");
process.exit(fails.length ? 1 : 0);
})().catch(function (e) { console.error(e); process.exit(1); });
+71
View File
@@ -0,0 +1,71 @@
"""project/project.html 을 테스트용 HTML 로 렌더한다(erp_base.html 은 최소 스텁, 가상의 데이터).
python tests/js/render_project.py # → tests/js/.out/project_render.html
"""
from __future__ import annotations
import io
import os
import jinja2
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
OUT_DIR = os.path.join(ROOT, "tests", "js", ".out")
BASE_STUB = ("{% block head_extra %}{% endblock %}<body>{% block topbar_actions %}{% endblock %}"
"<main class='erp-page'>{% block content %}{% endblock %}</main></body>")
ME = "me@test.local"
STAGES = {
1: [{"id": 11, "project_id": 1, "name": "할 일", "is_done_stage": False, "sort_order": 0, "color": None,
"created_by": ME, "default_assignee_email": ""},
{"id": 12, "project_id": 1, "name": "완료", "is_done_stage": True, "sort_order": 1, "color": None,
"created_by": ME, "default_assignee_email": ""}],
2: [{"id": 21, "project_id": 2, "name": "할 일", "is_done_stage": False, "sort_order": 0, "color": None,
"created_by": ME, "default_assignee_email": ""}],
}
def task(tid: int, title: str, pid: int, stage: int, *, ctx: int | None = None, linked: bool = False) -> dict:
return {"id": tid, "title": title, "project_id": pid, "context_project_id": ctx or pid, "is_linked": linked,
"stage_id": stage, "home_stage_id": stage, "stage_name": "할 일", "is_done_stage": False,
"description": "", "assignee_email": "", "assignee_name": "", "priority": "normal",
"start_date": None, "due_date": None, "completed_at": None, "created_by": ME,
"parent_task_id": None, "comment_count": 0, "subtask_count": 0, "subtask_done": 0,
"project_name": {1: "P1", 2: "P2", 3: "비밀"}[pid], "project_color": "#4573d2", "sort_order": tid}
TASKS = [task(101, "작업 A", 1, 11), task(102, "작업 B", 1, 11), task(103, "작업 C", 2, 21),
task(301, "연결된 작업", 3, 99, ctx=1, linked=True)]
PROJECTS = [{"id": 1, "name": "P1", "color": "#4573d2", "icon": "", "start_date": None, "due_date": None,
"created_by": ME, "description": "", "status": "active"},
{"id": 2, "name": "P2", "color": "#f06a6a", "icon": "", "start_date": None, "due_date": None,
"created_by": ME, "description": "", "status": "active"}]
def main() -> None:
env = jinja2.Environment(loader=jinja2.ChoiceLoader([
jinja2.DictLoader({"erp_base.html": BASE_STUB}),
jinja2.FileSystemLoader(os.path.join(ROOT, "app", "modules", "project", "templates")),
]))
env.globals["pj_kr_holidays"] = {}
html = env.get_template("project/project.html").render(
user={"email": ME, "is_super_admin": False}, is_admin=False, can_manage=True,
project=PROJECTS[0], current_project_id=1, stages=STAGES[1], tasks=TASKS,
members=[{"user_email": ME, "role": "member"}, {"user_email": "bob@test.local", "role": "member"}],
projects_meta=PROJECTS, nav_projects=PROJECTS, stages_by_project=STAGES, board_stage_names=["할 일", "완료"],
avatars={}, priority_labels={"low": "낮음", "normal": "보통", "high": "높음"},
color_palette=["#4573d2"], project_icons=["folder"], stage_color_palette=["#c7c4c4"],
today="2026-09-30", holidays={}, year=2026, month=9, prev_y=2026, prev_m=8, next_y=2026, next_m=10,
weekdays=["일", "월", "화", "수", "목", "금", "토"], weeks=[], goal_years=[2026],
my_open_total=0, mention_unread=0,
)
os.makedirs(OUT_DIR, exist_ok=True)
path = os.path.join(OUT_DIR, "project_render.html")
io.open(path, "w", encoding="utf-8", newline="\n").write(html)
print("rendered:", path)
if __name__ == "__main__":
main()
+471
View File
@@ -0,0 +1,471 @@
"""프로젝트 관리 모듈 — 권한·저장·댓글 첨부·알림 회귀 테스트 (실제 PostgreSQL + FastAPI TestClient).
운영 DB 와 분리된 **로컬 테스트용 PostgreSQL** 에서만 돈다. 가상의 사용자·프로젝트만 만든다.
# 1) 로컬 테스트 DB 에 스키마 적용(최초 1회): project_db_init.sql + project_db_0*.sql
# 2) 실행
PROJECT_TEST_DB_URL=postgresql://postgres@localhost:55432/project_db \
python tests/test_project_module.py
PROJECT_TEST_DB_URL 이 없거나 localhost/127.0.0.1 이 아니면 전부 건너뛴다(운영 DB 보호).
메일은 app.mail.send_email 을 가짜로 바꿔 기록만 한다(실제 발송 없음).
"""
from __future__ import annotations
import io
import os
import sys
import tempfile
import threading
import types
import uuid
from datetime import timedelta
from urllib.parse import urlparse
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
DSN = os.getenv("PROJECT_TEST_DB_URL", "")
_host = urlparse(DSN).hostname if DSN else None
ENABLED = bool(DSN) and _host in ("localhost", "127.0.0.1")
# ── app.main 대역(전체 앱을 띄우지 않고 프로젝트 라우터만 시험) ──────────────
class _Users:
def __init__(self) -> None:
self.d: dict[str, dict] = {}
def add(self, email: str, *, role: str = "user", project: bool = True, super_: bool = False) -> str:
email = email.lower()
self.d[email] = {"email": email, "name": email.split("@")[0], "role": role,
"modules": {"project": project}, "is_super_admin": super_}
return email
def get(self, email: str):
return self.d.get((email or "").lower())
def list_all(self):
return list(self.d.values())
USERS = _Users()
SENT_MAIL: list[dict] = []
if ENABLED:
from fastapi.responses import HTMLResponse
fake_main = types.ModuleType("app.main")
fake_main.user_store = USERS
def _current(request):
return USERS.get(request.headers.get("x-test-user", ""))
fake_main.get_current_user_record = _current
fake_main.build_erp_nav = lambda user, active="": []
fake_main.render_template = lambda request, name, ctx, status_code=200: HTMLResponse(
f"{name}|{ctx.get('reason', '')}", status_code=status_code)
sys.modules["app.main"] = fake_main
for k in list(os.environ):
if k.startswith("SMTP_") or k == "PROJECT_NOTIFY_EMAIL":
os.environ.pop(k)
import app.mail as _mail # noqa: E402
_mail.send_email = lambda **kw: SENT_MAIL.append(kw)
from fastapi import FastAPI # noqa: E402
from fastapi.testclient import TestClient # noqa: E402
from app.modules.project import reminders # noqa: E402
from app.modules.project import router as project_api_router # noqa: E402 - 패키지가 APIRouter 를 내보낸다
from app.modules.project.db import ProjectStore # noqa: E402
from app.timezone import today_kst # noqa: E402
ST = ProjectStore(DSN)
DATA_DIR = tempfile.mkdtemp(prefix="pj-test-")
APP = FastAPI()
APP.include_router(project_api_router)
APP.state.project_store = ST
APP.state.data_dir = DATA_DIR
CLIENT = TestClient(APP)
RUN = uuid.uuid4().hex[:6]
ADMIN = USERS.add(f"admin-{RUN}@test.local", role="admin")
SUPER = USERS.add("king@dbxcorp.co.kr", role="admin", super_=True)
ALICE = USERS.add(f"alice-{RUN}@test.local")
BOB = USERS.add(f"bob-{RUN}@test.local")
CAROL = USERS.add(f"carol-{RUN}@test.local")
DAVE = USERS.add(f"dave-{RUN}@test.local") # 프로젝트 권한은 있으나 어디에도 멤버 아님
EVE = USERS.add(f"eve-{RUN}@test.local", project=False) # 프로젝트 모듈 권한 없음
def req(method: str, url: str, who: str, **kw):
return CLIENT.request(method, url, headers={"x-test-user": who}, **kw)
def _project(name: str, owner: str, members: tuple[str, ...] = ()) -> dict:
p = ST.create_project(name=f"{name}-{uuid.uuid4().hex[:4]}", owner_email=owner, created_by=owner)
for m in members:
ST.add_member(project_id=p["id"], user_email=m)
return p
def _stage(pid: int, name: str = "할 일", done: bool = False, by: str = "") -> dict:
return ST.add_stage(project_id=pid, name=name, is_done_stage=done, created_by=by)
def _count(sql: str, *args) -> int:
with ST._pool.connection() as conn: # noqa: SLF001 - 테스트 전용 확인 쿼리
return int(conn.execute(sql, args).fetchone()["n"])
# ════════════════════════════════════════════════════════════
# [07] 소유자 변경은 관리자만
# ════════════════════════════════════════════════════════════
def test_owner_change_admin_only():
p = _project("P-owner", ADMIN, (BOB,))
r = req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": BOB})
assert r.status_code == 403, r.text
assert ST.get_project(project_id=p["id"])["owner_email"] == ADMIN
r = req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": CAROL, "name": "x"})
assert r.status_code == 403 and ST.get_project(project_id=p["id"])["name"] != "x"
# 같은 값을 같이 보내는 건(화면 저장) 통과
assert req("PUT", f"/project/api/projects/{p['id']}", BOB, json={"owner_email": ADMIN, "name": "ok"}).status_code == 200
# 관리자: 모듈 권한 없는 사람은 소유자 불가, 정상 사용자는 가능
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": EVE}).status_code == 400
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": CAROL}).status_code == 200
assert ST.get_project(project_id=p["id"])["owner_email"] == CAROL
# 소유자에서 빠지면(관리자가 다시 바꿈) 멤버가 아닌 CAROL 은 관리 권한을 잃는다
assert req("PUT", f"/project/api/projects/{p['id']}", ADMIN, json={"owner_email": ADMIN}).status_code == 200
assert req("GET", f"/project/api/projects/{p['id']}/snapshot", CAROL).status_code == 403
# 생성: 비관리자가 남을 소유자로 지정 → 거절, 본인·미지정 → 본인이 소유자
assert req("POST", "/project/api/projects", BOB, json={"name": "n1", "owner_email": CAROL}).status_code == 403
r = req("POST", "/project/api/projects", BOB, json={"name": "n2"})
assert r.status_code == 201 and r.json()["project"]["owner_email"] == BOB
# ════════════════════════════════════════════════════════════
# [06] 삭제 — 생성자 규칙 + 지금 권한
# ════════════════════════════════════════════════════════════
def test_delete_requires_current_access():
p = _project("P-del", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
t = req("POST", f"/project/api/projects/{p['id']}/tasks", ALICE, json={"title": "alice task", "stage_id": s["id"]}).json()["task"]
ST.add_comment(task_id=t["id"], author_email=ALICE, author_name="a", body="hi")
trash_before = _count("SELECT COUNT(*) AS n FROM project_trash")
# 현재 멤버인 타인 → 생성자 규칙으로 거절
assert req("DELETE", f"/project/api/tasks/{t['id']}", BOB).status_code == 403
# 멤버에서 빠진 생성자 → 거절, 행·댓글·휴지통 변화 없음
ST.remove_member(project_id=p["id"], user_email=ALICE)
assert req("DELETE", f"/project/api/tasks/{t['id']}", ALICE).status_code == 403
assert ST.get_task(task_id=t["id"]) is not None
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id = %s", t["id"]) == 1
assert _count("SELECT COUNT(*) AS n FROM project_trash") == trash_before
# 다시 멤버가 된 생성자 → 삭제(휴지통)
ST.add_member(project_id=p["id"], user_email=ALICE)
r = req("DELETE", f"/project/api/tasks/{t['id']}", ALICE)
assert r.status_code == 200 and ST.get_task(task_id=t["id"]) is None
# 프로젝트 삭제: 만든 사람이어도 지금 권한이 없으면 거절, 슈퍼관리자는 예외
p2 = _project("P-del2", ALICE)
ST.update_project(project_id=p2["id"], fields={"owner_email": ADMIN}) # 관리자가 소유자를 바꿈
assert req("DELETE", f"/project/api/projects/{p2['id']}", ALICE).status_code == 403
assert ST.get_project(project_id=p2["id"]) is not None
assert req("DELETE", f"/project/api/projects/{p2['id']}", SUPER).status_code == 200
# ════════════════════════════════════════════════════════════
# [02] 권한 회수 후 조회·변경·알림
# ════════════════════════════════════════════════════════════
def test_revoked_member_loses_everything():
p = _project("P-rev", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
t = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB,
json={"title": "shared", "stage_id": s["id"], "assignee_email": ALICE,
"description": f'<span class="pj-mention" data-email="{ALICE}">@a</span>'}).json()["task"]
c = req("POST", f"/project/api/tasks/{t['id']}/comments", ALICE, json={"body": "mine"}).json()["comment"]
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/my-tasks", ALICE).json()["tasks"])
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", ALICE).json()["tasks"])
assert any(n["task_id"] == t["id"] for n in req("GET", "/project/api/notifications", ALICE).json()["notifications"])
ST.remove_member(project_id=p["id"], user_email=ALICE)
assert not any(x["id"] == t["id"] for x in req("GET", "/project/api/my-tasks", ALICE).json()["tasks"])
assert not any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", ALICE).json()["tasks"])
assert not any(n.get("task_id") == t["id"] for n in req("GET", "/project/api/notifications", ALICE).json()["notifications"])
for m, u, body in (("GET", f"/project/api/tasks/{t['id']}", None),
("GET", f"/project/api/tasks/{t['id']}/comments", None),
("GET", f"/project/api/tasks/{t['id']}/attachments", None),
("PUT", f"/project/api/tasks/{t['id']}", {"title": "x"}),
("PUT", f"/project/api/comments/{c['id']}", {"body": "edited"}),
("DELETE", f"/project/api/comments/{c['id']}", None),
("POST", f"/project/api/tasks/{t['id']}/followers", {})):
r = req(m, u, ALICE, json=body) if body is not None else req(m, u, ALICE)
assert r.status_code == 403, (m, u, r.status_code)
assert ST.get_comment(comment_id=c["id"])["body"] == "mine"
assert req("GET", f"/project/t/{t['id']}", ALICE, follow_redirects=False).status_code == 403 # 옛 공유 링크
# 완료 알림은 권한 잃은 담당자에게 가지 않는다(담당자 기록은 남음)
before = _count("SELECT COUNT(*) AS n FROM project_notifications WHERE recipient_email=%s AND task_id=%s", ALICE, t["id"])
assert req("PUT", f"/project/api/tasks/{t['id']}", BOB, json={"completed": True}).status_code == 200
assert _count("SELECT COUNT(*) AS n FROM project_notifications WHERE recipient_email=%s AND task_id=%s", ALICE, t["id"]) == before
assert ST.get_task(task_id=t["id"])["assignee_email"] == ALICE
# 권한 없는 사람을 새 담당자로 지정할 수 없다
assert req("PUT", f"/project/api/tasks/{t['id']}", BOB, json={"assignee_email": DAVE}).status_code == 400
# 관리자·owner·멤버는 그대로
assert req("GET", f"/project/api/tasks/{t['id']}", ADMIN).status_code == 200
assert req("GET", f"/project/api/tasks/{t['id']}", BOB).status_code == 200
# ════════════════════════════════════════════════════════════
# [08] 비멤버 @태그
# ════════════════════════════════════════════════════════════
def test_mentions_only_for_people_who_can_see():
p = _project("P-men", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
desc = "".join(f'<span class="pj-mention" data-email="{e}">@x</span>' for e in (DAVE, EVE, "ghost@nowhere.test"))
r = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "m", "stage_id": s["id"], "description": desc})
t = r.json()["task"]
assert set(r.json()["mention_skipped"]) == {DAVE, EVE, "ghost@nowhere.test"}
assert _count("SELECT COUNT(*) AS n FROM task_mentions WHERE task_id=%s", t["id"]) == 0
r = req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "@dave hi", "mentions": [DAVE]})
assert r.status_code == 201 and r.json()["mention_skipped"] == [DAVE]
assert not req("GET", "/project/api/mentions", DAVE).json()["tasks"] or \
all(x["id"] != t["id"] for x in req("GET", "/project/api/mentions", DAVE).json()["tasks"])
# 멘션이 접근 권한을 만들지 않는다
assert req("GET", f"/project/api/tasks/{t['id']}", DAVE).status_code == 403
# 연결된 프로젝트 멤버는 태그 가능(읽기 권한)
p2 = _project("P-men2", ADMIN, (BOB, CAROL))
s2 = _stage(p2["id"], by=ADMIN)
assert req("POST", f"/project/api/tasks/{t['id']}/links", BOB, json={"project_id": p2["id"], "stage_id": s2["id"]}).status_code == 201
r = req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "@carol", "mentions": [CAROL]})
assert r.json()["mention_skipped"] == []
assert any(x["id"] == t["id"] for x in req("GET", "/project/api/mentions", CAROL).json()["tasks"])
# 태그 후보 API 도 같은 기준
cands = {u["email"] for u in req("GET", f"/project/api/all-users?task_id={t['id']}", BOB).json()["users"]}
assert CAROL in cands and BOB in cands and DAVE not in cands and EVE not in cands
# ════════════════════════════════════════════════════════════
# [12] 연결된 프로젝트 — 읽기 전용
# ════════════════════════════════════════════════════════════
def test_linked_task_is_read_only():
home = _project("P-home", ADMIN, (BOB,))
other = _project("P-link", ADMIN, (BOB, CAROL))
secret = _project("P-secret", ADMIN, (BOB,))
hs, os_ = _stage(home["id"], by=ADMIN), _stage(other["id"], by=ADMIN)
os2 = _stage(other["id"], name="진행", by=ADMIN)
ss = _stage(secret["id"], by=ADMIN)
t = ST.create_task(project_id=home["id"], title="linked", stage_id=hs["id"], created_by=BOB)
sib = ST.create_task(project_id=home["id"], title="sibling", stage_id=hs["id"], created_by=BOB)
sub = ST.create_task(project_id=home["id"], title="child", parent_task_id=t["id"], created_by=BOB)
for pid, sid in ((other["id"], os_["id"]), (secret["id"], ss["id"])):
assert req("POST", f"/project/api/tasks/{t['id']}/links", BOB, json={"project_id": pid, "stage_id": sid}).status_code == 201
r = req("GET", f"/project/api/tasks/{t['id']}", CAROL)
assert r.status_code == 200 and r.json()["task"]["access"] == "read"
assert [ln["project_id"] for ln in r.json()["task"]["links"]] == [other["id"]] # 비밀 프로젝트는 숨김
assert r.json()["task"]["followers"] is None
assert req("GET", f"/project/api/tasks/{sub['id']}", CAROL).json()["task"]["access"] == "read" # 하위 작업도 읽기
assert req("GET", f"/project/api/tasks/{sib['id']}", CAROL).status_code == 403 # 원 소속의 다른 작업은 안 보임
assert req("GET", f"/project/api/projects/{home['id']}/members", CAROL).status_code == 403
assert req("GET", f"/project/api/tasks/{t['id']}/comments", CAROL).status_code == 200
for m, u, body in (("PUT", f"/project/api/tasks/{t['id']}", {"title": "hack"}),
("POST", f"/project/api/tasks/{t['id']}/comments", {"body": "hi"}),
("DELETE", f"/project/api/tasks/{t['id']}", None)):
r = req(m, u, CAROL, json=body) if body is not None else req(m, u, CAROL)
assert r.status_code == 403, (m, u, r.status_code)
assert ST.get_task(task_id=t["id"])["title"] == "linked"
# 연결된 프로젝트 안의 섹션 이동은 예전처럼 허용
assert req("POST", f"/project/api/tasks/{t['id']}/links", CAROL, json={"project_id": other["id"], "stage_id": os2["id"]}).status_code == 201
# 공유 링크 — 연결된 프로젝트 화면으로
r = req("GET", f"/project/t/{t['id']}", CAROL, follow_redirects=False)
assert r.status_code == 303 and r.headers["location"] == f"/project/p/{other['id']}?task={t['id']}"
# 전체 스냅샷에서 연결 행은 연결된 프로젝트 맥락으로 한 번씩(원 소속 행은 CAROL 에게 없음)
snap = req("GET", f"/project/api/projects/{other['id']}/snapshot?scope=all", CAROL).json()
rows = [x for x in snap["tasks"] if x["id"] == t["id"]]
assert [(x["context_project_id"], x["is_linked"]) for x in rows] == [(other["id"], True)]
# 연결 해제 후엔 볼 수 없다
assert req("DELETE", f"/project/api/tasks/{t['id']}/links/{other['id']}", BOB).status_code == 200
assert req("GET", f"/project/api/tasks/{t['id']}", CAROL).status_code == 403
# ════════════════════════════════════════════════════════════
# [03] 파일 댓글 — 원자적 등록·재전송 중복 방지
# ════════════════════════════════════════════════════════════
def test_file_comment_atomic_and_idempotent():
p = _project("P-file", ADMIN, (BOB, CAROL))
s = _stage(p["id"], by=ADMIN)
t = ST.create_task(project_id=p["id"], title="files", stage_id=s["id"], created_by=BOB)
url = f"/project/api/tasks/{t['id']}/comments/files"
n0 = _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"])
# JSON 경로: 예전 has_attachment 플래그로 빈 댓글을 만들 수 없다
assert req("POST", f"/project/api/tasks/{t['id']}/comments", BOB, json={"body": "", "has_attachment": True}).status_code == 400
# 한 파일이라도 문제면(빈 파일) 아무것도 만들지 않고 어느 파일인지 알려 준다
r = req("POST", url, BOB, files=[("files", ("ok.txt", b"hello", "text/plain")), ("files", ("empty.txt", b"", "text/plain"))])
assert r.status_code == 400 and [f["name"] for f in r.json()["detail"]["failed"]] == ["empty.txt"]
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0
assert not os.path.isdir(os.path.join(DATA_DIR, "project", str(t["id"]))) or \
not os.listdir(os.path.join(DATA_DIR, "project", str(t["id"])))
# 정상: 본문 없이 파일 두 개, 같은 토큰으로 두 번 보내도 한 번만
files = [("files", ("a.png", b"\x89PNG....", "image/png")), ("files", ("b.pdf", b"%PDF-1", "application/pdf"))]
r1 = req("POST", url, BOB, data={"client_token": "tok-1"}, files=files)
r2 = req("POST", url, BOB, data={"client_token": "tok-1"}, files=files)
assert r1.status_code == 201 and r2.status_code == 201
assert r1.json()["comment"]["id"] == r2.json()["comment"]["id"] and r2.json().get("duplicate")
cid = r1.json()["comment"]["id"]
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0 + 1
assert _count("SELECT COUNT(*) AS n FROM task_attachments WHERE comment_id=%s", cid) == 2
# DB 저장 실패 → 방금 쓴 파일도 지우고 댓글 없음
orig = ST.add_comment_with_attachments
ST.add_comment_with_attachments = lambda **kw: (_ for _ in ()).throw(RuntimeError("db down"))
try:
before_files = set(os.listdir(os.path.join(DATA_DIR, "project", str(t["id"]))))
try:
req("POST", url, BOB, files=[("files", ("c.txt", b"data", "text/plain"))])
except RuntimeError:
pass # TestClient 가 서버 예외를 그대로 올린다(운영에선 500)
assert set(os.listdir(os.path.join(DATA_DIR, "project", str(t["id"])))) == before_files
finally:
ST.add_comment_with_attachments = orig
assert _count("SELECT COUNT(*) AS n FROM task_comments WHERE task_id=%s", t["id"]) == n0 + 1
# 남의 댓글에 파일을 붙일 수 없다
r = req("POST", f"/project/api/tasks/{t['id']}/attachments", CAROL,
data={"comment_id": str(cid)}, files={"file": ("x.txt", b"x", "text/plain")})
assert r.status_code == 403
# 동시에 같은 토큰 두 개 → 댓글 하나
out = []
ths = [threading.Thread(target=lambda: out.append(req("POST", url, BOB, data={"client_token": "tok-par"},
files=[("files", ("p.txt", b"p", "text/plain"))]).json()))
for _ in range(2)]
[th.start() for th in ths]
[th.join() for th in ths]
assert len({o["comment"]["id"] for o in out}) == 1
# ════════════════════════════════════════════════════════════
# [04] 날짜 범위
# ════════════════════════════════════════════════════════════
def test_date_range_validation():
p = _project("P-date", ADMIN, (BOB,))
s = _stage(p["id"], by=ADMIN)
base = f"/project/api/projects/{p['id']}/tasks"
assert req("POST", base, BOB, json={"title": "bad", "stage_id": s["id"], "start_date": "2026-10-05", "due_date": "2026-10-01"}).status_code == 400
t = req("POST", base, BOB, json={"title": "ok", "stage_id": s["id"], "start_date": "2026-10-01", "due_date": "2026-10-05"}).json()["task"]
u = f"/project/api/tasks/{t['id']}"
assert req("PUT", u, BOB, json={"due_date": "2026-09-30"}).status_code == 400 # 한쪽만 바꿔도 최종 상태 검사
assert ST.get_task(task_id=t["id"])["due_date"] == "2026-10-05"
assert req("PUT", u, BOB, json={"start_date": None}).status_code == 200 # null 로 지우기
assert req("PUT", u, BOB, json={"due_date": "2026-09-30"}).status_code == 200 # 시작일 없으면 허용
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "18:00", "due_time": "09:00"}).status_code == 400
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "00:00", "due_time": "23:59"}).status_code == 200
assert req("PUT", u, BOB, json={"start_date": "2026-09-30", "start_time": "09:00", "due_time": "09:00"}).status_code == 200
# 프로젝트도 같은 규칙(부분 수정 포함)
pu = f"/project/api/projects/{p['id']}"
assert req("PUT", pu, BOB, json={"start_date": "2026-11-01", "due_date": "2026-10-01"}).status_code == 400
assert req("PUT", pu, BOB, json={"due_date": "2026-10-01"}).status_code == 200
assert req("PUT", pu, BOB, json={"start_date": "2026-11-01"}).status_code == 400
assert req("POST", "/project/api/projects", BOB, json={"name": "d", "start_date": "2026-11-02", "due_date": "2026-11-01"}).status_code == 400
# ════════════════════════════════════════════════════════════
# [11] 완료 섹션에 바로 만든 작업
# ════════════════════════════════════════════════════════════
def test_create_in_done_stage_completes():
p = _project("P-done", ADMIN, (ALICE, BOB))
todo, done = _stage(p["id"], by=ADMIN), _stage(p["id"], name="완료", done=True, by=ADMIN)
SENT_MAIL.clear()
r = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "done now", "stage_id": done["id"], "assignee_email": ALICE})
t = r.json()["task"]
assert t["completed_at"] and "_newly_completed" not in t
assert _count("SELECT COUNT(*) AS n FROM project_activity WHERE task_id=%s AND action='completed'", t["id"]) == 1
assert _count("SELECT COUNT(*) AS n FROM project_notifications WHERE task_id=%s AND type='completed' AND recipient_email=%s", t["id"], ALICE) == 1
# 일반 섹션 생성 → 미완료, 완료 섹션으로 이동 → 완료(이력 1건 더), 이탈 → 미완료
t2 = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "later", "stage_id": todo["id"]}).json()["task"]
assert not t2["completed_at"]
assert req("PUT", f"/project/api/tasks/{t2['id']}", BOB, json={"stage_id": done["id"]}).json()["task"]["completed_at"]
assert not req("PUT", f"/project/api/tasks/{t2['id']}", BOB, json={"stage_id": todo["id"]}).json()["task"]["completed_at"]
# 섹션 없는 하위 작업: 수동 완료/취소
sub = req("POST", f"/project/api/projects/{p['id']}/tasks", BOB, json={"title": "sub", "parent_task_id": t2["id"]}).json()["task"]
assert sub["stage_id"] is None and not sub["completed_at"]
assert req("PUT", f"/project/api/tasks/{sub['id']}", BOB, json={"completed": True}).json()["task"]["completed_at"]
assert not req("PUT", f"/project/api/tasks/{sub['id']}", BOB, json={"completed": False}).json()["task"]["completed_at"]
# ════════════════════════════════════════════════════════════
# [15] 마감 알림 — 원자적·재시도·중복 방지·권한
# ════════════════════════════════════════════════════════════
def test_due_reminders_atomic_and_access():
p = _project("P-rem", ADMIN, (ALICE, BOB))
s = _stage(p["id"], by=ADMIN)
today = today_kst()
t_ok = ST.create_task(project_id=p["id"], title=f"rem-ok-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
t_gone = ST.create_task(project_id=p["id"], title=f"rem-gone-{RUN}", stage_id=s["id"], assignee_email=ALICE, due_date=today.isoformat(), created_by=BOB)
t_fail = ST.create_task(project_id=p["id"], title=f"FAILME-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
ST.remove_member(project_id=p["id"], user_email=ALICE)
q = "SELECT COUNT(*) AS n FROM project_notifications WHERE task_id=%s AND type='due_today'"
qr = "SELECT COUNT(*) AS n FROM task_reminders WHERE task_id=%s"
with ST._pool.connection() as conn: # noqa: SLF001 - 테스트 DB 에서만: 알림 생성 실패 흉내
conn.execute(f"ALTER TABLE project_notifications ADD CONSTRAINT test_fail_{RUN} CHECK (title NOT LIKE '%%FAILME-{RUN}%%')")
try:
reminders.run_due_reminders(ST, today=today, lookup=USERS.get)
assert _count(q, t_ok["id"]) == 1 and _count(q, t_gone["id"]) == 0
assert _count(q, t_fail["id"]) == 0 and _count(qr, t_fail["id"]) == 0 # 실패 → 기록도 되돌려짐
finally:
with ST._pool.connection() as conn: # noqa: SLF001
conn.execute(f"ALTER TABLE project_notifications DROP CONSTRAINT test_fail_{RUN}")
reminders.run_due_reminders(ST, today=today, lookup=USERS.get) # 재실행: 실패분만 생성
assert _count(q, t_fail["id"]) == 1 and _count(q, t_ok["id"]) == 1
# 동시 실행에도 중복 없음
t_par = ST.create_task(project_id=p["id"], title=f"rem-par-{RUN}", stage_id=s["id"], assignee_email=BOB, due_date=today.isoformat(), created_by=BOB)
ths = [threading.Thread(target=reminders.run_due_reminders, args=(ST,), kwargs={"today": today, "lookup": USERS.get}) for _ in range(4)]
[th.start() for th in ths]
[th.join() for th in ths]
assert _count(q, t_par["id"]) == 1
assert _count(q, t_gone["id"]) == 0 and _count(qr, t_gone["id"]) == 0
# ════════════════════════════════════════════════════════════
# [01] 전체 범위 스냅샷 — 다른 프로젝트의 생성·삭제·섹션 변경·권한 회수
# ════════════════════════════════════════════════════════════
def test_snapshot_all_scope():
a = _project("P-sa", ADMIN, (BOB,))
b = _project("P-sb", ADMIN, (BOB,))
sa, sb = _stage(a["id"], by=ADMIN), _stage(b["id"], by=ADMIN)
tb = ST.create_task(project_id=b["id"], title="in b", stage_id=sb["id"], created_by=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert {a["id"], b["id"]} <= {x["id"] for x in snap["projects"]}
assert any(x["id"] == tb["id"] for x in snap["tasks"]) and str(b["id"]) in snap["stages_by_project"]
sb2 = _stage(b["id"], name="new", by=ADMIN)
ST.delete_task(task_id=tb["id"], deleted_by=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert not any(x["id"] == tb["id"] for x in snap["tasks"])
assert sb2["id"] in [s["id"] for s in snap["stages_by_project"][str(b["id"])]]
ST.remove_member(project_id=b["id"], user_email=BOB)
snap = req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).json()
assert b["id"] not in {x["id"] for x in snap["projects"]} and str(b["id"]) not in snap["stages_by_project"]
ST.remove_member(project_id=a["id"], user_email=BOB)
assert req("GET", f"/project/api/projects/{a['id']}/snapshot?scope=all", BOB).status_code == 403
_ = sa
def test_store_date_range_unit():
from app.modules.project import store
store.validate_date_range(None, "2026-01-01")
store.validate_date_range("2026-01-01", None, "10:00", None)
store.validate_date_range("2026-01-01", "2026-01-01", "23:59", None)
for args in (("2026-01-02", "2026-01-01"), ("2026-01-01", "2026-01-01", "10:01", "10:00")):
try:
store.validate_date_range(*args)
except ValueError:
continue
raise AssertionError(args)
if __name__ == "__main__":
if not ENABLED:
print("SKIP: PROJECT_TEST_DB_URL(localhost) not set")
sys.exit(0)
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")
ST.close()
_ = io, timedelta