101 Commits

Author SHA1 Message Date
king cad347a936 Merge branch 'fix/perf-naver-roas-missing' 2026-10-20 11:40:08 +09:00
king da5f4d3d65 fix(performance): 네이버 광고비 칸에 ROAS 가 안 나오던 문제
네이버 광고 보고서는 열 구성을 바꿀 수 있는데 업로드가 총비용·ROAS 를
고정 4열·12열에서만 읽어, 열 배치가 다른 파일은 ROAS 가 빈 값으로
저장돼 광고비 표에 괄호 ROAS 가 표시되지 않았다.

- 총비용·구매완료 광고수익률 열을 머리글 이름으로 찾음(없으면 고정 위치)
- 광고수익률 칸이 없거나 비면 구매완료 전환매출액 ÷ 총비용 × 100
- 이미 roas 가 빈 채 저장된 행은 ad_roas 가 보관된 보고서 항목에서 다시 구함

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 11:40:07 +09:00
king 2f05a73509 Merge branch 'feat/perf-naver-roas-col' 2026-10-20 11:36:38 +09:00
king c82f712f0b feat(performance): 광고 보고서 상세에서 ROAS 를 광고비 오른쪽에 표기
네이버 광고 보고서는 ROAS(구매완료 광고수익률(%))가 12열이라 일자별
보고서 창에서 광고비(총비용)와 멀리 떨어져 보였다. 상세 표에서 ROAS
열을 광고비 열 바로 오른쪽으로 옮기고, 네이버 머리글은 "ROAS(%)"로
보여 준다(말풍선에 원래 머리글). 저장된 키는 그대로라 예전 업로드에도
적용된다. 구글·메타 상세도 같은 순서.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 11:36:38 +09:00
king 3e56f1223a Merge branch 'fix/cafe24-ftp-temp-ext' 2026-10-20 11:01:40 +09:00
king bd1cc61434 fix(cafe24): 디자인 FTP 임시 파일이 확장자 제한에 걸려 적용 실패
카페24 디자인 FTP 는 허용 확장자만 받는다. 임시 이름
`product-swiper.js.cf24tmp-<tag>` 는 확장자가 바뀌어 STOR 가
`550 Operation not permitted` 로 거부돼 모바일 스와이프·PC/모바일
상품상세 적용이 모두 실패했다. 원래 확장자를 끝에 두도록
`<stem>_cf24tmp_<tag><ext>` 로 바꾼다(원본 비킴 이름도 동일).
테스트 FTP 대역에 확장자 제한을 흉내내 회귀를 막는다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 11:01:39 +09:00
king e7d737f853 Merge branch 'feat/cafe24-swipe-code-copy' 2026-10-20 10:54:01 +09:00
king ef6313ec9f feat(cafe24): 옵션/품목 팝업에 모바일 스와이프 코드 복사 버튼
첫 줄 `// 상품명`, 이어서 품목마다 `"품목코드": "/web/... 썸네일 경로",`
형식으로 클립보드에 복사한다. 썸네일은 행에 보이는 이미지 기준이며
도메인·CDN 주소는 떼고 /web/ 부터 남긴다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 10:54:00 +09:00
king f1384d3a9a Merge branch 'fix/cafe24-status-read-lag' 2026-10-20 03:50:49 +09:00
king 1efc59ffcf fix(cafe24): 진열/판매 변경 후 예전 상태로 보이는 읽기 지연 보정
- overlay_recent_write: updated_date 가 같아도 값이 다르면 지연으로 판정
  (진열/판매만 바꾼 PUT 은 updated_date 를 올리지 않을 수 있음)
- 상품 목록에도 최근 쓰기 스냅샷 보정 적용(overlay_product_rows) —
  목록·필터가 예전 값으로 보이고 캐시가 예전 값으로 덮이던 문제
- 예약 폼 현재 상태 미리보기도 load_product 로 보정
- PUT 응답에 product_no 가 없어도 스냅샷 저장
- 회귀 테스트 추가

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 03:50:48 +09:00
king ee752e66c0 Merge branch 'feat/desc-link-atomic' 2026-10-19 23:42:52 +09:00
king 5135e68569 feat(project): 설명란 링크 굵게·기울임·밑줄, 한 글자처럼 한 번에 지우기
- 링크는 contenteditable=false 로 잠가 커서가 링크 글자 안으로 들어가지 않음
- 링크 바로 뒤 Backspace·바로 앞 Delete = 링크 통째로 삭제(execCommand, Ctrl+Z 가능)
- 저장 HTML 에서는 잠금 표시를 뺀다(getHtml)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 23:42:35 +09:00
king d895c35d6a Merge branch 'feat/perf-net-kpi-drive-files' 2026-10-19 23:19:17 +09:00
king 52ca60df9a feat(project): 파일 끌어 놓기 → 구글 드라이브 링크, 필터 켠 보드 카드 순서 버그 수정
- 설명란·세부 업무 목록·보드 카드에 파일을 놓으면 드라이브 프로젝트/섹션/업무/세부 업무
  폴더에 올리고 설명에 "파일 이름.확장자" 링크(PROJECT_DRIVE_FOLDER_ID)
- 설명에서 링크를 지우면 우리가 올린 파일만 드라이브 휴지통, 되살리면 복구
- 브라우저별 필터(localStorage)가 켜져 있으면 섹션 안 카드가 제자리로 돌아가던 버그 —
  필터 중에도 순서 변경 허용, 숨은 업무는 제자리. 카드 속 이미지 끌기 오인 방지

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 23:19:16 +09:00
king ee96c924fc feat(performance): KPI 수수료 차감 매출 한 줄·기본 보기 차감 매출·다음 업데이트 카운트다운·일 합계 ROAS
- KPI 는 수수료 차감 매출만 화면 왼쪽 한 줄(금액 + 비교 기간 대비 %), 나머지 카드 제거
- 일자별 표 기본 보기 = 수수료 차감 매출(localStorage 저장값 안 씀)
- 마지막 업데이트 옆 다음 자동 업데이트까지 남은 시간(초 단위 실시간)
- 일 합계 ROAS = 일 합계 금액 ÷ 일 합계 광고비(보기 기준별 roas / roas_net)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 23:19:14 +09:00
king b23774420b Merge branch 'fix/meet-kpi-with-weeks' 2026-10-19 18:30:59 +09:00
king 1df0c2bbd6 fix(project): 회의록 월 계획 숫자 줄을 주차 탭과 같은 줄로
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 18:30:58 +09:00
king a11aaab9be Merge branch 'fix/meet-kpibar-above' 2026-10-19 18:25:23 +09:00
king 650df5b058 fix(project): 회의록 월 계획 숫자 한 줄을 카드 위 빈 공간으로(잘리지 않게) · 결정사항 제목 왼쪽
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 18:25:22 +09:00
king d6ea464733 Merge branch 'feat/meet-head-week-split' 2026-10-19 18:15:45 +09:00
king bff71eeeba feat(project): 회의록 머리 한 칸(월 계획 숫자+결정사항) · 회의록 표 구역선만 굵은 검정·나머지 회색 · 주차 목표 두 칸(유통·인플/카페24·네이버)
- 회의록 머리: 한 줄 = 월 계획 숫자 | 결정사항 제목, 아래 전체 = 결정사항(크게), 월 계획 상세 제거
- 회의록 표: 구역 처음·끝 가로선만 굵은 검정, 나머지 선 모두 회색
- 연간 목표 주차별 매출 목표 입력: 주차마다 유통·인플 / 카페24·네이버 두 칸, 머리글은 전체 목표 아래 — 마이그레이션 project_db 030(value_dist·value_mall, value=합계)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 18:15:21 +09:00
king 897d19ca1c Merge branch 'fix/naver-ev-goods' 2026-10-19 16:56:27 +09:00
king 8c1cc3e7bb fix(performance): 네이버 주문 내역 금액 칸 = 배송비 뺀 판매금액 · 맨 아래 그날 매출 계산식
저장 금액(판매금액 + 배송비)을 그대로 보여 배송비 칸과 겹쳐 보이던 문제

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 16:56:25 +09:00
king 962fed151a Merge branch 'feat/perf-sync-reopen' 2026-10-19 16:50:28 +09:00
king c710e184e7 feat(performance): 업데이트 중에도 [매출 업데이트]로 진행 창 다시 보기 · 서버 재시작으로 남은 진행 기록 정리
- 버튼은 업데이트 중 '업데이트 중 · 진행 보기', 누르면 진행 중 작업(수동·자동)을 새로 시작하지 않고 진행 창으로
- 서버 시작 때 perf_sync_runs running 행을 '중단됨(서버 재시작)'으로 정리 — 30분 막힘 방지

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 16:50:16 +09:00
king 50d66c00a6 Merge branch 'fix/naver-ship-per-package' 2026-10-19 16:19:23 +09:00
king 6249ced4fa fix(performance): 네이버 배송비 = 배송 묶음마다 한 번(할인 안 뺌) — 판매분석 배송비와 같게
10/18 실데이터: 상품주문마다 배송비 − 할인 = 38,500 → 묶음마다 deliveryFeeAmount 한 번 = 87,500(판매분석과 일치)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 16:18:42 +09:00
king 7f4fb93996 Merge branch 'feat/naver-ship-check' 2026-10-19 16:13:18 +09:00
king f2d4275b7f feat(performance): 네이버 배송비 대조 진단 — reconcile 응답에 주문·배송 묶음 단위 후보(ship_check)
10/18 실데이터에서 상품주문마다 배송비 − 할인 = 38,500, 판매분석 87,500 — 판매분석과 맞는 셈을 실데이터로 고르기 위한 진단

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 16:13:03 +09:00
king 11ab405783 Merge branch 'fix/perf-ev-footer-color' 2026-10-19 15:55:11 +09:00
king 3aaa1d9daa fix(performance): 주문 내역 합계 줄 적립금·배송비·환불 칸 글자 흰색
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 15:55:11 +09:00
king 91de84bec9 Merge branch 'feat/perf-points-shipping' 2026-10-19 15:46:32 +09:00
king 28e6cdd78a feat(performance): 카페24 적립금 제외 · 네이버 배송비 포함·환불일 환불 차감 · 주문 내역 칸·합계
- 카페24 매출 = 결제합계 − 적립금, 환불도 적립금 환불 제외, 주문 내역 [적립금 사용] 칸·합계
- 네이버 매출 = 판매금액(총) + 배송비, 환불 = 클레임 완료일 기준 취소·반품 완료(naver:{상품주문}-RF)
- 주문 내역 [배송비]·[환불금액] 칸·합계, 예전 자료는 과거 매출 가져오기로 다시 받으면 새 규칙

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 15:46:31 +09:00
king 39d730faa0 Merge branch 'feat/inout-order-notice-mail' 2026-10-19 15:21:48 +09:00
king c3d3b5e8f3 feat(inout): 발주 메일을 보내면 입고 담당에게 발주 알림 메일 자동 발송
- 같은 Gmail·같은 제목, 내용은 발주번호·발주일·제품 코드·제품명·수량
- 알림 실패·입고 담당 없음은 공장 메일을 막지 않고 결과에 안내, 미리보기에 받을 사람 표시

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 15:21:48 +09:00
king 137f6e4d98 Merge branch 'feat/fill-toggle-file-drop' 2026-10-19 14:41:27 +09:00
king a29854b2cb feat(inout,project): 남은 수량 채우기 되돌리기 · 업무 창/보드 카드에 파일 끌어 놓아 첨부
[입출고] [남은 수량 모두 채우기]를 한 번 더 누르면 채우기 전 값으로([채운 수량 되돌리기])
[프로젝트] 업무 창 아무 곳·보드 메인 업무 카드에 파일을 놓으면 첨부(여러 개), 받는 곳 밖에 놓쳐도 화면 이동 없음
[프로젝트] [파일 추가] 여러 개 선택, 도움말 갱신

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:41:26 +09:00
king cc3e702204 Merge branch 'feat/inout-mail-facts-compact' 2026-10-19 14:30:18 +09:00
king d4e4bc5dbf style(inout): 발주 메일 첫 요약 표 칸 높이를 글자 한 줄에 맞춤 · 두 표 사이 18px
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:30:16 +09:00
king 52e21a3a68 Merge branch 'feat/inout-order-mail-cc' 2026-10-19 14:25:14 +09:00
king 971666532e feat(inout): 발주 메일 참조 기본값 king@dbxcorp.co.kr · 옵션 → 공장에서 변경
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:25:13 +09:00
king 9cc508dc50 Merge branch 'feat/inout-recv-bar-buttons' 2026-10-19 14:13:58 +09:00
king 2a2c436013 style(inout): 입고 줄 버튼·입력칸 높이 34px 통일 · [입고증 업로드] 이름·사진 아이콘 28px
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:13:57 +09:00
king f486e6f263 Merge branch 'feat/inout-done-lock' 2026-10-19 14:04:18 +09:00
king 90af8a8486 feat(inout): 전체 입고 완료면 입고 저장 막기 · 사방넷 입고 파일 버튼 엑셀 초록
- 모든 품목 입고 완료·초과면 입고 칸·[입고 저장] 등 흐리게 disabled, 서버도 잠근 뒤 거절
- 사방넷 입고 파일 버튼 #217346

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 14:03:54 +09:00
king 2237e2e799 Merge branch 'feat/inout-sabangnet-file' 2026-10-19 13:44:43 +09:00
king 96438d5078 feat(inout): 입고 기록 줄 [사방넷 입고 파일] 엑셀 다운로드
- 1행 제목 상품코드·가용수량·불용수량, A=코드표 사방넷 코드, B=입고 수량, C=상품 이름
- 사방넷 코드가 없는 상품·코드표 연결 불가면 파일 대신 안내
- 발주·입고 담당, 마이그레이션 없음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 13:44:42 +09:00
king 038007c34e Merge branch 'feat/inout-receipt-mail' 2026-10-19 13:33:48 +09:00
king 08fe894d1b feat(inout): 물류센터 이메일 옵션 · 입고 저장 뒤 입고 요청 메일(Gmail, 본문 안 사진 600px)
- 옵션 → 물류센터 탭: 물류센터 담당자 이메일·입고 요청 메일 참조(기본 king@·bj@dbxcorp.co.kr)
- 입고 저장 → 미리보기 팝업 바로 → [메일 발송](입고 담당 본인 Gmail), 입고 기록 줄 보내기/다시 보내기
- 제목 "[입고 요청] yyyy년 mm월 dd일(요일) 입고 요청 합니다.", 본문 = 전산 등록 부탁 + 상품 이름·코드·입고 수량·비고 표
- 입고증 사진은 첨부가 아니라 본문 안 이미지(CID multipart/related), 가로 최대 600px·비율 유지로 줄임
- Gmail 연결 권한을 발주 담당 → 발주·입고 담당으로
- 마이그레이션 inout_db 005(inout_settings·inout_receipt_mails), 초기화 SQL 에도 반영

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 13:33:46 +09:00
king b95d3909a4 Merge branch 'feat/inout-mail-facts-grid' 2026-10-19 12:20:27 +09:00
king cb69b086d7 feat(inout): 발주 메일 첫 요약 표를 4열(항목·값 두 쌍씩) 4×4로
- 예전 2열 × 8행 → 4열 × 4행, 요청 사항은 맨 아래 한 줄 전체

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 12:20:27 +09:00
king 86720d073e Merge branch 'feat/meet-item-borders' 2026-10-19 12:16:47 +09:00
king 7540bc5610 feat(project): 주간 회의록 항목 사이 가로선 검정 · 같은 항목 하위 줄 사이만 회색
- markMeetSecEnds 가 칸 바로 아래 줄이 새 항목이면 .is-item-end(검정), 아니면 회색
- 구역 경계 굵은 선은 그대로

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 12:16:46 +09:00
king 96d33c668b Merge branch 'feat/inout-po-weight-meet-borders' 2026-10-19 12:08:46 +09:00
king c1b3d7af59 feat(inout,project): 발주 메일 전체 무게·PP 사용량(kg) · 회의록 구역 굵은 선·줄 사이 회색 선
[입출고]
- 발주 메일 표: PP(g/개) → 전체 무게(kg) = 개당 무게 × 수량
- PP 사용량(kg) 열 추가(은 함유량 왼쪽) = 전체 무게 − 은 무게
- 은 함유량 괄호 = 전체 무게 × %(kg), 합계·요약·글 본문도 kg

[프로젝트]
- 주간 회의록 표: 구역(구분) 처음·끝 가로선 굵은 검정, 구역 안 줄 사이 가로선 회색
- 구역 끝에 닿는 칸(병합 포함)은 markMeetSecEnds 로 아래선 정리

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 12:08:32 +09:00
king e64612a8d9 Merge branch 'feat/project-dnd-perf-unit' 2026-10-19 10:46:13 +09:00
king 62c345bbb5 feat(project,performance): 보드 카드 끌기 실시간 미리보기 · 회의록 항목 끌어 옮기기·검정 테두리 · 실적 매출 단위·광고비(ROAS%) 줄
[프로젝트]
- 보드 카드 끌기: 기울어진 끄는 모양 + 점선 자리 표시가 카드 사이로 FLIP 애니메이션, 놓은 자리 그대로(다른 섹션도 순서 저장)
- 컬럼 dragenter 도 허용 — 자리 표시가 들어온 직후 놓을 때 drop 이 거부되던 문제
- 끄는 동안 실시간 동기화가 보드를 다시 그리지 않음
- 주간 회의록 항목 칸을 끌어 위아래로 이동(묶인 줄·세로 병합째, 같은 구역) — POST meeting-items/{id}/move-to
- 주간 회의록 표 테두리 모두 검정
- 도움말·모듈 문서 갱신

[실적]
- 설정의 쇼핑몰 원본 데이터 확인·카페24 매출 대조·일별 한 번에 비교 카드 삭제(서버 API 는 유지)
- 보기 설정: 매출 단위 원·천원·백만원(이 브라우저 쿠키 perf_unit)
- 매출 실적 표 매출 칸 아래 광고비(ROAS%) 줄(광고비 색), 카페24 는 구글·메타 두 줄

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 10:44:24 +09:00
king ee728ed006 Merge branch 'docs/slim-claude-md' 2026-10-18 02:41:28 +09:00
king 619f95b7f4 docs: split CLAUDE.md into per-module CLAUDE.md to cut token use
Root CLAUDE.md (loaded every conversation) shrank from 34KB to ~8KB.
Module details moved verbatim-in-substance to app/modules/<mod>/CLAUDE.md,
which Claude Code loads only when working in that folder.

- [모듈명] prefix → module table (folder, DB, perm key, docs, static files)
- shared docs read only per task type (old "read 4 docs first" rule dropped)
- large docs: read TOC via grep, then only the needed section
- cross-module dependency list kept in root

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-18 02:41:26 +09:00
king fa7c55dee5 Merge branch 'feat/inout-super-delete' 2026-10-17 01:44:19 +09:00
king 215b937f1e feat(inout): 수퍼관리자 발주 삭제(발주 목록)
- 발주 목록 줄 끝 휴지통 — 수퍼관리자에게만 보이고 서버도 수퍼관리자만 허용(ERP 관리자도 403)
- 확인 창 후 품목·입고 기록·입고증 사진·발주 메일 기록까지 완전히 삭제(CASCADE), 서버 로그에 남김
- 지운 뒤 보던 목록(거르기 그대로)으로 — 다른 사이트 주소는 무시

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 01:44:18 +09:00
king f1e8dd5bf5 Merge branch 'feat/inout-all-received-dates' 2026-10-17 01:37:17 +09:00
king fde37515c8 feat(inout): 전체 입고 완료 표기 · 날짜 서식 yyyy.mm.dd(요일)
- 모든 품목이 입고완료·초과입고면 목록·발주서 머리에 초록 "✓ 전체 입고 완료"(초과가 있으면 "초과 포함")
- 화면·메일·메일 기록 날짜를 모두 2026.10.17(토) / 2026.10.17(토) 15:14 로(ymd·ymdhm 매크로, store.fmt_date·fmt_datetime)
- 발주서 품목 합계 줄 왼쪽 여백

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 01:37:15 +09:00
king f3b33d4084 Merge branch 'fix/erp-confirm-over-modal' 2026-10-17 01:08:50 +09:00
king 86ea9a11d4 fix(erp-dialog): 모달 팝업 안에서 확인 창이 뒤에 깔려 안 보이던 문제
입출고 옵션(상품 정보) ✕ 지우기 등 모달 <dialog>(showModal) 안에서 erpConfirm 을 부르면
body 에 붙인 확인 창이 브라우저 맨 위 층 뒤에 깔려 보이지도 눌리지도 않았다.
모달이 열려 있을 때만 확인 창을 모달 <dialog> 껍데기로 감싸 그 위에 띄운다(Esc = 취소). 평소엔 예전 그대로.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 01:08:49 +09:00
king b5bdf99069 Merge branch 'feat/inout-products' 2026-10-17 00:59:47 +09:00
king a475f0b2f6 feat(inout): 옵션 상품 정보 탭 — 단가·무게(PP)·은 함유량, 발주서·메일 금액, 입고 담당 화면 줄이기
- 마이그레이션 004: inout_products(단가·개당 무게 g·은 함유량 %), inout_products_excluded(지운 단품),
  inout_order_lines 에 발주할 때 값 사본(unit_price·weight_g·silver_pct)
- 옵션 → 상품 정보: [단품 불러오기](값을 넣은 상품은 그대로, 지운 단품은 다음에도 빠짐), 바뀐 줄만 저장,
  은 g = 무게 × % 자동, 지우기·되살리기
- 상품 정보가 있으면 발주서 제품은 그 목록에서(단가 함께), 금액 = 수량 × 단가 실시간 합계
- 발주서 화면(발주 담당)·발주 메일에 단가·금액·PP(g/개)·은 함유량과 합계(금액·PP kg·은 g)
- 입고 담당(발주 담당 아님)은 품목을 제품 이름·발주 수량(+ 이번 입고)만, 입고 기록 칩도 이름
- 고침: 그날 100번째 발주서부터 번호가 겹치던 문제(순번 숫자 비교), 시각을 DB 시간대와 무관하게 KST 로 읽음

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 00:59:45 +09:00
king dcc6cd27b6 Merge branch 'fix/inout-gmail-connect-hint' 2026-10-16 16:59:15 +09:00
king 12f1d455b9 fix(inout): 메일 창 — 연결 전 아래 줄 숨김, redirect_uri_mismatch 대비 등록할 주소 안내
- .io-dlg-footbar 의 display:flex 가 hidden 속성을 덮어써 연결 전에도 [메일 발송]·[연결 끊기]가 보이던 문제
  → .io/.io-dlg/.io-viewer 안의 [hidden] 은 늘 숨김.
- 구글이 redirect_uri_mismatch 로 막으면 ERP 로 돌아오지 않으므로, 연결 안내에 구글 클라우드
  "승인된 리디렉션 URI"에 넣을 정확한 주소(callback_url)를 미리 보여 준다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 16:59:14 +09:00
king 9429485236 Merge branch 'feat/inout-mail-photos' 2026-10-16 16:41:30 +09:00
king 451b37955e feat(inout): 발주 메일(발주 담당 본인 Gmail) · 공장 이메일 · 입고증 사진
- inout_db 003: 공장 이메일, 사람별 Gmail 연결(갱신 토큰 암호문만), 발주 메일 기록, 입고증 사진(bytea). init 에도 같게.
- 발주 메일: 새 발주서 저장 → 미리보기 팝업(받는 사람 = 공장 이메일, 요약 표 HTML + 글 본문) → 사람이 [메일 발송]을
  눌러야 Gmail API(gmail.send)로 본인 Gmail 에서 발송. [Gmail 연결]은 사람마다 1회 — 고른 구글 계정 = ERP 계정 확인,
  APP_ENCRYPTION_KEY(AES-GCM, AAD inout:gmail:{email})로 암호화 저장. 보낸 기록, 재발송은 확인 후(resend),
  연결 끊김(invalid_grant)은 토큰 삭제 후 재연결 안내.
- 입고증 사진: 입고 저장 때 첨부(브라우저가 긴 변 2000px JPEG 로 줄임 — 7.9MB → 0.8MB), 10장·10MB, 파일 머리로 형식 검사,
  입고와 한 트랜잭션. 썸네일·크게 보기(←/→)·나중에 더하기·지우기, 보기는 nosniff·CSP sandbox. 초과 확인은 브라우저가 먼저(사진 유지).
- 테스트: 메일 본문·escape·받는 주소·Gmail 연결 검사·토큰 갱신/발송(가짜 구글)·암호화, 사진 검사, 실제 PostgreSQL 저장,
  실제 앱 흐름(사진 업로드·보기 헤더·권한, 메일 미리보기·연결·발송·재발송·끊김). 실제 브라우저로 팝업·사진·축소 확인.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 16:41:28 +09:00
king 2ed275cd80 Merge branch 'fix/inout-over-button' 2026-10-16 16:06:25 +09:00
king 5d7862515f fix(inout): [초과 입고로 저장] 버튼을 진한 빨강 바탕·흰 글씨로 — 분홍 안내 상자 위에서 잘 안 보이던 문제
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 16:06:24 +09:00
king 6121a27454 Merge branch 'feat/inout-options-popup' 2026-10-16 15:45:55 +09:00
king 4c17158753 feat(inout): 옵션을 톱니 팝업으로, 겹치던 옵션 화면 정리, 공장 담당자·연락처 분리
- 옵션 탭 → 상단 오른쪽 톱니(관리자) → 팝업(탭: 담당자·공장). 내용은 /inout/settings?panel=1,
  저장은 팝업 안에서(X-Inout-Options: 1 → JSON, 같은 탭 그대로 다시 그림), 바뀌면 닫을 때 새로고침.
  예전 /inout/settings 주소는 목록으로 가서 팝업 열기(?options=1).
- 겹침 원인: 공용 .erp-input(min-width 240px + content-box)이 좁은 칸에서 옆 칸을 덮고,
  .erp-table-wrap(카드 그림자·둥근 모서리)이 카드 안에서 상자를 겹쳐 보이게 함 → .io/.io-dlg 안에서만 바로잡음.
  공장 표는 진짜 <table> + 입력칸 form 속성으로 열 맞춤(줄 선·배경 어긋남 없음).
- 공장 담당자·연락처 분리: inout_db 002(manager 열, 이름만 있던 연락처는 담당자로). 발주서 화면에 공장 담당자·연락처.
  002 미적용이어도 발주서 화면은 열리고 공장 저장만 안내.
- 테스트: 팝업·JSON 저장·예전 주소·권한, 담당자/연락처, 002 전후. 실제 브라우저로 겹침 0·줄 맞춤 확인.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:45:53 +09:00
king 586a14f7f9 Merge branch 'fix/inout-dsn-doc' 2026-10-16 15:28:27 +09:00
king 65a1fd1991 docs(inout): DB 생성 명령 — 비밀번호 URL 인코딩·.env 줄 붙음 방지·실제 연결 확인
비밀번호의 @ 등 특수문자가 DSN 을 깨뜨려 /inout/ 이 30초 뒤 500(PoolTimeout)이 된 운영 사례(2026-10-16).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:28:26 +09:00
king e722d8ba1b Merge branch 'feat/inout-module' 2026-10-16 15:21:06 +09:00
king 6f3bffd840 feat(inout): 입출고 관리 모듈 — 공장 제작 발주 · 물류 입고 · 미입고/초과 관리
- 새 모듈 app/modules/inout(/inout/, 권한키 inout) + 새 DB inout_db(사용자 승인, scripts/sql/inout_db_init.sql — 멱등).
- 발주 담당이 공장에 발주서(PO-YYMMDD-NN, 제품 = itemcode_db 단품만 — 검색 + 저장 때 서버 재확인),
  입고 담당이 물류에 들어온 수량을 여러 번 나눠 입력 → 품목별 발주·입고·미입고, 진행률, 입고 예정일 지연.
- 미입고 현황: 제품별 합계 · 발주별(예정일 순) · 초과 입고. 잔량 종결/풀기, 입고 없는 발주 취소, 입고 기록 지우기.
- 초과 입고: 확인 화면(409, 입력 유지) 후 [초과 입고로 저장] — 트랜잭션 안에서 발주서 잠그고 판단, Enter 는 일반 저장.
- 옵션(ERP 관리자): 공장 목록, 발주 담당·입고 담당 지정(inout_roles). 관리자는 둘 다.
- 상태는 저장하지 않고 누적 입고로 계산(store.order_status). 이카운트 "발주 대비 미입고"·Odoo 분할 입고/종결 참고.
- 테스트: 순수 로직, 실제 PostgreSQL(앱 계정 inout_app — 권한 포함), 실제 앱 화면 흐름(권한별). 문서 INOUT_MODULE.md 등.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 15:21:05 +09:00
king 80b7becd45 Merge branch 'fix/meta-ads-no-vat' 2026-10-16 14:04:58 +09:00
king 8051e7f207 fix(performance): 메타 광고비에 부가세 1.1 곱하지 않음
- 메타 지출 금액은 이미 부가세 포함(사용자 확인) — 광고비 = 지출 금액 그대로(외화 계정은 × 그날 환율만).
  × 1.1 은 비용이 부가세 별도인 구글만 그대로.
- 일자별 표: "광고비(부가세 포함)"·"지출 금액(부가세 별도)" 두 열 → "지출 금액(부가세 포함)" 한 열.
- 설정·광고비 탭 안내 문구, 문서, 테스트 기대값 갱신.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 14:04:57 +09:00
king 7933f163b4 Merge branch 'feat/meta-ads-usd-fx' 2026-10-16 13:59:50 +09:00
king 0836d6a926 feat(performance): 메타 외화(USD) 광고 계정 — 그날 환율로 원화 환산
- 예전엔 원화가 아닌 계정이면 "원화 계정만" 오류로 저장 안 함 → 이제 지출 금액·구매 전환값을 그날 환율로 원화 환산해
  다른 계정과 합산(광고비 = 지출 × 환율 × 1.1, ROAS 는 비율이라 그대로).
- fx.py: Frankfurter v2(키 없음, 중앙은행 고시 환율 종합, 매일)에서 기간 환율 한 번에, 빈 날은 앞 가장 가까운 날,
  못 구하면 그 회차 저장 안 함, 지난 날 환율은 프로세스 캐시.
- 계정 탭에 지출 금액(USD)·적용 환율(원)(합계 = 광고비 가중 평균), 연결 테스트·설정 안내 문구 갱신.
- 테스트: 혼합 계정 환산·빈 날 환율·환율 장애·캐시·환율 합계, 실제 Frankfurter 응답으로 파싱 확인.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:59:49 +09:00
king 36b1f49340 Merge branch 'feat/meta-ads-account-tabs' 2026-10-16 13:38:18 +09:00
king b2710a0831 feat(performance): 메타 광고 상세보기 [합계 | 계정별] 탭
- 가져올 때 그날 메타 행 metrics 에 계정별 값(_accounts: 이름·광고비·ROAS·항목, insights account_name)을 함께 저장
  — 새 마이그레이션 없음. "_" 키는 일자별 표 열·합계·화면 값에서 제외.
- ad_spend.detail_tabs: 합계 탭 + 계정 탭(그 계정이 광고 낸 날만, 광고비 큰 계정부터), 계정별 값 없는 날 수 안내.
- 상세보기 창: 탭(주황 강조, 계정 ID 말풍선), 계정 탭은 1원 반올림 차이 안내. 네이버·구글은 그대로 표 하나.
- 테스트: 계정별 변환·탭 순서/이름/가중 ROAS·옛 자료 안내·API 응답, jsdom 탭 전환.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:38:17 +09:00
king 8bbb1f9ab2 Merge branch 'fix/meta-ads-diagnosis-cut' 2026-10-16 13:26:50 +09:00
king 8a597007cb fix(performance): 메타 연결 테스트 진단이 잘리던 문제
- 비밀값 가림(redact_text)의 기본 300자 한도에서 긴 메타 원문·안내 뒤의 [진단]이 "[진…"으로 잘렸다.
- 연결 테스트 문구를 [진단] 먼저 + 메타 원문(긴 안내 주소 제거) 뒤로 바꾸고,
  광고 연동 오류 문구 한도를 ad_sync.AD_MESSAGE_MAX(1200자)로.
- 테스트: 설정 연결 테스트 경로(AdSyncService)에서 진단 전체·순서·주소 제거·토큰 미포함 확인.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:26:49 +09:00
king dc54553d2f Merge branch 'fix/meta-ads-permission-diagnosis' 2026-10-16 13:21:51 +09:00
king 527ec83b30 feat(performance): 메타 광고 권한 오류(#200) 원인 진단
- 연결 테스트가 권한 오류를 받으면 메타에 debug_token(권한·대상 계정·만료, 안 되면 me/permissions)과
  me/adaccounts(보이는 계정)를 물어 원인 하나를 짚는다: ads_read 없음 / 계정 미배정 / 권한이 다른 계정에만 / 앱 쪽.
- 광고비 탭 불러오기의 권한 오류엔 "[연결 테스트]가 원인을 진단" 안내. 진단 문구에도 토큰 미포함.
- 테스트 7개 추가(원인별 결론·폴백·안내 위치).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:21:50 +09:00
king abf03f0a80 Merge branch 'feat/meta-ads-api' 2026-10-16 13:09:44 +09:00
king b397bdf83b feat(performance): 메타 광고 API 연동 — 광고비·구매 ROAS 자동 가져오기
- ad_sources/meta_ads.py + registry 한 줄: Meta Marketing API Insights(기본 v26.0),
  level=account·하루 단위, 광고 계정 여러 개를 날짜별로 합산, paging.next 따라감(graph.facebook.com 밖 주소 거부).
- 설정(실적 설정 → 광고 API 연동): 광고 계정 ID(여러 개)·액세스 토큰(암호화)·앱 시크릿(선택, appsecret_proof)·API 버전.
- 광고비 = 지출 금액 × 1.1(부가세 포함, 구글과 같은 기준), ROAS = 구매 전환값 ÷ 지출 금액(광고 관리자 구매 ROAS).
  구매 값은 omni_purchase → purchase → 픽셀 구매 중 처음 있는 것 하나(겹친 값 더하지 않음). 원화 계정만.
- 메타 오류 코드 안내(토큰 만료 190·권한 200·계정 ID 100·호출 한도), 오류 문구에 토큰·주소 미포함.
- 메타 머리글 = 일자별 보고서 표(DETAIL_CHANNELS), 화면 안내 문구·문서 갱신. 새 마이그레이션·환경변수 없음.
- 테스트: test_meta_ads.py(가짜 메타 서버, 실제 fetch_days → AdSyncService), 메타 연동 반영해 기존 테스트 기대값 갱신.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:09:43 +09:00
king 32457e4ce8 Merge branch 'feat/project-options-system' 2026-10-16 10:29:39 +09:00
king 94fac65238 feat(project): Project 옵션 시스템 전체 적용 + 모달 안 말풍선 가림 수정
- 프로젝트 화면(처음 여는 탭)·보드(카드 표지)는 서버 저장(project_db.project_options, 마이그레이션 029)
  → 수퍼관리자·Admin 이 바꾸면 모든 사용자에게 적용. 일반(폰트)은 그대로 이 브라우저(localStorage).
- GET/PUT /project/api/options(쓰기는 Admin 이상, 보낸 키만, 029 미적용 503). 검사·기본값은
  store.normalize/validate_project_options 한 곳. 프로젝트 화면은 data-default-view·data-board-cover 로 받음
  (읽기 실패해도 기본값으로 열림).
- 옵션 창: 열 때 서버 최신값 읽기(실패 시 시스템 칸 잠금·폰트만 저장), 바뀐 키만 PUT, 실패면 창 유지.
  분류 제목 옆 적용 범위 배지(이 브라우저에만 / 모든 사용자에게).
- 공용 말풍선: 모달 대화창(showModal) 안에서는 popover(top layer)로 띄워 대화창 뒤에 가려지지 않게.
- 테스트: tests/test_project_options_api.py, jsdom 옵션 테스트 갱신. 도움말·문서·DEPLOYMENT(029) 갱신.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:29:37 +09:00
king 1cabad8e3b Merge branch 'feat/project-options-admin' 2026-10-16 10:11:46 +09:00
king e753e55aa1 feat(project): Project 옵션 — 처음 여는 탭·보드 표지를 Admin 에게도
- 프로젝트 화면·보드 분류: 수퍼관리자 → 수퍼관리자·Admin(pj_admin / project.js isPAdmin).
- 관리자(긴급 공지) 분류는 그대로 수퍼관리자만(공지 화면이 수퍼관리자 전용).
- Pro user·User 는 폰트만, 브라우저에 남은 첫 탭·표지 값은 무시(기본값).
- Admin 테스트 추가, 도움말·문서 갱신, project.js 캐시 버전 올림.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:45 +09:00
king 31db917eb8 chore(notice): project.js 캐시 버전 맞춤(20261016b)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:08:41 +09:00
king 59dd7e2ef9 Merge branch 'feat/project-options-super-only' 2026-10-16 10:08:22 +09:00
king 30b0366818 feat(project): Project 옵션 — 폰트만 모두에게, 처음 여는 탭·보드 표지·관리자는 수퍼관리자만
- 옵션 창의 프로젝트 화면·보드 분류를 수퍼관리자에게만 렌더(관리자 분류와 같은 조건).
- 수퍼관리자가 아니면 project.js 가 브라우저에 남은 pj_default_view·pj_board_cover 를 무시하고
  기본값(보드·표지 켬)으로 동작. 일반 사용자 저장은 pj_font 만 씀.
- 테스트: 수퍼관리자 렌더(project_super_render.html) 추가, 일반 사용자 경우 테스트. 도움말·문서 갱신.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:08:21 +09:00
king d6b15a6aec Merge branch 'feat/project-options-dialog' 2026-10-16 10:03:33 +09:00
king ed7b2ef3ca feat(project): Project 옵션 창 개편 — 분류별 설정 + 보드 카드 표지·처음 여는 탭
- 옵션 창을 왼쪽 분류(일반·프로젝트 화면·보드·관리자) | 오른쪽 설정 구조로 개편,
  아래 [기본값으로]·취소·저장(한꺼번에 저장). 폰트·긴급 공지(수퍼관리자)는 그대로.
- 보드: 카드 표지 이미지 켜기/끄기(localStorage pj_board_cover, 기본 켬) — 저장하면 보던 보드에 바로 반영.
- 프로젝트 화면: 처음 여는 탭(pj_default_view — 보드·목록·캘린더·타임라인·대시보드).
  달력 월 이동 복원·전체 보기(대시보드)·업무 창 패널(embed)은 기존 동작 유지.
- 도움말·docs/PROJECT_MODULE.md·CLAUDE.md 갱신, jsdom 테스트 추가, 정적 파일 버전 올림.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:03:32 +09:00
king 70743394d8 Merge branch 'fix/code-review-2026-10-15' 2026-10-15 18:54:19 +09:00
113 changed files with 12068 additions and 874 deletions
+9
View File
@@ -49,6 +49,10 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# Cloud Console 에서 Google Drive API·Google Slides API 사용 설정. 서비스 계정이면 공유 드라이브 콘텐츠 관리자로 추가.
# GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN=replace-me # 비우면 GOOGLE_SHEETS_OAUTH_REFRESH_TOKEN 사용
# MEETING_BOARD_FOLDER_ID=0AGF3CIEboPQiUk9PVA # 보드를 만들 공유 드라이브(폴더) ID — 비우면 이 기본값
#
# Project 업무 파일 → 구글 드라이브(설명란·보드 카드·세부 업무에 파일 끌어 놓기) — 위 Google 인증(Drive 권한)을 같이 쓴다.
# 그 아래 프로젝트/섹션/업무/세부 업무 폴더를 자동으로 만든다. 서비스 계정이면 공유 드라이브 폴더여야 올라간다.
# PROJECT_DRIVE_FOLDER_ID=1Zdak2FtACRJ6peOnA9zD22hsbbsTixJG # 업무 파일 최상위 폴더 ID — 비우면 이 기본값
# ─── 휴가 관리 모듈 (vacation_db) ───
# 설정해야 모듈이 동작한다(미설정 시 "설정 필요" 안내, JSON 폴백 없음).
@@ -144,6 +148,11 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# CAFE24_MOBILE_DETAIL_FTP_PATH=/sde_design/mobile11/product/detail.html
# CAFE24_PC_DETAIL_FTP_PATH=/sde_design/skin11/product/detail.html
# ─── 입출고 관리 모듈 (inout_db) — app/modules/inout ───
# 본사 → 공장 발주, 물류 입고, 미입고 관리. 미설정 시 "설정 필요" 안내만.
# 초기화: scripts/sql/inout_db_init.sql (docs/INOUT_MODULE.md). 제품(단품)은 아래 ITEMCODE_DB_URL 재사용.
# INOUT_DB_URL=postgresql://inout_app:replace-me@postgres-db:5432/inout_db
# ─── 상품 검색 (itemcode_db 읽기 전용) ───
# cupang 설정 화면에서 제품명을 itemcode_db 에서 검색해 등록한다(읽기만).
# 미설정 시 검색 비활성 → 수동 등록만 가능.
+66 -36
View File
File diff suppressed because one or more lines are too long
+10 -3
View File
@@ -85,10 +85,17 @@ def read_text_file(config: Cafe24FtpConfig, path: str) -> str:
def temp_names(path: str, tag: str) -> tuple[str, str]:
"""(임시 업로드 이름, 원본을 잠시 비킬 이름) — 같은 폴더, 원본 이름 + 표식."""
"""(임시 업로드 이름, 원본을 잠시 비킬 이름) — 같은 폴더, 원본 이름 + 표식.
⚠️ 원래 확장자를 **맨 끝에 그대로** 둔다. 카페24 디자인 FTP 는 허용된 확장자(.js·
.html·.css 등)만 받는다 — 예전 이름 `product-swiper.js.cf24tmp-…` 는 확장자가 바뀌어
STOR 가 `550 Operation not permitted` 로 거부됐다(실물). 그래서
`product-swiper_cf24tmp_<tag>.js` 모양으로 만든다(점·하이픈 대신 밑줄).
"""
folder, name = posixpath.split(path)
return (posixpath.join(folder, f"{name}.cf24tmp-{tag}"),
posixpath.join(folder, f"{name}.cf24old-{tag}"))
stem, ext = posixpath.splitext(name)
return (posixpath.join(folder, f"{stem}_cf24tmp_{tag}{ext}"),
posixpath.join(folder, f"{stem}_cf24old_{tag}{ext}"))
def write_text_file(
+186
View File
@@ -0,0 +1,186 @@
"""Google 드라이브 — 업무 파일 올리기(설명란·보드 카드·세부 업무에 파일 끌어 놓기, 2026-10-19).
인증은 google_slides 와 같은 설정(서비스 계정 우선, 없으면 OAuth 리프레시 토큰 — Drive 권한 포함)을 쓴다.
- 최상위 폴더 `PROJECT_DRIVE_FOLDER_ID`(기본 = 업무 파일 폴더). 그 아래 `프로젝트/섹션/업무/세부 업무` 폴더를 이름으로
찾고 없으면 만든다(휴지통 폴더 제외). 같은 경로를 두 사람이 동시에 만들지 않게 폴더 찾기·만들기는 한 번에 하나씩.
- 올린 파일은 appProperties `dbxTaskId` = 업무 id — 설명란에서 링크를 지우면 **우리가 올린 파일만** 휴지통으로 보낸다
(다른 사람이 붙여 넣은 드라이브 링크는 건드리지 않음). 링크를 되살리면(되돌리기·잘라 붙이기) 휴지통에서 꺼낸다.
휴지통 파일은 드라이브가 30일 뒤 지운다.
- 서비스 계정은 내 드라이브 저장 용량이 없어 "공유 드라이브" 폴더여야 올라간다(OAuth 토큰이면 그 사용자 드라이브도 됨).
- 비밀값(키/토큰)은 로그·화면에 절대 출력하지 않는다. 라이브러리·설정이 없으면 `enabled = False`.
"""
from __future__ import annotations
import os
import re
import threading
from typing import Any, BinaryIO, Iterable
from app.integrations.google_slides import GoogleSlidesClient, _friendly
DEFAULT_FOLDER_ID = "1Zdak2FtACRJ6peOnA9zD22hsbbsTixJG"
FOLDER_MIME = "application/vnd.google-apps.folder"
TASK_KEY = "dbxTaskId"
CHUNK = 8 * 1024 * 1024
# 설명란 링크에서 드라이브 파일 id — 우리가 넣는 링크 모양(https://drive.google.com/file/d/<id>/view)
FILE_LINK_RE = re.compile(r"https://drive\.google\.com/file/d/([A-Za-z0-9_-]{10,})")
# 폴더 찾기·만들기는 한 번에 하나(같은 폴더가 두 개 생기지 않게). 파일 올리기·휴지통은 호출마다 따로 만든
# 서비스 객체로(googleapiclient 의 HTTP 는 스레드 안전하지 않다) — 큰 파일이 다른 사람 업로드를 막지 않게.
_FOLDER_LOCK = threading.Lock()
class GoogleDriveError(RuntimeError):
"""화면에 보여도 되는 사유(비밀값 없음)."""
def root_folder_id() -> str:
return (os.getenv("PROJECT_DRIVE_FOLDER_ID") or "").strip() or DEFAULT_FOLDER_ID
def file_url(file_id: str) -> str:
return f"https://drive.google.com/file/d/{file_id}/view"
def file_ids_in(html: str) -> set[str]:
"""설명 HTML 안의 드라이브 파일 링크 id 들."""
return set(FILE_LINK_RE.findall(html or ""))
def folder_name(name: Any) -> str:
"""폴더 이름 — 앞뒤 공백·줄바꿈 정리, 너무 길면 자름, 비면 "(이름 없음)"."""
s = re.sub(r"\s+", " ", str(name or "")).strip()[:120]
return s or "(이름 없음)"
def _q(value: str) -> str:
"""Drive 검색어 따옴표 안 글자(역슬래시·작은따옴표 이스케이프)."""
return value.replace("\\", "\\\\").replace("'", "\\'")
class GoogleDriveFiles(GoogleSlidesClient):
"""google_slides 의 인증(서비스 계정·OAuth)을 그대로 쓰고 Drive 만 연다."""
def __init__(self) -> None: # noqa: D107 — 부모 __init__ 대신(Slides 서비스는 만들지 않음)
self.enabled = False
self.reason = ""
self.auth_mode = ""
self._creds: Any = None
try:
import googleapiclient.discovery # noqa: F401
import googleapiclient.http # noqa: F401
except ImportError:
self.reason = "google-api-python-client 미설치"
return
creds = self._service_account_creds()
if creds is None:
creds = self._oauth_creds()
if creds is None:
if not self.reason:
self.reason = "Google 인증 미설정(GOOGLE_SHEETS_CREDENTIALS 또는 GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN 필요)"
return
self._creds = creds
self.enabled = True
def _service(self) -> Any:
from googleapiclient.discovery import build
return build("drive", "v3", credentials=self._creds, cache_discovery=False)
def _check(self) -> None:
if not self.enabled:
raise GoogleDriveError(self.reason or "Google 드라이브 연동이 꺼져 있습니다.")
# ────────────────────────────────────────────────
def ensure_folder_path(self, names: Iterable[str], *, root: str | None = None) -> str:
"""root 아래 names 순서대로 폴더를 찾거나 만들고 마지막 폴더 id."""
self._check()
parent = root or root_folder_id()
with _FOLDER_LOCK:
try:
drive = self._service()
for raw in names:
name = folder_name(raw)
q = (f"'{_q(parent)}' in parents and name = '{_q(name)}' and mimeType = '{FOLDER_MIME}' "
"and trashed = false")
res = drive.files().list(
q=q, fields="files(id)", pageSize=1, supportsAllDrives=True, includeItemsFromAllDrives=True,
corpora="allDrives", orderBy="createdTime",
).execute()
found = res.get("files") or []
if found:
parent = found[0]["id"]
continue
parent = drive.files().create(
body={"name": name, "mimeType": FOLDER_MIME, "parents": [parent]},
fields="id", supportsAllDrives=True,
).execute()["id"]
except GoogleDriveError:
raise
except Exception as exc: # noqa: BLE001
raise GoogleDriveError(_friendly_drive(exc)) from None
return parent
def upload(self, *, folder_id: str, name: str, stream: BinaryIO, mimetype: str, task_id: int) -> dict[str, Any]:
"""폴더에 파일 하나 → {id, name, url}. 이름은 원래 파일 이름.확장자 그대로."""
self._check()
from googleapiclient.http import MediaIoBaseUpload
try:
media = MediaIoBaseUpload(stream, mimetype=mimetype or "application/octet-stream", chunksize=CHUNK,
resumable=True)
meta = {"name": name, "parents": [folder_id], "appProperties": {TASK_KEY: str(int(task_id))}}
f = self._service().files().create(body=meta, media_body=media, fields="id,name",
supportsAllDrives=True).execute()
except Exception as exc: # noqa: BLE001
raise GoogleDriveError(_friendly_drive(exc)) from None
return {"id": f["id"], "name": f.get("name") or name, "url": file_url(f["id"])}
def ours(self, file_id: str) -> dict[str, Any] | None:
"""우리가 올린 파일이면 {trashed, task_id}, 아니면(남의 파일·없는 파일·권한 없음) None."""
self._check()
try:
f = self._service().files().get(fileId=file_id, fields="trashed,appProperties",
supportsAllDrives=True).execute()
except Exception: # noqa: BLE001 — 지워졌거나 볼 수 없는 파일은 건드리지 않는다
return None
tid = (f.get("appProperties") or {}).get(TASK_KEY)
if not tid:
return None
return {"trashed": bool(f.get("trashed")), "task_id": tid}
def set_trashed(self, file_id: str, trashed: bool) -> None:
self._check()
try:
self._service().files().update(fileId=file_id, body={"trashed": bool(trashed)},
supportsAllDrives=True).execute()
except Exception as exc: # noqa: BLE001
raise GoogleDriveError(_friendly_drive(exc)) from None
def _friendly_drive(exc: Exception) -> str:
status = getattr(getattr(exc, "resp", None), "status", None)
text = str(exc)
if "storageQuotaExceeded" in text or "do not have storage quota" in text:
return ("서비스 계정은 내 드라이브에 파일을 올릴 수 없습니다 — 업무 파일 폴더를 공유 드라이브에 두거나 "
"OAuth 토큰(GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN)을 쓰세요.")
if status == 404:
return "업무 파일 폴더를 찾을 수 없습니다(PROJECT_DRIVE_FOLDER_ID·폴더 공유 권한 확인)."
if status == 403 and "insufficient" not in text.lower():
return "Google 드라이브 접근이 거부되었습니다(폴더 편집 권한·Drive API 사용 설정 확인)."
return _friendly(exc).replace("Google 슬라이드 처리 실패", "Google 드라이브 처리 실패")
_CLIENT: GoogleDriveFiles | None = None
_CLIENT_LOCK = threading.Lock()
def get_client() -> GoogleDriveFiles:
"""프로세스당 하나(설정이 비어 있으면 매번 다시 확인 — .env 를 고치고 재시작 없이도 사유가 갱신되게)."""
global _CLIENT
with _CLIENT_LOCK:
if _CLIENT is None or not _CLIENT.enabled:
_CLIENT = GoogleDriveFiles()
return _CLIENT
+20
View File
@@ -24,6 +24,8 @@ from .modules.dispatch import build_dispatch_store
from .modules.dispatch import router as dispatch_router
from .modules.expense import CategoryStore, build_expense_store
from .modules.expense import router as expense_router
from .modules.inout import build_inout_items, build_inout_store
from .modules.inout import router as inout_router
from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store
from .modules.malaysia import router as malaysia_router
from .modules.notice import build_notice_store
@@ -59,6 +61,7 @@ MODULE_LABELS: dict[str, str] = {
"cafe24": "카페24 상품관리",
"performance": "실적",
"asset": "자산관리",
"inout": "입출고 관리",
"expense_approver": "개인경비",
"vacation_approver": "휴가",
}
@@ -153,6 +156,7 @@ _MODULE_TEMPLATE_DIRS = [
BASE_DIR / "modules" / "performance" / "templates",
BASE_DIR / "modules" / "asset" / "templates",
BASE_DIR / "modules" / "notice" / "templates",
BASE_DIR / "modules" / "inout" / "templates",
]
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.loader = ChoiceLoader(
@@ -218,6 +222,10 @@ app.state.performance_store = build_performance_store(dsn=env("PERFORMANCE_DB_UR
app.state.asset_store = build_asset_store(dsn=env("ASSET_DB_URL") or None)
# 긴급 공지(ERP 전체 화면 가운데): project_db 024 — 프로젝트 저장소의 연결 풀을 같이 쓴다(없으면 None → 503).
app.state.notice_store = build_notice_store(app.state.project_store)
# 입출고 관리(본사 → 공장 발주, 물류 입고, 미입고): INOUT_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내).
# 제품은 itemcode_db 단품(single_items) 읽기 전용 — ITEMCODE_DB_URL 재사용.
app.state.inout_store = build_inout_store(dsn=env("INOUT_DB_URL") or None)
app.state.inout_items = build_inout_items()
# 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄.
app.include_router(expense_router)
@@ -230,6 +238,7 @@ app.include_router(cafe24_router)
app.include_router(performance_router)
app.include_router(asset_router)
app.include_router(notice_router)
app.include_router(inout_router)
def public_url_for(request: Request, route_name: str) -> str:
@@ -422,6 +431,16 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
"status": "ready",
"category": "관리",
},
{
"key": "inout",
"title": "입출고 관리",
"subtitle": "Inbound",
"description": "본사에서 공장으로 넣은 제작 발주와 물류 입고 수량을 맞춰 보고, 미입고·초과 입고를 관리합니다.",
"url": "/inout/",
"health_url": "/inout/health",
"status": "ready",
"category": "운영",
},
]
items.append({
"key": "asset", "title": "자산관리", "subtitle": "Asset Management",
@@ -437,6 +456,7 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
def _icon_svg(name: str) -> str:
"""좌측 사이드바용 인라인 아이콘. 외부 의존 없는 작은 SVG."""
paths = {
"inout": '<path d="M3 7l9-4 9 4v10l-9 4-9-4z"/><path d="M3 7l9 4 9-4"/><path d="M12 11v10"/>',
"asset": '<rect x="3" y="3" width="18" height="13" rx="2"/><path d="M8 21h8M12 16v5"/><path d="M7 7h10M7 11h6"/>',
"home": '<path d="M3 11 12 3l9 8"/><path d="M5 10v10h14V10"/>',
"expense": '<rect x="3" y="6" width="18" height="13" rx="2"/><path d="M3 10h18"/><path d="M7 15h4"/>',
+9
View File
@@ -0,0 +1,9 @@
# [자산] 자산관리 모듈 — `app/modules/asset/`, `asset_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/ASSET_MODULE.md`.
> 정적 파일: `app/static/asset.css`, `app/static/asset.js`. 템플릿: `templates/`.
- 진입 `/asset/`, 권한키 `asset`. 사무집기·전산장비 개별 자산번호 등록.
- 배정/반납/상태·구매/보증·활동 이력, HWiNFO XML 사양/보고서 보존(`hwinfo.py`), 사진 갤러리(`media.py`), 보고서 모니터 자산(`monitors.py`).
- 삭제는 수퍼관리자(`SUPER_ADMIN_EMAIL`)만 — 이력/원본 보존.
- `ASSET_DB_URL` 미설정 시 저장 비활성, XML 분석 미리보기는 가능.
+36
View File
@@ -0,0 +1,36 @@
# [카페24] 카페24 상품관리 모듈 — `app/modules/cafe24/`, `cafe24_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/CAFE24_MODULE.md`(큰 문서 — `grep -n '^#'` 로 목차 보고 필요한 절만 읽기).
> 정적 파일: `app/static/cafe24.css`, `cafe24-options.js`. 템플릿: `templates/`. 테스트: `tests/`.
> 공통 API 계층: `app/integrations/cafe24/` — **실적 모듈 카페24 어댑터도 같은 토큰을 씀**, 바꾸면 실적 영향 확인.
> 배포 시 이 모듈 변경이면 `dbx-cafe24-worker` 도 같이 재빌드.
## 기능
- 카페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` 에 넣는 방식은 적용 안 됨.
- 옵션/품목 팝업(단일 옵션 화면) 「모바일 스와이프 코드 복사」: `// 상품명` + `"품목코드": "/web/…썸네일 경로",` 줄들을 클립보드로
(`cafe24-options.js` `swipeCode` — 행에 지금 보이는 썸네일 기준, 도메인/CDN 은 떼고 `/web/` 부터).
- 권한키 `cafe24`(연결/해제는 admin 전용).
## 규칙
- 카페24 OAuth/API 클라이언트는 향후 주문관리와 공유하기 위해 **공통 계층 `app/integrations/cafe24/`** 에 둔다 — 라우터에서 `httpx`/`requests` 직접 호출 금지.
- 토큰은 Fernet 암호화 저장(`CAFE24_TOKEN_SECRET`), 로그/화면에 토큰·시크릿 절대 미출력.
- 쓰기 직전 항상 카페24 현재 HTML 을 다시 읽어 `BACKUP` revision 생성(로컬 값을 현재값으로 가정 금지).
- 디자인 FTP(스와이프·상품상세) 쓰기는 임시 파일 → 검증 → rename. **카페24 FTP 는 허용 확장자만 받으므로 임시 이름도 원래 확장자로 끝나야 함**(`x_cf24tmp_<tag>.js`, `design_ftp.temp_names`). `x.js.cf24tmp-…` 는 `550 Operation not permitted`.
- 예약은 DB 저장 + 별도 worker(`worker.py`, compose 서비스 `dbx-cafe24-worker`)가 처리 — 웹 프로세스에서 대기하지 않는다.
## 읽기 지연 ("마지막 쓰기가 권위")
- **카페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`).
- 진열/판매만 바꾼 PUT 은 `updated_date` 가 안 오를 수 있음 → **같은 시각 + 값 다름 = 지연**.
- 단건 GET 뿐 아니라 **목록·예약 미리보기도 보정** 필수(`store.overlay_product_rows`). 빠뜨리면 "진열/중지 바꿔도 반영 안 됨"으로 보임.
- 유예시간 `CAFE24_READ_LAG_GRACE_MIN`(기본 360분).
- 쓰기 후 화면은 PUT 응답으로 그리고 다시 GET 하지 않는다.
- API 문서 예제는 apidocs.cafe24.com 청크 JS 에서 추출(예전 `/docs/code` JSON 은 404).
+21
View File
@@ -663,6 +663,27 @@ class Cafe24Store:
return {}
return dict(row["last_write_snapshot"])
def get_recent_product_snapshots(self, grace_minutes: int) -> dict[int, dict[str, Any]]:
"""유예시간 안에 쓴 상품들의 product 스냅샷 섹션 {product_no: {"data", "written_at"}}.
목록 화면이 상품마다 따로 조회하지 않고 한 번에 지연 보정하기 위한 것이다.
섹션별 written_at 판정은 store.overlay_recent_write 가 다시 한다.
"""
with self._pool.connection() as conn:
rows = conn.execute(
"""
SELECT product_no, last_write_snapshot -> 'product' AS product
FROM cafe24_products
WHERE last_written_at >= now() - make_interval(mins => %s)
AND last_write_snapshot ? 'product'
""",
(max(0, int(grace_minutes)),),
).fetchall()
return {
int(r["product_no"]): dict(r["product"])
for r in rows if isinstance(r.get("product"), dict)
}
# ════════════════════════════════════════════════════════════
# 상세페이지 HTML 버전 (append-only — UPDATE/DELETE 하지 않는다)
# 쓰기 직전 BACKUP 을 남기는 것이 유일한 복구 수단이다.
+7
View File
@@ -328,6 +328,13 @@ def product_list(request: Request) -> HTMLResponse:
error = ""
try:
raw_rows, truncated = products.list_all_products(api.client, product_name=keyword)
# 목록 API 도 쓰기 직후 한동안 예전 값을 준다 — 진열/판매 등을 최근 쓰기로 보정한다.
try:
snapshots = st.get_recent_product_snapshots(read_lag_grace_minutes())
except Exception: # noqa: BLE001 — 보정 실패는 목록 표시를 막지 않는다
logger.exception("카페24 최근 쓰기 스냅샷 조회 실패")
snapshots = {}
raw_rows = store.overlay_product_rows(raw_rows, snapshots, grace_minutes=read_lag_grace_minutes())
st.upsert_products([products.normalize_product(r) for r in raw_rows])
total = len(raw_rows)
rows = [_row_for_list(r) for r in raw_rows]
+2 -2
View File
@@ -26,7 +26,7 @@ from app.integrations.cafe24 import Cafe24Error, build_cafe24_api, load_config,
from . import store, writes
from .common import base_ctx, guard
from .routes_products import _no_store
from .routes_products import _no_store, load_product
logger = logging.getLogger("cafe24.schedules")
@@ -187,7 +187,7 @@ def schedule_current_flags(request: Request, product_no: int) -> dict:
st, _user = require_store(request)
api = build_cafe24_api(st)
try:
raw = products.get_product(api.client, product_no)
raw, _ = load_product(st, api, product_no) # 방금 바꾼 진열/판매가 지연으로 예전 값이 되지 않게
except Cafe24Error as exc:
return {"product_no": product_no, "error": str(exc)}
normalized = products.normalize_product(raw)
+53 -1
View File
@@ -640,6 +640,12 @@ def overlay_recent_write(
보다 GET 의 updated_date 가 **이전**이면 GET 이 아직 예전 레코드를 돌려주는
것이다. 우리 서버 시계와 비교하지 않으므로 시계 차이에 영향받지 않는다.
날짜가 없어 판정할 수 없으면 카페24 값을 그대로 둔다.
두 updated_date 가 **같을** 때: 카페24는 진열/판매만 바꾼 PUT 에서 updated_date 를
올리지 않을 수 있다. 그러면 지연된 GET 도 같은 시각을 돌려주므로 "같다 = 따라잡음"
으로 보면 예전 진열/판매가 그대로 보인다(실제 발생 — 바꿔도 반영 안 된 것처럼 보임).
같은 시각인데 값이 다르면 카페24 기준으로 그 뒤 수정된 근거가 없으므로 지연으로 본다.
GET 이 **이후** 시각이면 관리자 등에서 다시 고친 것 — 카페24 값을 믿는다.
반환: (병합된 상품 dict, 지연 여부)
"""
if not snapshot:
@@ -648,7 +654,9 @@ def overlay_recent_write(
return fetched, False
fetched_at = _as_aware(fetched.get("updated_date"))
snap_at = _as_aware(snapshot.get("updated_date"))
if fetched_at is None or snap_at is None or fetched_at >= snap_at:
if fetched_at is None or snap_at is None or fetched_at > snap_at:
return fetched, False
if fetched_at == snap_at and not _snapshot_differs(fetched, snapshot):
return fetched, False
merged = dict(fetched)
for key in SNAPSHOT_FIELDS:
@@ -658,6 +666,50 @@ def overlay_recent_write(
return merged, True
def _snapshot_differs(fetched: dict, snapshot: dict) -> bool:
"""GET 에 있는 스냅샷 필드 중 값이 다른 것이 있는가(문자열로 비교 — 둘 다 카페24 원본 모양)."""
for key in SNAPSHOT_FIELDS:
if key == "updated_date" or key not in snapshot or key not in fetched:
continue
if fetched[key] is None:
continue
if str(fetched[key]) != str(snapshot[key]):
return True
return False
def overlay_product_rows(
rows: list[dict],
snapshots: dict,
*,
grace_minutes: int,
now: datetime | None = None,
) -> list[dict]:
"""목록(GET /admin/products) 행마다 최근 쓰기 스냅샷을 덮어씌운다.
snapshots: {product_no: {"data": 스냅샷, "written_at": ISO}} — 스냅샷 product 섹션.
목록 API 도 단건 GET 과 똑같이 읽기 지연이 있다. 보정하지 않으면 진열/판매를 바꾼
뒤 목록을 다시 불러올 때 예전 상태로 보이고(필터에 걸려 사라지기도 한다), 그 값이
캐시(cafe24_products)에도 다시 저장된다.
"""
if not snapshots:
return rows
out: list[dict] = []
for row in rows:
try:
no = int(row.get("product_no") or 0)
except (TypeError, ValueError):
no = 0
section = snapshots.get(no) if no else None
if isinstance(section, dict) and section.get("data"):
row, _ = overlay_recent_write(
row, snapshot=section.get("data"), written_at=section.get("written_at"),
grace_minutes=grace_minutes, now=now,
)
out.append(row)
return out
# ── 품목 스냅샷: 코드별 · 필드별 병합 ──
# 스냅샷 모양: {variant_code: {필드: 값, ..., "_at": ISO, "_deleted": bool,
# "options": [{name,value}...], "_options_before": [...]}}
@@ -125,7 +125,7 @@
{% endblock %}
{% block scripts %}
<script src="/static/cafe24-options.js?v=20260928c"></script>
<script src="/static/cafe24-options.js?v=20261020a"></script>
<script>
(function () {
var pane = document.getElementById("cf24-editor-pane");
+14
View File
@@ -193,6 +193,9 @@ class MemoryStore:
def get_write_snapshot(self, product_no):
return dict(self.snapshots.get(int(product_no), {}))
def get_recent_product_snapshots(self, grace_minutes):
return {no: dict(snap["product"]) for no, snap in self.snapshots.items() if snap.get("product")}
# ── 예약 ──
def add_schedule(self, **fields):
sid = next(self._ids)
@@ -475,10 +478,20 @@ class FakeFTP:
raise ftplib.error_perm("550 No such file")
callback(self.files[path])
# 카페24 디자인 FTP 는 허용 확장자만 받는다(실물: `x.js.cf24tmp-…` STOR → 550).
ALLOWED_EXT = (".js", ".html", ".htm", ".css", ".json", ".txt", ".xml",
".jpg", ".jpeg", ".gif", ".png", ".svg", ".webp")
@classmethod
def _check_ext(cls, path):
if not path.lower().endswith(cls.ALLOWED_EXT):
raise ftplib.error_perm(f"550 {path}: Operation not permitted")
def storbinary(self, cmd, fp):
path = cmd.split(" ", 1)[1]
data = fp.read()
FakeFTP.log.append(("STOR", path))
self._check_ext(path)
self.files[path] = data[: len(data) // 2] if FakeFTP.truncate_store else data
def rename(self, src, dst):
@@ -490,6 +503,7 @@ class FakeFTP:
raise ftplib.error_perm("502 RNFR not implemented")
if src not in self.files:
raise ftplib.error_perm("550 No such file")
self._check_ext(dst)
if dst in self.files and FakeFTP.rename_mode == "no_overwrite":
raise ftplib.error_perm("553 File exists")
self.files[dst] = self.files.pop(src)
+66 -1
View File
@@ -746,7 +746,7 @@ def test_design_ftp_read_and_write_roundtrip():
assert design_ftp.read_text_file(_FTP_CFG, _SWIPER) == "new content"
# 원본에 직접 STOR 하지 않는다 — 임시 파일에 올린 뒤 이름 바꾸기로 교체
stors = [e for e in ftp.log if e[0] == "STOR"]
assert stors and all(".cf24tmp-" in e[1] for e in stors), ftp.log
assert stors and all("_cf24tmp_" in e[1] and e[1].endswith(".js") for e in stors), ftp.log
assert any(e[0] == "RENAME" and e[2] == _SWIPER for e in ftp.log)
# 임시 파일이 남지 않는다
assert set(ftp.files) == {_SWIPER}
@@ -1127,6 +1127,71 @@ def test_product_snapshot_keeps_only_scalar_fields():
assert snap == {"product_name": "A", "price": "1.00", "display": "T"}
def test_overlay_same_updated_date_but_different_flags_is_lag():
# 카페24는 진열/판매만 바꾼 PUT 에서 updated_date 를 안 올릴 수 있다 — 같은 시각에 값이
# 다르면 지연이다(예전엔 "같다 = 따라잡음"으로 봐서 바꾼 진열/판매가 되돌아 보였다).
fetched = {"display": "T", "selling": "T", "updated_date": "2026-09-18T10:00:00+09:00"}
snap = {"display": "F", "selling": "T", "updated_date": "2026-09-18T10:00:00+09:00"}
merged, stale = store.overlay_recent_write(fetched, snapshot=snap, written_at=now_kst(), grace_minutes=60)
assert stale is True and merged["display"] == "F"
def test_overlay_same_updated_date_and_same_values_is_caught_up():
fetched = {"display": "F", "price": "1.00", "updated_date": "2026-09-18T10:00:00+09:00"}
snap = {"display": "F", "price": "1.00", "updated_date": "2026-09-18T10:00:00+09:00"}
merged, stale = store.overlay_recent_write(fetched, snapshot=snap, written_at=now_kst(), grace_minutes=60)
assert stale is False and merged is fetched
def test_overlay_product_rows_fixes_lagging_list():
rows = [
{"product_no": 1, "display": "T", "selling": "T", "updated_date": "2026-09-18T10:00:00+09:00"},
{"product_no": 2, "display": "T", "selling": "T", "updated_date": "2026-09-18T10:00:00+09:00"},
]
snaps = {1: {"data": {"display": "T", "selling": "F", "updated_date": "2026-09-18T10:00:00+09:00"},
"written_at": now_kst().isoformat()}}
out = store.overlay_product_rows(rows, snaps, grace_minutes=60)
assert out[0]["selling"] == "F"
assert out[1] is rows[1]
assert store.overlay_product_rows(rows, {}, grace_minutes=60) is rows
def test_status_toggle_survives_read_lag_without_updated_date_bump():
"""진열/판매 배지 → PUT → 다시 열어도(단건·목록) 바꾼 값이 보인다.
실물 재현 조건: PUT 이 updated_date 를 올리지 않고, GET 은 한동안 예전 값을 준다.
"""
from app.modules.cafe24 import routes_products
st = fakes.MemoryStore()
cafe = fakes.FakeCafe24()
api = fakes.FakeApi(cafe)
cafe._tick = lambda: None # 진열/판매만 바꾸면 updated_date 그대로
cafe.stale = dict(cafe.state) # GET 은 바꾸기 전 값(읽기 지연)
orig = (routes_products.require_store, routes_products.build_cafe24_api)
routes_products.require_store = lambda request: (st, {"email": "a@b.c"})
routes_products.build_cafe24_api = lambda _st: api
try:
res = routes_products.product_status(None, 131, {"field": "selling", "value": False})
assert res == {"ok": True, "display": True, "selling": False}
assert cafe.state["selling"] == "F"
assert cafe.puts()[-1][2]["request"] == {"selling": "F"}
product, stale = routes_products.load_product(st, api, 131)
assert stale is True and products.normalize_product(product)["selling"] is False
rows = store.overlay_product_rows(
[dict(cafe.stale)], st.get_recent_product_snapshots(60), grace_minutes=60
)
assert products.normalize_product(rows[0])["selling"] is False
# 다시 켜기 — 값은 요청한 결과값 그대로(뒤집기 아님)
res = routes_products.product_status(None, 131, {"field": "selling", "value": True})
assert res["selling"] is True and cafe.state["selling"] == "T"
finally:
routes_products.require_store, routes_products.build_cafe24_api = orig
# ════════════════════════════════════════════════════════════
# 기본 정보 · 옵션 · 품목 입력 검증
# ════════════════════════════════════════════════════════════
+3
View File
@@ -232,6 +232,9 @@ def resolve_effective(
# ════════════════════════════════════════════════════════════
def remember_product_write(st: Any, product_no: int, updated: dict[str, Any]) -> tuple[dict[str, Any], str]:
"""PUT 응답(상품 dict)을 캐시·스냅샷에 남긴다. (정규화된 상품 행, 기록 오류 문자열)."""
if updated and not updated.get("product_no"):
# 응답에 상품번호가 빠져도 기록은 남긴다 — 안 남기면 지연 보정이 안 돼 예전 값이 보인다.
updated = {**updated, "product_no": int(product_no)}
info = products.normalize_product(updated) if updated else {}
if not info.get("product_no"):
return info, ""
+47
View File
@@ -0,0 +1,47 @@
# [쿠팡] 쿠팡 밀크런 모듈 — `app/modules/cupang/`, `cupang_db`
> 이 모듈만 고칠 때 읽는 요약. 별도 상세 문서 없음 — 이 파일이 기준.
> 정적 파일: `app/static/cupang.css`, `app/static/cupang.js`. 템플릿: `templates/`.
> 상품은 `itemcode_db` 읽기 전용(`itemcode.py`).
## 출고 달력 / 상자 계산
- 출고 달력·상자 계산이 중심.
- 출고 묶음은 **상자 계산 화면의 [분배 확정] 으로만** 만든다. 신규 등록 폼 없음, `/cupang/new` 는 상자 계산으로 리다이렉트.
- 확정 조건: 미배분 상자 0 + 담긴 센터마다 출고방식(택배/파렛트) 선택.
- 확정 시 센터마다 출고 묶음 1건(`status=출고준비`, 센터입고일 = 출고일 + 1일).
- 상자 구성은 `cupang_shipments.box_plan` JSONB 에 스냅샷(혼합 상자 내용물·상자 종류 표시용).
- 출고리스트 엑셀 자동 다운로드(`GET /cupang/export.xlsx?date=`, 시트명 YYYYMMDD).
- 양식 생성은 `export.py` 한 곳에서 만들어 xlsx·구글시트가 공유.
- 작업 중 상태는 `cupang_box_calc_drafts` 에 이름 붙여 임시 저장/불러오기.
## 구글 시트 동기화
- `CUPANG_SHEET_ID` + 인증(사용자 OAuth `GOOGLE_SHEETS_OAUTH_REFRESH_TOKEN` 또는 서비스 계정 `GOOGLE_SHEETS_CREDENTIALS[_JSON]`) 설정 시
확정과 동시에 Google 스프레드시트에 출고일 시트를 생성/덮어쓰기(`app/integrations/google_sheets.py`, 미설정이면 조용히 skip).
- 출고 삭제(건별/날짜 전체) 시에도 같은 날짜 시트 동기화 — 남은 출고가 있으면 다시 쓰고, 없으면 시트 삭제
(문서에 시트가 하나뿐이면 내용만 비움).
## 제품 포장무게
- 설정(제품명)에서 제품별 포장무게(g, `cupang_products.weight_g`, 마이그레이션 007 + 시드) 입력·표시·정렬.
- 출고 상세 상자 목록에 상자별 무게 합계(수량 × 지금 포장무게, `router._attach_box_weights`).
- 무게 없는 제품은 "일부 미입력".
- 화면은 kg 소수 첫째 자리 사사오입(`router._g_to_kg`) + 맨 아래 수량·무게 합계 행(앞 3열 병합).
- 표 칸 모두 가운데 정렬, 요약 카드와 20px 간격.
- 상자 목록 엑셀에도 무게(g) 열.
## 쿠팡 발주 엑셀 업로드
- 다중 업로드(`POST /cupang/api/box-calc/upload`, openpyxl).
- F13 입고예정일의 하루 전 = 출고일.
- 22행부터 B=쿠팡상품코드·F=센터명·G=수량을 읽어 `cupang_products.coupang_item_code` 로 제품 매칭 → 센터별 합산
→ 센터 단위로 상자 계산·자동 배분.
## 쿠팡 로켓 매출 (`/cupang/sales`)
- 테이블 `cupang_sales`·`cupang_sales_weekly`. 발주 라인별 공급가·원가·물류비·마진 표.
- 기간/센터/유형/검색 조회, 행 CRUD, 엑셀 다운로드.
- 구글 시트 양식 xlsx·csv 업로드(`sales_import.py`) — 같은 발주번호+SKU+출고일+센터+수량은 덮어씀.
- 광고비·할인 프로모션·장려금은 주차 단위(`cupang_sales_weekly`)로 보관, 순마진은 화면에서 계산.
- 초기 데이터는 `scripts/sql/cupang_sales_seed.sql`.
+13
View File
@@ -0,0 +1,13 @@
# [배송] 말레이시아 배송 모듈 — `app/modules/dispatch/`, `dispatch_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/DISPATCH_MODULE.md`.
> 정적 파일: `app/static/dispatch/`. 템플릿: `templates/`. 테스트: `tests/`.
- TikTok·Shopee 출고관리. 권한키 `dispatch`.
- 플랫폼별 데이터 엑셀 업로드(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 파싱/생성.
+4
View File
@@ -0,0 +1,4 @@
# [경비] 개인경비 모듈 — `app/modules/expense/`, `expense_db`
> 이 모듈만 고칠 때 읽는 요약. 별도 상세 문서 없음 — 코드(`router.py`·`store.py`·`categories.py`)가 기준.
> 템플릿: `templates/`. DB 구성은 필요할 때만 `docs/DATABASES.md` 의 expense_db 절.
+66
View File
@@ -0,0 +1,66 @@
# [입출고] 입출고 관리 모듈 — `app/modules/inout/`, `inout_db`(2026-10-16)
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/INOUT_MODULE.md`.
> 정적 파일: `app/static/inout.css`, `inout.js`. 템플릿: `templates/`.
> 상품은 `itemcode_db.single_items` 읽기 전용(`itemcode.py`). `APP_ENCRYPTION_KEY` 는 실적 모듈과 공유.
> 참고 모델: 이카운트 "발주 대비 미입고"·Odoo 분할 입고/종결.
## 발주 / 입고
- 본사 → 공장 제품 제작 발주(발주서 `PO-YYMMDD-NN`). 제품 = `itemcode_db.single_items` 단품만, 검색 `GET /inout/api/items`·저장 때 서버 재확인.
- 물류 입고를 여러 번 나눠 입력, 품목별 발주·입고·미입고.
- 미입고 현황(제품별 합계·발주별·지연).
- [남은 수량 모두 채우기]를 한 번 더 누르면(= [채운 수량 되돌리기]) 채우기 전 값으로(2026-10-19, `inout.js`).
- 초과 입고는 확인 화면 후 허용(트랜잭션 안에서 발주서 잠그고 판단, `confirm_over`).
- **전체 입고 완료(모든 품목 입고 ≥ 발주, 상태 done·over)면 더 입고 못 함**(2026-10-19) — 화면은 입고 칸·[입고 저장]·사진·[남은 수량 채우기]를 흐리게 disabled, 서버 `_add_receipt` 도 잠근 뒤 거절. 입고 기록을 지우면 다시 열림.
- 잔량 종결·취소(취소는 입고 없을 때만).
- 상태는 저장하지 않고 누적 입고로 계산(`store.order_status`).
- 모든 품목 입고완료·초과입고 = "✓ 전체 입고 완료"(초과면 "초과 포함", `order_badge`).
- 발주 삭제는 **수퍼관리자만**(발주 목록 🗑, `perms.super`, 입고·사진·메일 기록까지 CASCADE).
## 권한 / 옵션
- 권한키 `inout`(조회).
- **발주 담당·입고 담당·공장(담당자·연락처 따로, 002)은 모듈 옵션** — 상단 톱니 → 팝업(`/inout/settings?panel=1`, ERP 관리자, `inout_roles`·`inout_factories`). 관리자는 둘 다.
- 공용 `.erp-input`·`.erp-table-wrap` 겹침은 `.io` 안에서만 바로잡음.
- **입고 담당(발주 담당 아님)은 품목을 이름·발주 수량만**(`items_limited`), 옵션은 관리자만.
## 발주 메일 (003)
- 새 발주서 저장 → 미리보기 팝업(받는 사람 = 공장 이메일, 요약 표 본문) → 사람이 [메일 발송]을 눌러야 보냄.
- **발주 담당 본인 Gmail**(Gmail API `gmail.send`, 사람마다 [Gmail 연결] 1회 — 고른 구글 계정 = ERP 계정 확인). 갱신 토큰은 `APP_ENCRYPTION_KEY` AES-GCM 암호문(`gmail.py`).
- 보낸 기록·재발송 확인.
- **입고 담당 발주 알림 자동 발송**(2026-10-19): 발주 메일이 나가면 같은 Gmail 로 옵션 → 담당자의 입고 담당들에게 따로 보냄 — 제목은 발주 메일과 같고 내용은 발주번호·발주일·제품 코드·제품명·수량만(`store.order_notice_mail`, `router._send_order_notice`). 실패해도 공장 메일은 그대로(안내만), 미리보기 창에 받을 사람 안내.
- **참조 기본값 `king@dbxcorp.co.kr`**(2026-10-19) — 미리보기 참조 칸에 미리 들어감, 옵션 → 공장 탭 "발주 메일 참조"에서 고침(`inout_settings` `order_mail_cc`, 행이 없으면 기본값 — 저장만 005 필요).
## 입고 요청 메일 (005, 2026-10-19)
- 입고 담당이 **입고 저장** → 발주서 화면 `?rmail={입고 id}` 로 미리보기 팝업이 바로 뜸 → [메일 발송](입고 담당 본인 Gmail, 발주 메일과 같은 연결 — Gmail 연결 권한은 발주·입고 담당 `_require(…, "mail")`). 입고 기록 줄 [보내기/다시 보내기]로 언제든.
- 받는 사람 = 옵션 → **물류센터** 탭 담당자 이메일(`inout_settings` `logistics_emails`), 참조 기본 = `receipt_mail_cc`(005 가 `king@dbxcorp.co.kr, bj@dbxcorp.co.kr` 넣음). 창에서 고칠 수 있음.
- 제목 `[입고 요청] yyyy년 mm월 dd일(요일) 입고 요청 합니다.`(입고일) · 본문 "입고된 아래 리스트 상품을 전산 등록 부탁드립니다." + 표(상품 이름·상품 코드·입고 수량·비고 = 발주 품목 줄 메모, 합계) + 메모 + **맨 아래 입고증 사진 = 본문 안 이미지**(CID `multipart/related`, 첨부 아님 — `gmail.build_message(inline_images=)`), 서버가 가로 600px 이하·비율 유지 JPEG 로 줄임(`store.mail_images`, EXIF 회전 반영, HEIC 는 빼고 안내). 미리보기는 cid → data: 로 바꿔 보여 줌.
- 보낸 기록 `inout_receipt_mails`(입고 지우면 CASCADE), 이미 보낸 입고는 `resend` 확인.
## 사방넷 입고 파일 (2026-10-19, 마이그레이션 없음)
- 입고 기록 줄 [사방넷 입고 파일](엑셀 초록 `#217346`) → `GET /inout/orders/{id}/receipts/{rid}/sabangnet.xlsx`(발주·입고 담당). 1행 제목 **A 상품코드 · B 가용수량 · C 불용수량**,
A = 코드표 `single_items.sabangnet_code`(`itemcode.sabangnet_codes`), B = 입고 수량, **C = 수량이 아니라 상품 이름**(사용자 지정). A·C 는 글자 칸(앞자리 0 보존).
- 사방넷 코드가 빈 품목이 있거나 코드표를 못 읽으면 파일을 만들지 않고 발주서로 돌아가 품목을 알려 준다(빈 칸 업로드 방지). 파일 이름 `사방넷_입고_{입고일}_{발주번호}.xlsx`.
## 입고증 사진 (003)
- 입고 저장 때 첨부(브라우저가 2000px JPEG 로 줄임, 10장·10MB, 파일 머리 검사, 입고와 한 트랜잭션, bytea).
- 썸네일·크게 보기·나중에 더하기. 초과 확인은 브라우저가 먼저(사진 유지).
## 상품 정보 (004, 옵션 세 번째 탭)
- 테이블 `inout_products`·`inout_products_excluded`.
- [단품 불러오기] = 코드표 단품 → 목록(값을 넣은 상품은 그대로·지운 단품은 다음에도 빠짐, 제외 목록에서 되살리기).
- 단가(원)·무게(개당 g = PP량)·은(Ag) 함유량(%) 수기 입력(은 g = 무게 × % 자동).
- 한 번 불러오면 발주서 제품은 이 목록에서. 발주 품목에 그때 값 사본(`unit_price`·`weight_g`·`silver_pct`).
- 발주서·메일에 금액(수량 × 단가)·PP·은 함유량과 합계.
- **발주 메일 표**(2026-10-19, `store.order_mail`): 전체 무게(kg) = 개당 g × 수량 · **PP 사용량(kg)** = 전체 무게 − 은 무게(은 함유량 왼쪽 열) · 은(Ag) 함유량 = `30% (76.5kg)`(괄호 = 전체 무게 × %, kg 소수 넷째). 합계 줄·요약(전체 무게·PP 사용량·은 총량)도 kg. 첫 요약 표는 항목·값 두 쌍씩 4열(4×4), 요청 사항은 맨 아래 한 줄 전체. 발주서 화면 표는 예전 그대로(PP g/개).
## 시각 / 날짜
- 시각은 DB 시간대와 무관하게 KST 로 읽음(`db._KstTimestamptzLoader`).
- 날짜 서식은 모두 `yyyy.mm.dd(요일)`(`ymd`·`ymdhm` 매크로, `store.fmt_date`).
+32
View File
@@ -0,0 +1,32 @@
"""입출고 관리(inout) 모듈 — 본사 → 공장 제품 제작 발주, 물류 입고(분할), 발주 대비 미입고·초과 관리.
- 라우터: `router.py` (prefix=/inout)
- 저장소: `db.py` (inout_db / PostgreSQL) + `store.py` (상태·검사, 순수 함수)
- 제품: `itemcode.py` — itemcode_db.single_items(단품) 읽기 전용(ITEMCODE_DB_URL 재사용)
- 템플릿: `templates/inout/`, 화면 스크립트·스타일 `static/inout.{js,css}`
INOUT_DB_URL 미설정이면 build_inout_store 가 None → 라우터가 "설정 필요" 안내(앱은 죽지 않음).
권한: 모듈 권한키 `inout`(조회), 발주 담당·입고 담당은 모듈 옵션(inout_roles)에서 지정, ERP 관리자는 둘 다 + 옵션.
상세 docs/INOUT_MODULE.md.
"""
from typing import Any
from .router import router
__all__ = ["router", "build_inout_store", "build_inout_items"]
def build_inout_store(*, dsn: str | None) -> Any:
if not dsn:
return None
from .db import InoutDBStore # 지연 import
return InoutDBStore(dsn)
def build_inout_items() -> Any:
"""코드표 단품 리더(ITEMCODE_DB_URL). 미설정이면 enabled=False."""
from .itemcode import SingleItemReader # 지연 import
return SingleItemReader()
+669
View File
@@ -0,0 +1,669 @@
"""inout_db PostgreSQL 저장소 — 공장·담당자·발주서·입고.
- 드라이버: psycopg 3 + pool(다른 모듈과 같은 패턴), 연결 `INOUT_DB_URL`. 스키마는 scripts/sql/inout_db_init.sql(앱이 만들지 않음).
- 상태(발주·부분입고·입고완료·초과·종결·취소)는 저장하지 않고 품목별 누적 입고로 계산한다(store.order_status) — 어긋날 일이 없다.
- 쓰기는 한 트랜잭션. 입고 저장은 발주서 행을 잠그고(FOR UPDATE) 그 안에서 누적 입고를 다시 읽어 초과를 판단한다
(두 사람이 동시에 입고해도 초과 확인을 건너뛰지 않게).
"""
from __future__ import annotations
from datetime import date, datetime
from typing import Any
from psycopg.errors import UndefinedColumn, UndefinedTable
from psycopg.rows import dict_row
from psycopg.types.datetime import TimestamptzLoader
from psycopg_pool import ConnectionPool
from app.timezone import KST
from . import store
_SCAN_LIMIT = 20000 # 목록에서 상태 거르기 전에 읽는 발주서 상한
class OverReceipt(Exception):
"""확인 없이 발주보다 많이 입고하려 함 — over = [{item_code, item_name, ordered, after, over}]."""
def __init__(self, over: list[dict[str, Any]]) -> None:
super().__init__("초과 입고")
self.over = over
def _norm_email(e: str) -> str:
return (e or "").strip().lower()
class _KstTimestamptzLoader(TimestamptzLoader):
"""TIMESTAMPTZ → 한국 시각(KST) datetime. 화면·메일에 찍는 시각(입력·보낸 시각 등)이 DB 서버 시간대(보통 UTC)와 무관하게."""
def load(self, data: Any) -> datetime:
return super().load(data).astimezone(KST)
def _kst_session(conn: Any) -> None:
# 세션 시간대(SET TIME ZONE)는 쓰지 않는다 — 'Asia/Seoul' 은 시간대 자료가 없는 서버에서 접속이 실패하고,
# 고정 오프셋은 psycopg 가 못 읽어 UTC 로 돌아간다. 읽을 때 파이썬에서 바꾼다.
conn.adapters.register_loader("timestamptz", _KstTimestamptzLoader)
class InoutDBStore:
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}, configure=_kst_session, open=False)
self._pool.open(wait=False)
def close(self) -> None:
self._pool.close()
# ════════════════════════════════════════════════════════════
# 공장
# ════════════════════════════════════════════════════════════
def list_factories(self, *, include_inactive: bool = False) -> list[dict[str, Any]]:
where = "" if include_inactive else "WHERE f.is_active"
with self._pool.connection() as conn:
return conn.execute(
"SELECT f.*, (SELECT count(*) FROM inout_orders o WHERE o.factory_id = f.id) AS order_count "
f"FROM inout_factories f {where} ORDER BY f.is_active DESC, f.sort_order, f.name"
).fetchall()
def save_factory(self, *, factory_id: int | None, name: str, manager: str = "", contact: str = "", email: str = "",
memo: str = "", is_active: bool = True, sort_order: int = 0) -> int:
"""공장 추가·수정. 담당자(manager, 002)·연락처(contact)·이메일(email, 003 — 여러 개는 쉼표)."""
name = (name or "").strip()
if not name or len(name) > 100:
raise ValueError("공장 이름을 1~100자로 입력하세요.")
emails = ", ".join(store.parse_emails(email, label="공장 이메일"))
vals = (name, (manager or "").strip()[:100], (contact or "").strip()[:200], emails, (memo or "").strip()[:store.MEMO_MAX],
bool(is_active), int(sort_order))
try:
with self._pool.connection() as conn:
dup = conn.execute("SELECT id FROM inout_factories WHERE lower(name) = lower(%s) AND id <> %s",
(name, factory_id or 0)).fetchone()
if dup:
raise ValueError(f"같은 이름의 공장이 이미 있습니다: {name}")
if factory_id:
row = conn.execute(
"UPDATE inout_factories SET name=%s, manager=%s, contact=%s, email=%s, memo=%s, is_active=%s, sort_order=%s "
"WHERE id=%s RETURNING id", (*vals, factory_id)).fetchone()
if not row:
raise ValueError("공장을 찾을 수 없습니다.")
return int(row["id"])
return int(conn.execute(
"INSERT INTO inout_factories (name, manager, contact, email, memo, is_active, sort_order) "
"VALUES (%s,%s,%s,%s,%s,%s,%s) RETURNING id", vals).fetchone()["id"])
except UndefinedColumn:
raise ValueError("DB 마이그레이션 inout_db 002·003(공장 담당자·이메일 칸)이 아직 적용되지 않았습니다.") from None
def delete_factory(self, factory_id: int) -> None:
"""발주 기록이 없는 공장만 지운다(있으면 '사용 안 함'으로 숨김)."""
with self._pool.connection() as conn:
used = conn.execute("SELECT 1 FROM inout_orders WHERE factory_id=%s LIMIT 1", (factory_id,)).fetchone()
if used:
raise ValueError("발주 기록이 있는 공장은 지울 수 없습니다 — '사용 안 함'으로 바꾸세요.")
conn.execute("DELETE FROM inout_factories WHERE id=%s", (factory_id,))
# ════════════════════════════════════════════════════════════
# 담당자(발주 담당·입고 담당)
# ════════════════════════════════════════════════════════════
def list_roles(self) -> dict[str, list[str]]:
out: dict[str, list[str]] = {r: [] for r in store.ROLES}
with self._pool.connection() as conn:
for r in conn.execute("SELECT email, role FROM inout_roles ORDER BY email").fetchall():
out.setdefault(r["role"], []).append(r["email"])
return out
def roles_of(self, email: str) -> set[str]:
with self._pool.connection() as conn:
rows = conn.execute("SELECT role FROM inout_roles WHERE email=%s", (_norm_email(email),)).fetchall()
return {r["role"] for r in rows}
def set_role_members(self, role: str, emails: list[str], *, by: str) -> None:
"""그 역할 담당자를 통째로 바꾼다(한 트랜잭션)."""
if role not in store.ROLES:
raise ValueError("알 수 없는 담당 종류입니다.")
clean = sorted({_norm_email(e) for e in emails if _norm_email(e)})
with self._pool.connection() as conn, conn.transaction():
conn.execute("DELETE FROM inout_roles WHERE role=%s AND NOT (email = ANY(%s))", (role, clean))
for e in clean:
conn.execute("INSERT INTO inout_roles (email, role, created_by) VALUES (%s,%s,%s) ON CONFLICT DO NOTHING",
(e, role, _norm_email(by)))
# ════════════════════════════════════════════════════════════
# 발주서
# ════════════════════════════════════════════════════════════
def _insert_line(self, conn: Any, order_id: int, line_no: int, ln: dict[str, Any], names: dict[str, str],
specs: dict[str, dict[str, Any]]) -> None:
"""발주 품목 한 줄 — 004 가 적용됐으면 상품 정보의 단가·무게·은 함유량을 그때 값으로 함께 남긴다."""
if self.products_ready():
sp = specs.get(ln["item_code"]) or {}
conn.execute("INSERT INTO inout_order_lines (order_id, line_no, item_code, item_name, qty, memo, unit_price, weight_g, silver_pct) "
"VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s)",
(order_id, line_no, ln["item_code"], names.get(ln["item_code"], ""), ln["qty"], ln["memo"],
sp.get("unit_price"), sp.get("weight_g"), sp.get("silver_pct")))
else:
conn.execute("INSERT INTO inout_order_lines (order_id, line_no, item_code, item_name, qty, memo) VALUES (%s,%s,%s,%s,%s,%s)",
(order_id, line_no, ln["item_code"], names.get(ln["item_code"], ""), ln["qty"], ln["memo"]))
def create_order(self, data: dict[str, Any], names: dict[str, str], *, by: str,
specs: dict[str, dict[str, Any]] | None = None) -> dict[str, Any]:
"""data = store.validate_order 결과, names = {코드: 단품 이름}, specs = {코드: 상품 정보 행}(004). 반환 {id, order_no}."""
with self._pool.connection() as conn, conn.transaction():
self._require_factory(conn, data["factory_id"])
conn.execute("SELECT pg_advisory_xact_lock(hashtext('inout_order_no'))")
prefix = store.order_no(data["order_date"], 0)[:-2]
# 순번은 숫자로 비교 — 글자 max 면 "-99" 가 "-100" 보다 커서 100번째부터 같은 번호가 나온다
row = conn.execute("SELECT max(substr(order_no, %s)::int) AS m FROM inout_orders "
"WHERE order_no LIKE %s AND substr(order_no, %s) ~ '^[0-9]{1,9}$'",
(len(prefix) + 1, prefix + "%", len(prefix) + 1)).fetchone()
seq = (row["m"] or 0) + 1 if row else 1
no = store.order_no(data["order_date"], seq)
oid = conn.execute(
"INSERT INTO inout_orders (order_no, factory_id, order_date, due_date, memo, created_by, updated_by) "
"VALUES (%s,%s,%s,%s,%s,%s,%s) RETURNING id",
(no, data["factory_id"], data["order_date"], data["due_date"], data["memo"], _norm_email(by), _norm_email(by)),
).fetchone()["id"]
for i, ln in enumerate(data["lines"], start=1):
self._insert_line(conn, oid, i, ln, names, specs or {})
return {"id": int(oid), "order_no": no}
def update_order(self, order_id: int, data: dict[str, Any], names: dict[str, str], *, by: str,
specs: dict[str, dict[str, Any]] | None = None) -> None:
"""머리글·품목 고치기. 입고된 품목은 뺄 수 없다(입고 기록이 사라지므로) — 수량은 바꿀 수 있다.
이미 있던 품목의 단가 등 사본은 그대로(발주 당시 값), 새로 넣은 품목만 지금 상품 정보 값으로(004)."""
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서는 고칠 수 없습니다.")
self._require_factory(conn, data["factory_id"], allow_inactive_id=head["factory_id"])
existing = {r["item_code"]: r for r in conn.execute(
"SELECT l.id, l.item_code, COALESCE(sum(rl.qty), 0) AS received FROM inout_order_lines l "
"LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id WHERE l.order_id=%s GROUP BY l.id",
(order_id,)).fetchall()}
wanted = {ln["item_code"] for ln in data["lines"]}
blocked = [c for c, r in existing.items() if c not in wanted and int(r["received"]) > 0]
if blocked:
raise ValueError("입고 기록이 있는 품목은 뺄 수 없습니다: " + ", ".join(sorted(blocked)))
for code, r in existing.items():
if code not in wanted:
conn.execute("DELETE FROM inout_order_lines WHERE id=%s", (r["id"],))
for i, ln in enumerate(data["lines"], start=1):
if ln["item_code"] in existing:
conn.execute("UPDATE inout_order_lines SET line_no=%s, qty=%s, memo=%s WHERE id=%s",
(i, ln["qty"], ln["memo"], existing[ln["item_code"]]["id"]))
else:
self._insert_line(conn, order_id, i, ln, names, specs or {})
conn.execute("UPDATE inout_orders SET factory_id=%s, order_date=%s, due_date=%s, memo=%s, updated_by=%s WHERE id=%s",
(data["factory_id"], data["order_date"], data["due_date"], data["memo"], _norm_email(by), order_id))
def set_closed(self, order_id: int, *, closed: bool, reason: str = "", by: str) -> None:
"""종결(남은 미입고를 더 기다리지 않음) / 종결 풀기."""
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서입니다.")
if closed:
conn.execute("UPDATE inout_orders SET closed_at=now(), closed_by=%s, close_reason=%s, updated_by=%s WHERE id=%s",
(_norm_email(by), (reason or "").strip()[:store.MEMO_MAX], _norm_email(by), order_id))
else:
conn.execute("UPDATE inout_orders SET closed_at=NULL, closed_by='', close_reason='', updated_by=%s WHERE id=%s",
(_norm_email(by), order_id))
def cancel_order(self, order_id: int, *, by: str) -> None:
"""잘못 넣은 발주 — 입고 기록이 없을 때만 취소(기록은 남김)."""
with self._pool.connection() as conn, conn.transaction():
self._lock_order(conn, order_id)
if conn.execute("SELECT 1 FROM inout_receipts WHERE order_id=%s LIMIT 1", (order_id,)).fetchone():
raise ValueError("입고 기록이 있는 발주서는 취소할 수 없습니다 — 남은 수량은 '종결'하세요.")
conn.execute("UPDATE inout_orders SET cancelled_at=now(), cancelled_by=%s, updated_by=%s WHERE id=%s",
(_norm_email(by), _norm_email(by), order_id))
def delete_order(self, order_id: int) -> dict[str, Any]:
"""발주서 완전 삭제(수퍼관리자) — 품목·입고 기록·입고증 사진·메일 기록까지 함께(CASCADE). 되돌릴 수 없다.
반환 {order_no, receipts} — 화면 안내·로그용."""
with self._pool.connection() as conn, conn.transaction():
self._lock_order(conn, order_id)
n = conn.execute("SELECT count(*) AS n FROM inout_receipts WHERE order_id=%s", (order_id,)).fetchone()["n"]
row = conn.execute("DELETE FROM inout_orders WHERE id=%s RETURNING order_no", (order_id,)).fetchone()
return {"order_no": row["order_no"], "receipts": int(n)}
def get_order(self, order_id: int) -> dict[str, Any] | None:
with self._pool.connection() as conn:
head = conn.execute(
# 담당자(manager)는 002 열 — 미적용 DB 에서도 깨지지 않게 to_jsonb 로 읽는다
"SELECT o.*, f.name AS factory_name, to_jsonb(f) ->> 'manager' AS factory_manager, f.contact AS factory_contact, "
"COALESCE(to_jsonb(f) ->> 'email', '') AS factory_email "
"FROM inout_orders o JOIN inout_factories f ON f.id = o.factory_id WHERE o.id=%s",
(order_id,)).fetchone()
if not head:
return None
lines = conn.execute(
"SELECT l.*, COALESCE(sum(rl.qty), 0)::int AS received FROM inout_order_lines l "
"LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id WHERE l.order_id=%s "
"GROUP BY l.id ORDER BY l.line_no", (order_id,)).fetchall()
receipts = conn.execute("SELECT * FROM inout_receipts WHERE order_id=%s ORDER BY receipt_date, id",
(order_id,)).fetchall()
rlines = conn.execute(
"SELECT rl.receipt_id, rl.order_line_id, rl.qty, l.item_code, l.item_name FROM inout_receipt_lines rl "
"JOIN inout_order_lines l ON l.id = rl.order_line_id JOIN inout_receipts r ON r.id = rl.receipt_id "
"WHERE r.order_id=%s ORDER BY l.line_no", (order_id,)).fetchall()
# 입고증 사진(목록만 — 내용은 /inout/photos/{id})·발주 메일 기록 — 003 미적용이면 빈 목록
try:
photos = conn.execute(
"SELECT p.id, p.receipt_id, p.filename, p.content_type, p.size_bytes FROM inout_receipt_photos p "
"JOIN inout_receipts r ON r.id = p.receipt_id WHERE r.order_id=%s ORDER BY p.id", (order_id,)).fetchall()
mails = conn.execute("SELECT * FROM inout_order_mails WHERE order_id=%s ORDER BY sent_at, id", (order_id,)).fetchall()
except UndefinedTable:
photos, mails = [], []
# 입고 요청 메일 기록(005) — 미적용이면 빈 목록
try:
rmails = conn.execute(
"SELECT m.* FROM inout_receipt_mails m JOIN inout_receipts r ON r.id = m.receipt_id "
"WHERE r.order_id=%s ORDER BY m.sent_at, m.id", (order_id,)).fetchall()
except UndefinedTable:
rmails = []
by_rmail: dict[int, list[dict[str, Any]]] = {}
for m in rmails:
by_rmail.setdefault(int(m["receipt_id"]), []).append(m)
by_photo: dict[int, list[dict[str, Any]]] = {}
for ph in photos:
by_photo.setdefault(int(ph["receipt_id"]), []).append(ph)
by_receipt: dict[int, list[dict[str, Any]]] = {}
for r in rlines:
by_receipt.setdefault(int(r["receipt_id"]), []).append(r)
lines = store.decorate_lines(lines)
status = store.order_status(lines, closed=bool(head["closed_at"]), cancelled=bool(head["cancelled_at"]))
return {**head, "lines": lines, "summary": store.summarize(lines), "status": status,
"status_label": store.ORDER_LABELS[status],
"receipts": [{**r, "lines": by_receipt.get(int(r["id"]), []), "photos": by_photo.get(int(r["id"]), []),
"mails": by_rmail.get(int(r["id"]), []),
"total": sum(int(x["qty"]) for x in by_receipt.get(int(r["id"]), []))} for r in receipts],
"mails": mails}
def list_orders(self, *, status: str = "active", factory_id: int | None = None, q: str = "",
date_from: date | None = None, date_to: date | None = None, limit: int = 500) -> list[dict[str, Any]]:
"""목록 — 상태는 품목 합계로 계산한 뒤 거른다. q = 발주번호·제품 코드·제품 이름."""
where, params = ["TRUE"], []
if factory_id:
where.append("o.factory_id = %s")
params.append(factory_id)
if date_from:
where.append("o.order_date >= %s")
params.append(date_from)
if date_to:
where.append("o.order_date <= %s")
params.append(date_to)
if q.strip():
like = "%" + q.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
where.append("(o.order_no ILIKE %s OR EXISTS (SELECT 1 FROM inout_order_lines x WHERE x.order_id = o.id "
"AND (x.item_code ILIKE %s OR x.item_name ILIKE %s)))")
params += [like, like, like]
with self._pool.connection() as conn:
heads = conn.execute(
"SELECT o.*, f.name AS factory_name FROM inout_orders o JOIN inout_factories f ON f.id = o.factory_id "
# 상태는 품목 합계로 계산해 아래에서 거르므로 넉넉히 읽는다(발주서는 많아야 연 수천 건)
f"WHERE {' AND '.join(where)} ORDER BY o.order_date DESC, o.id DESC LIMIT {_SCAN_LIMIT}", params
).fetchall()
ids = [h["id"] for h in heads]
lines = conn.execute(
"SELECT l.order_id, l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
"FROM inout_order_lines l LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
"WHERE l.order_id = ANY(%s) GROUP BY l.id ORDER BY l.line_no", (ids,)).fetchall() if ids else []
by_order: dict[int, list[dict[str, Any]]] = {}
for ln in lines:
by_order.setdefault(int(ln["order_id"]), []).append(ln)
allowed = store.STATUS_FILTERS.get(status, store.STATUS_FILTERS["active"])[1]
out = []
for h in heads:
ls = by_order.get(int(h["id"]), [])
st = store.order_status(ls, closed=bool(h["closed_at"]), cancelled=bool(h["cancelled_at"]))
if st not in allowed:
continue
names = [x["item_name"] or x["item_code"] for x in ls]
out.append({**h, "status": st, "status_label": store.ORDER_LABELS[st], "summary": store.summarize(ls),
"line_count": len(ls), "items_label": (names[0] + (f" 외 {len(names) - 1}종" if len(names) > 1 else "")) if names else ""})
if len(out) >= limit:
break
return out
# ════════════════════════════════════════════════════════════
# 입고
# ════════════════════════════════════════════════════════════
def add_receipt(self, order_id: int, quantities: dict[int, Any], *, receipt_date: Any, memo: Any,
confirm_over: bool, by: str, photos: list[dict[str, Any]] | None = None) -> dict[str, Any]:
"""입고 1건 저장. 발주를 넘는 품목이 있는데 confirm_over 가 아니면 OverReceipt(아무것도 저장 안 함).
photos = store.validate_photos 결과(입고증) — 입고와 한 트랜잭션(사진 저장이 실패하면 입고도 저장 안 함)."""
try:
return self._add_receipt(order_id, quantities, receipt_date=receipt_date, memo=memo,
confirm_over=confirm_over, by=by, photos=photos or [])
except UndefinedTable:
raise ValueError("DB 마이그레이션 inout_db 003(입고증 사진)이 아직 적용되지 않아 사진을 저장할 수 없습니다 — "
"사진 없이 저장하거나 관리자에게 알려 주세요.") from None
def _add_receipt(self, order_id: int, quantities: dict[int, Any], *, receipt_date: Any, memo: Any,
confirm_over: bool, by: str, photos: list[dict[str, Any]]) -> dict[str, Any]:
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서에는 입고할 수 없습니다.")
if head["closed_at"]:
raise ValueError("종결된 발주서입니다 — 입고하려면 발주 담당이 종결을 풀어야 합니다.")
lines = conn.execute(
"SELECT l.id, l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
"FROM inout_order_lines l LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
"WHERE l.order_id=%s GROUP BY l.id", (order_id,)).fetchall()
# 전체 입고 완료(모든 품목 입고 ≥ 발주)면 더 받지 않는다(2026-10-19) — 화면은 버튼을 막고, 서버도 거절(잠근 뒤 판단)
if lines and all(int(x["received"]) >= int(x["qty"]) for x in lines):
raise ValueError("전체 입고가 완료된 발주서입니다 — 더 입고할 수 없습니다(잘못 넣은 입고는 입고 기록에서 지운 뒤 다시 넣으세요).")
data = store.validate_receipt(lines, quantities, receipt_date=receipt_date, memo=memo)
if data["over"] and not confirm_over:
raise OverReceipt(data["over"])
rid = conn.execute("INSERT INTO inout_receipts (order_id, receipt_date, memo, created_by) VALUES (%s,%s,%s,%s) RETURNING id",
(order_id, data["receipt_date"], data["memo"], _norm_email(by))).fetchone()["id"]
for it in data["items"]:
conn.execute("INSERT INTO inout_receipt_lines (receipt_id, order_line_id, qty) VALUES (%s,%s,%s)",
(rid, it["order_line_id"], it["qty"]))
self._insert_photos(conn, int(rid), photos, by)
return {"id": int(rid), "over": data["over"], "total": sum(it["qty"] for it in data["items"]), "photos": len(photos)}
# ── 입고증 사진(003) ──
@staticmethod
def _insert_photos(conn: Any, receipt_id: int, photos: list[dict[str, Any]], by: str) -> None:
for ph in photos:
conn.execute("INSERT INTO inout_receipt_photos (receipt_id, filename, content_type, size_bytes, data, created_by) "
"VALUES (%s,%s,%s,%s,%s,%s)",
(receipt_id, ph["filename"], ph["content_type"], len(ph["data"]), ph["data"], _norm_email(by)))
def add_receipt_photos(self, order_id: int, receipt_id: int, files: list[tuple[str, bytes]], *, by: str) -> int:
"""이미 있는 입고에 사진 더하기(빠뜨렸을 때). 장수 한도는 잠근 뒤 다시 센다. 반환 = 더한 장수."""
try:
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서입니다.")
if not conn.execute("SELECT 1 FROM inout_receipts WHERE id=%s AND order_id=%s", (receipt_id, order_id)).fetchone():
raise ValueError("입고 기록을 찾을 수 없습니다.")
have = int(conn.execute("SELECT count(*) AS n FROM inout_receipt_photos WHERE receipt_id=%s",
(receipt_id,)).fetchone()["n"])
photos = store.validate_photos(files, existing=have)
if not photos:
raise ValueError("올릴 사진을 고르세요.")
self._insert_photos(conn, receipt_id, photos, by)
return len(photos)
except UndefinedTable:
raise ValueError("DB 마이그레이션 inout_db 003(입고증 사진)이 아직 적용되지 않았습니다.") from None
def delete_receipt_photo(self, order_id: int, photo_id: int) -> None:
with self._pool.connection() as conn, conn.transaction():
self._lock_order(conn, order_id)
row = conn.execute("DELETE FROM inout_receipt_photos p USING inout_receipts r "
"WHERE p.id=%s AND p.receipt_id = r.id AND r.order_id=%s RETURNING p.id",
(photo_id, order_id)).fetchone()
if not row:
raise ValueError("사진을 찾을 수 없습니다.")
def get_photo(self, photo_id: int) -> dict[str, Any] | None:
"""사진 내용(+ 발주서 id) — 보여 주기용."""
try:
with self._pool.connection() as conn:
return conn.execute("SELECT p.id, p.filename, p.content_type, p.data, r.order_id FROM inout_receipt_photos p "
"JOIN inout_receipts r ON r.id = p.receipt_id WHERE p.id=%s", (photo_id,)).fetchone()
except UndefinedTable:
return None
# ════════════════════════════════════════════════════════════
# Gmail 연결(사람별, 갱신 토큰 암호문만) · 발주 메일 기록 — 003
# ════════════════════════════════════════════════════════════
def gmail_token(self, email: str) -> dict[str, Any] | None:
try:
with self._pool.connection() as conn:
return conn.execute("SELECT * FROM inout_gmail_tokens WHERE email=%s", (_norm_email(email),)).fetchone()
except UndefinedTable:
return None
def save_gmail_token(self, email: str, *, refresh_token_enc: str, scopes: str) -> None:
try:
with self._pool.connection() as conn:
conn.execute("INSERT INTO inout_gmail_tokens (email, refresh_token_enc, scopes, connected_at, last_error) "
"VALUES (%s,%s,%s,now(),'') ON CONFLICT (email) DO UPDATE SET refresh_token_enc=EXCLUDED.refresh_token_enc, "
"scopes=EXCLUDED.scopes, connected_at=now(), last_error=''",
(_norm_email(email), refresh_token_enc, scopes[:500]))
except UndefinedTable:
raise ValueError("DB 마이그레이션 inout_db 003(발주 메일)이 아직 적용되지 않았습니다.") from None
def delete_gmail_token(self, email: str) -> None:
try:
with self._pool.connection() as conn:
conn.execute("DELETE FROM inout_gmail_tokens WHERE email=%s", (_norm_email(email),))
except UndefinedTable:
pass
def mark_gmail(self, email: str, *, error: str = "") -> None:
"""보낸 뒤 — 성공이면 마지막 사용 시각, 실패면 오류 문구(비밀값 없음)."""
with self._pool.connection() as conn:
conn.execute("UPDATE inout_gmail_tokens SET last_used_at = CASE WHEN %s = '' THEN now() ELSE last_used_at END, "
"last_error=%s WHERE email=%s", (error[:300], error[:300], _norm_email(email)))
def add_order_mail(self, order_id: int, *, sent_by: str, to: list[str], cc: list[str], subject: str, gmail_id: str) -> None:
with self._pool.connection() as conn:
conn.execute("INSERT INTO inout_order_mails (order_id, sent_by, to_addrs, cc_addrs, subject, gmail_id) "
"VALUES (%s,%s,%s,%s,%s,%s)",
(order_id, _norm_email(sent_by), ", ".join(to), ", ".join(cc), subject[:300], gmail_id[:100]))
# ════════════════════════════════════════════════════════════
# 모듈 설정(물류센터 이메일·입고 요청 메일 참조) · 입고 요청 메일 기록 — 005
# ════════════════════════════════════════════════════════════
def settings_ready(self) -> bool:
with self._pool.connection() as conn:
return bool(conn.execute("SELECT to_regclass('public.inout_settings') IS NOT NULL AND "
"to_regclass('public.inout_receipt_mails') IS NOT NULL AS ok").fetchone()["ok"])
def get_settings(self) -> dict[str, str]:
"""설정 값 — 없는 키는 store.SETTING_DEFAULTS. 005 미적용이어도 기본값으로."""
out = dict(store.SETTING_DEFAULTS)
try:
with self._pool.connection() as conn:
for r in conn.execute("SELECT key, value FROM inout_settings").fetchall():
if r["key"] in out:
out[r["key"]] = r["value"]
except UndefinedTable:
pass
return out
def save_settings(self, values: dict[str, str], *, by: str) -> None:
try:
with self._pool.connection() as conn, conn.transaction():
for k, v in values.items():
conn.execute("INSERT INTO inout_settings (key, value, updated_by, updated_at) VALUES (%s,%s,%s,now()) "
"ON CONFLICT (key) DO UPDATE SET value=EXCLUDED.value, updated_by=EXCLUDED.updated_by, updated_at=now()",
(k, v, _norm_email(by)))
except UndefinedTable:
raise ValueError("DB 마이그레이션 inout_db 005(물류센터 이메일·입고 요청 메일)가 아직 적용되지 않았습니다.") from None
def receipt_photo_data(self, receipt_id: int) -> list[dict[str, Any]]:
"""입고 1건의 사진 내용(메일 본문에 넣기) — 올린 순서."""
try:
with self._pool.connection() as conn:
return conn.execute("SELECT id, filename, content_type, data FROM inout_receipt_photos WHERE receipt_id=%s ORDER BY id",
(receipt_id,)).fetchall()
except UndefinedTable:
return []
def add_receipt_mail(self, receipt_id: int, *, sent_by: str, to: list[str], cc: list[str], subject: str, gmail_id: str) -> None:
try:
with self._pool.connection() as conn:
conn.execute("INSERT INTO inout_receipt_mails (receipt_id, sent_by, to_addrs, cc_addrs, subject, gmail_id) "
"VALUES (%s,%s,%s,%s,%s,%s)",
(receipt_id, _norm_email(sent_by), ", ".join(to), ", ".join(cc), subject[:300], gmail_id[:100]))
except UndefinedTable:
pass # 메일은 이미 나갔다 — 기록만 못 남김(005 미적용)
def delete_receipt(self, order_id: int, receipt_id: int, *, by: str) -> None:
"""잘못 넣은 입고 1건을 지운다(그 수량만큼 다시 미입고)."""
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서입니다.")
row = conn.execute("DELETE FROM inout_receipts WHERE id=%s AND order_id=%s RETURNING id",
(receipt_id, order_id)).fetchone()
if not row:
raise ValueError("입고 기록을 찾을 수 없습니다.")
conn.execute("UPDATE inout_orders SET updated_by=%s WHERE id=%s", (_norm_email(by), order_id))
# ════════════════════════════════════════════════════════════
# 상품 정보(004) — 코드표 단품 + 단가·무게(개당 g)·은 함유량(%) 수기 입력, 지운 단품은 제외 목록
# ════════════════════════════════════════════════════════════
def products_ready(self) -> bool:
"""004 가 적용됐나(상품 표·발주 품목 값 칸). 한 번 확인되면 기억."""
if getattr(self, "_products_ok", False):
return True
with self._pool.connection() as conn:
ok = bool(conn.execute(
"SELECT to_regclass('public.inout_products') IS NOT NULL AND EXISTS (SELECT 1 FROM information_schema.columns "
"WHERE table_name = 'inout_order_lines' AND column_name = 'unit_price') AS ok").fetchone()["ok"])
self._products_ok = ok
return ok
def _need_products(self) -> None:
if not self.products_ready():
raise ValueError("DB 마이그레이션 inout_db 004(상품 정보)가 아직 적용되지 않았습니다.")
def list_products(self) -> list[dict[str, Any]]:
if not self.products_ready():
return []
with self._pool.connection() as conn:
return conn.execute("SELECT * FROM inout_products ORDER BY item_code").fetchall()
def list_excluded(self) -> list[dict[str, Any]]:
if not self.products_ready():
return []
with self._pool.connection() as conn:
return conn.execute("SELECT * FROM inout_products_excluded ORDER BY item_code").fetchall()
def import_products(self, items: list[dict[str, str]], *, by: str) -> dict[str, int]:
"""코드표 단품 → 상품 정보. 새 단품은 추가, 값(단가·무게·은 함유량)을 넣은 상품은 그대로(이름도),
값이 없는 상품은 이름만 최신으로, 제외 목록의 단품은 건너뛴다."""
self._need_products()
out = {"added": 0, "renamed": 0, "kept": 0, "excluded": 0, "same": 0}
with self._pool.connection() as conn, conn.transaction():
have = {r["item_code"]: r for r in conn.execute("SELECT * FROM inout_products FOR UPDATE").fetchall()}
skip = {r["item_code"] for r in conn.execute("SELECT item_code FROM inout_products_excluded").fetchall()}
for it in items:
code, name = it["code"].strip().upper(), (it.get("name") or "").strip()[:300]
if not code:
continue
if code in skip:
out["excluded"] += 1
elif code not in have:
conn.execute("INSERT INTO inout_products (item_code, item_name, updated_by) VALUES (%s,%s,%s) "
"ON CONFLICT (item_code) DO NOTHING", (code, name, _norm_email(by)))
have[code] = {"item_code": code}
out["added"] += 1
elif store.has_values(have[code]):
out["kept"] += 1
elif have[code].get("item_name") != name:
conn.execute("UPDATE inout_products SET item_name=%s, updated_at=now() WHERE item_code=%s", (name, code))
out["renamed"] += 1
else:
out["same"] += 1
return out
def save_products(self, rows: list[dict[str, Any]], *, by: str) -> int:
"""값 저장 — rows = [{code, unit_price, weight_g, silver_pct}](store.validate_product_values 를 거친 값). 한 트랜잭션."""
self._need_products()
with self._pool.connection() as conn, conn.transaction():
for r in rows:
hit = conn.execute("UPDATE inout_products SET unit_price=%s, weight_g=%s, silver_pct=%s, updated_by=%s, updated_at=now() "
"WHERE item_code=%s RETURNING item_code",
(r["unit_price"], r["weight_g"], r["silver_pct"], _norm_email(by), r["code"])).fetchone()
if not hit:
raise ValueError(f"상품 정보에 없는 단품입니다: {r['code']}")
return len(rows)
def exclude_product(self, code: str, *, by: str) -> None:
"""상품 정보에서 지우고 제외 목록에 — 다음 불러오기에서 빠진다(지난 발주서는 그대로)."""
self._need_products()
with self._pool.connection() as conn, conn.transaction():
row = conn.execute("DELETE FROM inout_products WHERE item_code=%s RETURNING item_name", (code,)).fetchone()
if not row:
raise ValueError("상품을 찾을 수 없습니다.")
conn.execute("INSERT INTO inout_products_excluded (item_code, item_name, excluded_by) VALUES (%s,%s,%s) "
"ON CONFLICT (item_code) DO UPDATE SET excluded_at=now(), excluded_by=EXCLUDED.excluded_by",
(code, row["item_name"], _norm_email(by)))
def restore_product(self, code: str, *, by: str) -> None:
"""제외 목록에서 되살리기 — 바로 상품 정보로(값은 빈칸)."""
self._need_products()
with self._pool.connection() as conn, conn.transaction():
row = conn.execute("DELETE FROM inout_products_excluded WHERE item_code=%s RETURNING item_name", (code,)).fetchone()
if not row:
raise ValueError("제외 목록에 없는 단품입니다.")
conn.execute("INSERT INTO inout_products (item_code, item_name, updated_by) VALUES (%s,%s,%s) ON CONFLICT DO NOTHING",
(code, row["item_name"], _norm_email(by)))
def catalog_count(self) -> int:
if not self.products_ready():
return 0
with self._pool.connection() as conn:
return int(conn.execute("SELECT count(*) AS n FROM inout_products").fetchone()["n"])
def catalog_search(self, q: str, *, limit: int = 30) -> list[dict[str, Any]]:
"""발주서 제품 고르기 — 상품 정보에서(지운 단품 제외). 코드 앞부분 일치 먼저."""
esc = (q or "").strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
if not esc:
return []
with self._pool.connection() as conn:
return conn.execute(
"SELECT item_code, item_name, unit_price, weight_g, silver_pct FROM inout_products "
"WHERE item_code ILIKE %(q)s OR item_name ILIKE %(q)s "
"ORDER BY (item_code ILIKE %(p)s) DESC, item_code LIMIT %(n)s",
{"q": f"%{esc}%", "p": f"{esc}%", "n": int(limit)}).fetchall()
def catalog_lookup(self, codes: list[str]) -> dict[str, dict[str, Any]]:
if not codes or not self.products_ready():
return {}
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM inout_products WHERE item_code = ANY(%s)", ([c.upper() for c in codes],)).fetchall()
return {r["item_code"]: r for r in rows}
# ════════════════════════════════════════════════════════════
# 미입고 현황 — 진행 중(종결·취소 아님) 발주의 남은 수량, 그리고 초과 입고
# ════════════════════════════════════════════════════════════
def outstanding(self, *, factory_id: int | None = None, q: str = "") -> dict[str, list[dict[str, Any]]]:
where, params = ["o.closed_at IS NULL", "o.cancelled_at IS NULL"], []
if factory_id:
where.append("o.factory_id = %s")
params.append(factory_id)
if q.strip():
like = "%" + q.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
where.append("(l.item_code ILIKE %s OR l.item_name ILIKE %s OR o.order_no ILIKE %s)")
params += [like, like, like]
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT o.id AS order_id, o.order_no, o.order_date, o.due_date, f.name AS factory_name, "
"l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
"FROM inout_order_lines l JOIN inout_orders o ON o.id = l.order_id "
"JOIN inout_factories f ON f.id = o.factory_id "
"LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
f"WHERE {' AND '.join(where)} GROUP BY l.id, o.id, f.name "
"ORDER BY o.due_date NULLS LAST, o.order_date, o.id, l.line_no", params).fetchall()
rows = store.decorate_lines(rows)
return {"pending": [r for r in rows if r["remaining"] > 0], "over": [r for r in rows if r["over"] > 0]}
# ── 내부 ──
@staticmethod
def _lock_order(conn: Any, order_id: int) -> dict[str, Any]:
head = conn.execute("SELECT * FROM inout_orders WHERE id=%s FOR UPDATE", (order_id,)).fetchone()
if not head:
raise LookupError("발주서를 찾을 수 없습니다.")
return head
@staticmethod
def _require_factory(conn: Any, factory_id: int, *, allow_inactive_id: int | None = None) -> None:
row = conn.execute("SELECT is_active FROM inout_factories WHERE id=%s", (factory_id,)).fetchone()
if not row:
raise ValueError("공장을 찾을 수 없습니다.")
if not row["is_active"] and factory_id != allow_inactive_id:
raise ValueError("사용하지 않는 공장입니다(옵션에서 '사용'으로 바꾸세요).")
+192
View File
@@ -0,0 +1,192 @@
"""발주 메일 — 발주 담당자 본인 Gmail 로 보내기(2026-10-16 사용자 요청, Gmail API).
연결(사람마다 한 번): [Gmail 연결] → 구글 동의 화면(로그인과 같은 OAuth 클라이언트 GOOGLE_CLIENT_ID, 범위 = gmail.send 만)
→ /inout/gmail/callback 에서 ① 고른 구글 계정이 ERP 로그인 계정과 같은지(다르면 거절 — 남의 메일함으로 보내지 않게)
② gmail.send 를 허락했는지 ③ 갱신 토큰이 왔는지 확인 → 갱신 토큰을 APP_ENCRYPTION_KEY(실적 모듈과 같은 마스터 키,
AES-256-GCM, AAD = inout:gmail:{email})로 암호화해 inout_gmail_tokens 에. 원문·접근 토큰은 저장·출력하지 않는다.
보내기: 갱신 토큰 → 접근 토큰(oauth2.googleapis.com/token) → gmail.users.messages.send(raw = RFC 822, 글 + HTML).
사람이 [메일 발송]을 눌렀을 때만 보낸다(자동 발송 없음). 연결이 끊겼으면(invalid_grant·권한 없음) 다시 연결 안내.
구글 클라우드 준비(관리자 1회): Gmail API 사용 설정 · OAuth 동의 화면에 …/auth/gmail.send 범위 추가 ·
OAuth 클라이언트의 승인된 리디렉션 URI 에 {PUBLIC_BASE_URL}/inout/gmail/callback 추가. 상세 docs/INOUT_MODULE.md.
"""
from __future__ import annotations
import base64
import os
from email.message import EmailMessage
from email.utils import formataddr
from typing import Any
import httpx
GMAIL_SCOPE = "https://www.googleapis.com/auth/gmail.send"
TOKEN_URI = "https://oauth2.googleapis.com/token"
SEND_URI = "https://gmail.googleapis.com/gmail/v1/users/me/messages/send"
REVOKE_URI = "https://oauth2.googleapis.com/revoke"
CLIENT_NAME = "inout_gmail"
class GmailNotConnected(Exception):
"""Gmail 연결이 없거나 끊김 — 다시 [Gmail 연결]."""
class GmailError(Exception):
"""보내기 실패(구글 오류 등) — 문구는 화면에 그대로(비밀값 없음)."""
def _http() -> httpx.Client:
"""HTTP 클라이언트 — 테스트가 바꿔 끼운다."""
return httpx.Client(timeout=20.0)
# ── 토큰 암호화(실적 모듈과 같은 마스터 키) ─────────────────
def _ring() -> Any:
from app.modules.performance.security.crypto import CryptoConfigError, KeyRing # noqa: WPS433
try:
return KeyRing.from_env()
except CryptoConfigError as exc:
raise GmailError(f"암호화 키가 없어 Gmail 연결을 저장할 수 없습니다 — {exc}") from None
def _aad(email: str) -> str:
return f"inout:gmail:{(email or '').strip().lower()}"
def encrypt_token(email: str, refresh_token: str) -> str:
from app.modules.performance.security.crypto import encrypt # noqa: WPS433
return encrypt(refresh_token, aad=_aad(email), ring=_ring())
def decrypt_token(email: str, enc: str) -> str:
from app.modules.performance.security.crypto import DecryptError, decrypt # noqa: WPS433
try:
return decrypt(enc, aad=_aad(email), ring=_ring())
except DecryptError:
raise GmailNotConnected("저장된 Gmail 연결을 읽을 수 없습니다(암호화 키가 바뀌었을 수 있음) — 다시 연결하세요.") from None
# ── OAuth 클라이언트(로그인과 같은 GOOGLE_CLIENT_ID, 범위만 다름) ──
def oauth_client() -> Any:
from app.main import env, oauth # noqa: WPS433
if not env("GOOGLE_CLIENT_ID") or not env("GOOGLE_CLIENT_SECRET"):
raise GmailError("GOOGLE_CLIENT_ID/SECRET 이 없어 Gmail 을 연결할 수 없습니다.")
client = oauth.create_client(CLIENT_NAME)
if client is None:
oauth.register(
name=CLIENT_NAME,
client_id=env("GOOGLE_CLIENT_ID"),
client_secret=env("GOOGLE_CLIENT_SECRET"),
server_metadata_url="https://accounts.google.com/.well-known/openid-configuration",
client_kwargs={"scope": f"openid email {GMAIL_SCOPE}"},
)
client = oauth.create_client(CLIENT_NAME)
return client
def check_grant(token: dict[str, Any], *, expected_email: str) -> tuple[str, str]:
"""콜백 토큰 확인 → (갱신 토큰, 허락된 범위). 계정이 다르거나 발송 권한·갱신 토큰이 없으면 GmailError."""
info = token.get("userinfo") or {}
got = str(info.get("email") or "").strip().lower()
want = (expected_email or "").strip().lower()
if not got or got != want:
raise GmailError(f"ERP 로그인 계정({want})과 다른 구글 계정({got or '알 수 없음'})을 골랐습니다 — 같은 계정으로 다시 연결하세요.")
scopes = str(token.get("scope") or "")
if GMAIL_SCOPE not in scopes.split():
raise GmailError("메일 보내기 권한(gmail.send)을 허락하지 않았습니다 — 동의 화면에서 체크한 뒤 다시 연결하세요.")
refresh = str(token.get("refresh_token") or "")
if not refresh:
raise GmailError("구글이 갱신 토큰을 주지 않았습니다 — 구글 계정 → 보안 → 타사 앱 접근에서 이 앱을 지우고 다시 연결하세요.")
return refresh, scopes
# ── 보내기 ──────────────────────────────────────────────
def _google_message(resp: httpx.Response) -> str:
try:
body = resp.json()
except ValueError:
return f"HTTP {resp.status_code}"
err = body.get("error")
if isinstance(err, dict):
return str(err.get("message") or err.get("status") or resp.status_code)[:200]
return str(body.get("error_description") or err or resp.status_code)[:200]
def access_token(refresh_token: str) -> str:
from app.main import env # noqa: WPS433
try:
with _http() as client:
resp = client.post(TOKEN_URI, data={"client_id": env("GOOGLE_CLIENT_ID"), "client_secret": env("GOOGLE_CLIENT_SECRET"),
"refresh_token": refresh_token, "grant_type": "refresh_token"})
except httpx.HTTPError as exc:
raise GmailError(f"구글 인증 서버에 연결하지 못했습니다({type(exc).__name__}).") from None
if resp.status_code != 200:
try:
code = str(resp.json().get("error") or "")
except ValueError:
code = ""
if code in ("invalid_grant", "unauthorized_client", "invalid_client"):
raise GmailNotConnected("Gmail 연결이 끊겼습니다(권한 취소·비밀번호 변경 등) — 다시 연결하세요.")
raise GmailError(f"구글 인증 실패: {_google_message(resp)}")
token = str(resp.json().get("access_token") or "")
if not token:
raise GmailError("구글 인증 서버가 접근 토큰을 주지 않았습니다.")
return token
def build_message(*, sender_name: str, sender_email: str, to: list[str], cc: list[str], subject: str,
text: str, html: str, inline_images: list[dict[str, Any]] | None = None) -> bytes:
"""글 + HTML(multipart/alternative). inline_images = [{cid, data(JPEG)}] 면 HTML 쪽을 multipart/related 로 만들어
<img src="cid:…"> 가 첨부가 아니라 본문 안 이미지로 보이게 한다(입고 요청 메일, 2026-10-19)."""
msg = EmailMessage()
msg["From"] = formataddr((sender_name or sender_email, sender_email))
msg["To"] = ", ".join(to)
if cc:
msg["Cc"] = ", ".join(cc)
msg["Subject"] = subject
msg.set_content(text)
msg.add_alternative(html, subtype="html")
if inline_images:
html_part = msg.get_payload()[1]
for im in inline_images: # 파일 이름은 붙이지 않는다 — 메일 프로그램이 첨부 목록에 따로 띄우지 않게
html_part.add_related(im["data"], maintype="image", subtype="jpeg", cid=f"<{im['cid']}>", disposition="inline")
return msg.as_bytes()
def send(refresh_token: str, raw: bytes) -> str:
"""보내고 Gmail 메시지 id 를 돌려준다."""
token = access_token(refresh_token)
body = {"raw": base64.urlsafe_b64encode(raw).decode("ascii")}
try:
with _http() as client:
resp = client.post(SEND_URI, json=body, headers={"Authorization": f"Bearer {token}"})
except httpx.HTTPError as exc:
raise GmailError(f"Gmail 에 연결하지 못했습니다({type(exc).__name__}).") from None
if resp.status_code in (401, 403):
msg = _google_message(resp)
if "has not been used" in msg or "disabled" in msg.lower():
raise GmailError(f"Gmail API 가 꺼져 있습니다 — 관리자가 구글 클라우드에서 Gmail API 를 사용 설정해야 합니다. ({msg})")
raise GmailNotConnected(f"Gmail 보내기 권한이 없습니다 — 다시 연결하세요. ({msg})")
if resp.status_code != 200:
raise GmailError(f"메일을 보내지 못했습니다: {_google_message(resp)}")
return str(resp.json().get("id") or "")
def revoke(refresh_token: str) -> None:
"""연결 끊기 — 구글 쪽 권한도 취소(실패해도 무시, 우리 쪽 토큰은 지운다)."""
try:
with _http() as client:
client.post(REVOKE_URI, data={"token": refresh_token})
except httpx.HTTPError:
pass
def configured() -> bool:
"""APP_ENCRYPTION_KEY·GOOGLE_CLIENT_ID/SECRET 이 있는지(화면 안내용)."""
return bool(os.getenv("APP_ENCRYPTION_KEY", "").strip() and os.getenv("GOOGLE_CLIENT_ID", "").strip()
and os.getenv("GOOGLE_CLIENT_SECRET", "").strip())
+103
View File
@@ -0,0 +1,103 @@
"""itemcode_db 읽기 전용 — 단품(single_items)만 검색·확인.
입출고 발주서의 제품은 코드표 DB 의 단품 아이템에서만 고른다(2026-10-16 사용자 요청 — 세트는 공장 발주 대상이 아님).
itemcode_db 실제 스키마(운영 확인됨, malaysia/itemcode.py 와 같음): single_items(item_code, sabangnet_code, name).
환경변수 `ITEMCODE_DB_URL`(읽기 전용 역할 itemcode_ro) — cupang·malaysia 모듈과 공유.
미설정/실패 시 enabled=False, 빈 결과(앱/모듈을 죽이지 않음) — 그때 발주서 저장은 "코드표 연결 필요"로 막는다.
"""
from __future__ import annotations
import logging
import os
from typing import Any
logger = logging.getLogger("inout.itemcode")
_SEARCH_SQL = (
"SELECT item_code, name FROM single_items "
"WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s "
"ORDER BY (item_code ILIKE %(prefix)s) DESC, item_code ASC LIMIT %(limit)s"
)
_LOOKUP_SQL = "SELECT item_code, name FROM single_items WHERE upper(item_code) = ANY(%(codes)s)"
class SingleItemReader:
def __init__(self, dsn: str | None = None) -> None:
self._pool: Any = None
self.enabled = False
self.reason = ""
self.last_error = ""
self._configure(dsn if dsn is not None else os.getenv("ITEMCODE_DB_URL", "").strip())
def _configure(self, dsn: str) -> None:
if not dsn:
self.reason = "ITEMCODE_DB_URL 미설정 — 코드표(단품) 조회 비활성."
return
try:
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
self._pool = ConnectionPool(conninfo=dsn, min_size=1, max_size=3,
kwargs={"row_factory": dict_row, "autocommit": True}, open=False)
self._pool.open(wait=False)
self.enabled = True
except Exception as exc: # noqa: BLE001 — 설정/드라이버 문제로 모듈을 죽이지 않음
self.reason = f"itemcode_db 연결 풀 생성 실패: {type(exc).__name__}"
def search(self, query: str, *, limit: int = 30) -> list[dict[str, str]]:
"""코드·이름 부분 일치(코드 앞부분 일치 먼저). 반환 [{"code","name"}]. 실패는 빈 목록."""
q = (query or "").strip()
if not q or not self.enabled or not self._pool:
return []
esc = q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
rows = self._run(_SEARCH_SQL, {"q": f"%{esc}%", "prefix": f"{esc}%", "limit": int(limit)})
return [{"code": str(r["item_code"]).strip(), "name": str(r.get("name") or "").strip()} for r in rows or []]
def list_all(self, *, limit: int = 20000) -> list[dict[str, str]] | None:
"""단품 전체(옵션 → 상품 정보 → 단품 불러오기). 조회 불가면 None(빈 목록과 구분)."""
if not self.enabled or not self._pool:
return None
rows = self._run("SELECT item_code, name FROM single_items ORDER BY item_code LIMIT %(limit)s", {"limit": int(limit)})
if rows is None:
return None
return [{"code": str(r["item_code"]).strip().upper(), "name": str(r.get("name") or "").strip()} for r in rows if r.get("item_code")]
def lookup(self, codes: list[str]) -> dict[str, str] | None:
"""코드들 → {코드(대문자): 이름}. 단품 표에 없는 코드는 빠진다. 조회 불가면 None."""
if not self.enabled or not self._pool:
return None
wanted = sorted({c.strip().upper() for c in codes if c and c.strip()})
if not wanted:
return {}
rows = self._run(_LOOKUP_SQL, {"codes": wanted})
if rows is None:
return None
return {str(r["item_code"]).strip().upper(): str(r.get("name") or "").strip() for r in rows}
def sabangnet_codes(self, codes: list[str]) -> dict[str, str] | None:
"""코드들 → {코드(대문자): 사방넷 코드}(사방넷 입고 파일, 2026-10-19). 사방넷 코드가 빈 단품은 ''. 조회 불가면 None."""
if not self.enabled or not self._pool:
return None
wanted = sorted({c.strip().upper() for c in codes if c and c.strip()})
if not wanted:
return {}
rows = self._run("SELECT item_code, sabangnet_code FROM single_items WHERE upper(item_code) = ANY(%(codes)s)", {"codes": wanted})
if rows is None:
return None
return {str(r["item_code"]).strip().upper(): str(r.get("sabangnet_code") or "").strip() for r in rows}
def _run(self, sql: str, params: dict[str, Any]) -> list[dict[str, Any]] | None:
try:
with self._pool.connection() as conn:
rows = conn.execute(sql, params).fetchall()
self.last_error = ""
return rows
except Exception as exc: # noqa: BLE001 — 모듈을 죽이지 않음
self.last_error = f"{type(exc).__name__}"
logger.exception("itemcode(single_items) 조회 실패")
return None
def close(self) -> None:
if self._pool is not None:
self._pool.close()
File diff suppressed because it is too large Load Diff
+683
View File
@@ -0,0 +1,683 @@
"""입출고 관리 — 상수·검사·상태 계산(순수 함수, DB 없음).
흐름(2026-10-16 사용자 요청, 상용 ERP 참고 — 이카운트 "발주 대비 미입고 현황"·Odoo 분할 입고/잔량 종결):
발주 담당이 공장에 발주서(단품 코드·수량)를 넣고 → 물류에 들어올 때마다 입고 담당이 그날 들어온 수량을 입력(여러 번 나눠도 됨)
→ 품목마다 발주 − 누적 입고 = 미입고. 다 들어오면 입고완료, 더 들어오면 초과입고(확인 후 허용, 빨강 표시).
더 안 들어올 잔량은 발주 담당이 "종결"(이카운트 발주 종결 · Odoo No backorder) — 미입고 현황에서 빠지고 종결로 남는다.
"""
from __future__ import annotations
import html as _html
import re
from datetime import date, datetime
from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
from typing import Any, Iterable
ROLE_ORDER = "order" # 발주 담당
ROLE_RECEIVE = "receive" # 입고 담당
ROLES = (ROLE_ORDER, ROLE_RECEIVE)
ROLE_LABELS = {ROLE_ORDER: "발주 담당", ROLE_RECEIVE: "입고 담당"}
MAX_QTY = 10_000_000
MAX_LINES = 200
MEMO_MAX = 500
# 품목 상태
LINE_NONE, LINE_PARTIAL, LINE_DONE, LINE_OVER = "none", "partial", "done", "over"
LINE_LABELS = {LINE_NONE: "미입고", LINE_PARTIAL: "부분입고", LINE_DONE: "입고완료", LINE_OVER: "초과입고"}
# 발주서 상태 — 진행(open·partial)은 미입고 현황에 나온다
ST_OPEN, ST_PARTIAL, ST_DONE, ST_OVER, ST_CLOSED, ST_CANCELLED = "open", "partial", "done", "over", "closed", "cancelled"
# 모든 품목이 입고완료·초과입고 = "전체 입고 완료"(2026-10-17 요청 — 초과가 있으면 화면에 "초과 포함"만 덧붙인다)
ORDER_LABELS = {ST_OPEN: "발주", ST_PARTIAL: "부분입고", ST_DONE: "전체 입고 완료", ST_OVER: "전체 입고 완료",
ST_CLOSED: "종결", ST_CANCELLED: "취소"}
ACTIVE_STATUSES = (ST_OPEN, ST_PARTIAL) # 아직 더 들어올 것이 있는 발주
STATUS_FILTERS = { # 목록 거르기
"active": ("진행 중", ACTIVE_STATUSES),
"done": ("완료", (ST_DONE, ST_OVER)),
"closed": ("종결·취소", (ST_CLOSED, ST_CANCELLED)),
"all": ("전체", tuple(ORDER_LABELS)),
}
WEEKDAYS_KO = "월화수목금토일"
def fmt_date(d: date | None) -> str:
"""날짜 서식 — 2026.10.17(토). 입출고 화면·메일 모두 이 모양(2026-10-17 요청). 화면 쪽은 _macros.html ymd 와 같다."""
if not d:
return ""
return f"{d:%Y.%m.%d}({WEEKDAYS_KO[d.weekday()]})"
def fmt_datetime(dt: datetime | None) -> str:
"""2026.10.17(토) 15:14 — 시각은 DB 에서 KST 로 읽는다(db._KstTimestamptzLoader)."""
return f"{fmt_date(dt)} {dt:%H:%M}" if dt else ""
def line_status(qty: int, received: int) -> str:
if received <= 0:
return LINE_NONE
if received < qty:
return LINE_PARTIAL
return LINE_DONE if received == qty else LINE_OVER
def order_status(lines: Iterable[dict[str, Any]], *, closed: bool = False, cancelled: bool = False) -> str:
"""lines: [{qty, received}]. 취소·종결이 먼저, 그다음 입고 합계로."""
if cancelled:
return ST_CANCELLED
if closed:
return ST_CLOSED
sts = [line_status(int(x["qty"]), int(x.get("received") or 0)) for x in lines]
if not sts or all(s == LINE_NONE for s in sts):
return ST_OPEN
if any(s in (LINE_NONE, LINE_PARTIAL) for s in sts):
return ST_PARTIAL
return ST_OVER if any(s == LINE_OVER for s in sts) else ST_DONE
def summarize(lines: list[dict[str, Any]]) -> dict[str, int]:
"""발주·입고·미입고(0 아래로 안 내려감)·초과 합계."""
ordered = sum(int(x["qty"]) for x in lines)
received = sum(int(x.get("received") or 0) for x in lines)
remaining = sum(max(int(x["qty"]) - int(x.get("received") or 0), 0) for x in lines)
over = sum(max(int(x.get("received") or 0) - int(x["qty"]), 0) for x in lines)
pct = min(100, round(received * 100 / ordered)) if ordered else 0
return {"ordered": ordered, "received": received, "remaining": remaining, "over": over, "pct": pct}
def decorate_lines(lines: list[dict[str, Any]]) -> list[dict[str, Any]]:
"""화면용 — 품목마다 미입고·초과·상태 이름."""
out = []
for x in lines:
qty, rec = int(x["qty"]), int(x.get("received") or 0)
st = line_status(qty, rec)
out.append({**x, "received": rec, "remaining": max(qty - rec, 0), "over": max(rec - qty, 0),
"status": st, "status_label": LINE_LABELS[st]})
return out
# ── 입력 검사 ────────────────────────────────────────────────
def parse_qty(raw: Any, *, label: str = "수량", allow_zero: bool = False) -> int:
s = str(raw if raw is not None else "").replace(",", "").strip()
if not s:
if allow_zero:
return 0
raise ValueError(f"{label}을(를) 입력하세요.")
try:
n = int(s)
except ValueError:
raise ValueError(f"{label}은(는) 정수로 입력하세요.") from None
if n < 0 or (n == 0 and not allow_zero):
raise ValueError(f"{label}은(는) {0 if allow_zero else 1} 이상이어야 합니다.")
if n > MAX_QTY:
raise ValueError(f"{label}이(가) 너무 큽니다.")
return n
def parse_date(raw: Any, *, label: str, required: bool = True) -> date | None:
s = str(raw or "").strip()
if not s:
if required:
raise ValueError(f"{label}을(를) 입력하세요.")
return None
try:
return date.fromisoformat(s)
except ValueError:
raise ValueError(f"{label} 형식이 올바르지 않습니다(YYYY-MM-DD).") from None
def validate_order(*, factory_id: Any, order_date: Any, due_date: Any, memo: Any,
codes: list[str], quantities: list[str], line_memos: list[str] | None = None) -> dict[str, Any]:
"""발주서 폼 → 정리된 값. 빈 줄(코드·수량 둘 다 없음)은 건너뛴다. 같은 제품 두 줄은 오류."""
errors: list[str] = []
try:
fid = int(str(factory_id or "").strip())
except ValueError:
fid = 0
if fid <= 0:
errors.append("공장을 고르세요.")
od = dd = None
try:
od = parse_date(order_date, label="발주일")
except ValueError as exc:
errors.append(str(exc))
try:
dd = parse_date(due_date, label="입고 예정일", required=False)
except ValueError as exc:
errors.append(str(exc))
if od and dd and dd < od:
errors.append("입고 예정일이 발주일보다 빠릅니다.")
line_memos = line_memos or []
lines: list[dict[str, Any]] = []
seen: set[str] = set()
for i, code in enumerate(codes):
code = (code or "").strip().upper()
raw_qty = quantities[i] if i < len(quantities) else ""
if not code and not str(raw_qty or "").strip():
continue
if not code:
errors.append(f"{i + 1}번째 줄: 제품을 고르세요.")
continue
if code in seen:
errors.append(f"{code}: 같은 제품이 두 줄에 있습니다 — 한 줄로 합쳐 주세요.")
continue
seen.add(code)
try:
qty = parse_qty(raw_qty, label=f"{code} 발주 수량")
except ValueError as exc:
errors.append(str(exc))
continue
lines.append({"item_code": code, "qty": qty,
"memo": str(line_memos[i] if i < len(line_memos) else "").strip()[:MEMO_MAX]})
if not lines and not any("줄" in e or "수량" in e for e in errors):
errors.append("발주할 제품을 한 줄 이상 넣으세요.")
if len(lines) > MAX_LINES:
errors.append(f"한 발주서에 {MAX_LINES}개 제품까지 넣을 수 있습니다.")
if errors:
raise ValueError("\n".join(errors))
return {"factory_id": fid, "order_date": od, "due_date": dd, "memo": str(memo or "").strip()[:MEMO_MAX], "lines": lines}
def validate_receipt(order_lines: list[dict[str, Any]], quantities: dict[int, Any], *,
receipt_date: Any, memo: Any) -> dict[str, Any]:
"""입고 입력 — quantities: {발주 줄 id: 입력값}. 빈칸·0 은 이번에 안 들어온 것.
over = 이번 입고로 발주를 넘는 품목(확인 받은 뒤 저장). order_lines 는 지금까지 누적 입고(received)를 포함."""
errors: list[str] = []
try:
rd = parse_date(receipt_date, label="입고일")
except ValueError as exc:
errors.append(str(exc))
rd = None
by_id = {int(x["id"]): x for x in order_lines}
items: list[dict[str, Any]] = []
over: list[dict[str, Any]] = []
for lid, raw in quantities.items():
line = by_id.get(int(lid))
if line is None:
errors.append("이 발주서에 없는 품목이 들어 있습니다.")
continue
try:
qty = parse_qty(raw, label=f"{line['item_code']} 입고 수량", allow_zero=True)
except ValueError as exc:
errors.append(str(exc))
continue
if qty == 0:
continue
items.append({"order_line_id": int(lid), "qty": qty})
after = int(line.get("received") or 0) + qty
if after > int(line["qty"]):
over.append({"item_code": line["item_code"], "item_name": line.get("item_name", ""),
"ordered": int(line["qty"]), "after": after, "over": after - int(line["qty"])})
if not items and not errors:
errors.append("입고 수량을 한 품목 이상 넣으세요.")
if errors:
raise ValueError("\n".join(errors))
return {"receipt_date": rd, "memo": str(memo or "").strip()[:MEMO_MAX], "items": items, "over": over}
def order_no(order_date: date, seq: int) -> str:
"""PO-YYMMDD-NN — 발주일 기준 그날 순번(01부터)."""
return f"PO-{order_date:%y%m%d}-{seq:02d}"
# ════════════════════════════════════════════════════════════
# 발주 메일(2026-10-16, 마이그레이션 003) — 받는 주소 검사, 본문(요약) 만들기. 보내기는 gmail.py
# ════════════════════════════════════════════════════════════
MAX_RECIPIENTS = 10
_EMAIL_RE = re.compile(r"^[A-Za-z0-9._%+\-']+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$")
def parse_emails(raw: Any, *, label: str = "이메일", required: bool = False) -> list[str]:
"""'a@x.com, b@y.co.kr; c@z.com' → 주소 목록(순서 유지·중복 제거). 형식이 틀리면 ValueError."""
out: list[str] = []
for part in re.split(r"[\s,;]+", str(raw or "")):
if not part:
continue
if not _EMAIL_RE.match(part) or len(part) > 254:
raise ValueError(f"{label} 형식이 올바르지 않습니다: {part[:60]}")
if part.lower() not in [x.lower() for x in out]:
out.append(part)
if required and not out:
raise ValueError(f"{label}을(를) 입력하세요.")
if len(out) > MAX_RECIPIENTS:
raise ValueError(f"{label}은(는) {MAX_RECIPIENTS}개까지 넣을 수 있습니다.")
return out
def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) -> dict[str, str]:
"""발주서 → 메일 제목·글 본문·HTML 본문(요약). order = db.get_order 결과.
품목마다 단가·금액(수량 × 단가)·전체 무게(개당 g × 수량, kg)·PP 사용량(전체 무게 − 은 무게, kg)·은 함유량(%·전체 무게 × %, kg)
— 발주 품목에 남긴 그때 값(004). 없으면 '-'. (2026-10-19 — 예전엔 PP(g/개)·개당 은 g)"""
lines = order["lines"]
first = (lines[0]["item_name"] or lines[0]["item_code"]) if lines else ""
more = f" 외 {len(lines) - 1}종" if len(lines) > 1 else ""
subject = f"[발주] {order['order_no']} · {order['factory_name']} · {first}{more}"
total = sum(int(x["qty"]) for x in lines)
money = order_totals(lines)
due = fmt_date(order["due_date"]) if order.get("due_date") else "협의"
greet = f"{order['factory_manager']}님, 안녕하세요." if order.get("factory_manager") else "안녕하세요."
who = sender_name or sender_email
facts = [("발주번호", order["order_no"]), ("발주일", fmt_date(order["order_date"])),
("입고 예정일", due), ("품목", f"{len(lines)}종 · 총 {total:,}개")]
if money["amount"] is not None:
note = f" (단가 미입력 {money['missing_price']}종 제외)" if money["missing_price"] else ""
facts.append(("발주 금액", f"{fmt_num(money['amount'])}원{note}"))
ag_kg = money["silver_g"] / Decimal(1000) if money["silver_g"] is not None else None
if money["pp_kg"] is not None:
facts.append(("전체 무게", f"{fmt_num(money['pp_kg'], 3)} kg"))
if money["pp_use_kg"] is not None:
facts.append(("PP 사용량", f"{fmt_num(money['pp_use_kg'], 3)} kg"))
if ag_kg is not None:
facts.append(("은(Ag) 총량", f"{fmt_num(ag_kg, 4)} kg"))
if order.get("memo"):
facts.append(("요청 사항", order["memo"]))
def cells(x: dict[str, Any]) -> dict[str, str]:
price, w, pct = to_dec(x.get("unit_price")), to_dec(x.get("weight_g")), to_dec(x.get("silver_pct"))
q = int(x["qty"])
amt = line_amount(q, price)
total_kg = w * q / Decimal(1000) if w is not None else None # 전체 무게 = 개당 g × 수량
ag_kg = total_kg * pct / Decimal(100) if total_kg is not None and pct is not None else None
return {"price": fmt_num(price) if price is not None else "-", "amount": fmt_num(amt) if amt is not None else "-",
"weight": fmt_num(total_kg, 3) if total_kg is not None else "-",
"pp_use": fmt_num(total_kg - ag_kg, 3) if ag_kg is not None else "-",
"ag": (f"{fmt_num(pct, 4)}%" + (f" ({fmt_num(ag_kg, 4)}kg)" if ag_kg is not None else "")) if pct is not None else "-"}
# 글 본문(HTML 을 못 보는 메일 프로그램용)
text = [greet, "", "아래와 같이 제품 제작을 발주합니다.", ""]
text += [f"- {k}: {v}" for k, v in facts]
text += ["", "[발주 품목] 수량 · 단가 · 금액 · 전체 무게 · PP 사용량 · 은 함유량"]
for i, x in enumerate(lines, start=1):
c = cells(x)
text.append(f"{i}. {x['item_code']} {x['item_name']} — {int(x['qty']):,}개 · 단가 {c['price']} · 금액 {c['amount']}"
f" · 전체 무게 {c['weight'] + 'kg' if c['weight'] != '-' else '-'}"
f" · PP 사용량 {c['pp_use'] + 'kg' if c['pp_use'] != '-' else '-'} · 은 {c['ag']}"
+ (f" ({x['memo']})" if x.get("memo") else ""))
text += ["", "입고 예정일까지 물류로 입고 부탁드리며, 일정이 바뀌면 회신 부탁드립니다.", "", f"발주 담당: {who} ({sender_email})"]
# HTML 본문 — 값은 모두 escape
e = _html.escape
td = "padding:6px 10px;border:1px solid #d9dce1;"
r = "text-align:right;white-space:nowrap;"
# 요약 표 = 항목·값 두 쌍씩 한 줄(4열, 2026-10-19 — 예전 2열 × 8행). 요청 사항(길 수 있음)은 맨 아래 한 줄 전체.
# 칸 높이는 글자 한 줄에 맞게 — 받은 메일(메일 프로그램)에서 칸이 크게 늘어나 보여 줄 높이·글자 크기·위아래 여백을 칸마다 못 박는다.
ftd = "padding:4px 10px;border:1px solid #d9dce1;font-size:14px;line-height:20px;height:20px;vertical-align:middle;white-space:nowrap;"
fth = f"{ftd}background:#f6f7f9;text-align:left;font-weight:700;"
pairs = [(k, v) for k, v in facts if k != "요청 사항"]
fact_rows = ""
for i in range(0, len(pairs), 2):
cols = "".join(f'<th style="{fth}">{e(k)}</th><td style="{ftd}">{e(str(v))}</td>' for k, v in pairs[i:i + 2])
if len(pairs[i:i + 2]) == 1:
cols += f'<th style="{fth}"></th><td style="{ftd}"></td>'
fact_rows += f"<tr>{cols}</tr>"
if order.get("memo"): # 요청 사항은 길면 줄을 바꿔야 하므로 높이를 고정하지 않는다
memo_td = "padding:4px 10px;border:1px solid #d9dce1;font-size:14px;line-height:20px;vertical-align:middle;"
fact_rows += (f'<tr><th style="{fth}">요청 사항</th>'
f'<td colspan="3" style="{memo_td}">{e(str(order["memo"]))}</td></tr>')
rows = []
for i, x in enumerate(lines, start=1):
c = cells(x)
rows.append(
f'<tr><td style="{td}text-align:center">{i}</td><td style="{td}font-family:Consolas,monospace">{e(x["item_code"])}</td>'
f'<td style="{td}">{e(x["item_name"])}</td><td style="{td}{r}">{int(x["qty"]):,}</td>'
f'<td style="{td}{r}">{e(c["price"])}</td><td style="{td}{r}">{e(c["amount"])}</td>'
f'<td style="{td}{r}">{e(c["weight"])}</td><td style="{td}{r}">{e(c["pp_use"])}</td><td style="{td}{r}">{e(c["ag"])}</td>'
f'<td style="{td}">{e(x.get("memo") or "")}</td></tr>')
foot_amount = fmt_num(money["amount"]) if money["amount"] is not None else ""
foot_pp = fmt_num(money["pp_kg"], 3) if money["pp_kg"] is not None else ""
foot_use = fmt_num(money["pp_use_kg"], 3) if money["pp_use_kg"] is not None else ""
foot_ag = f'{fmt_num(ag_kg, 4)} kg' if ag_kg is not None else ""
bg = "background:#f6f7f9;"
html = (
'<div style="font-family:\'Malgun Gothic\',\'Apple SD Gothic Neo\',sans-serif;font-size:14px;color:#1d1d1f;line-height:1.6">'
f"<p>{e(greet)}<br>아래와 같이 제품 제작을 발주합니다.</p>"
f'<table cellpadding="0" cellspacing="0" style="border-collapse:collapse;margin:8px 0 0">{fact_rows}</table>'
# 두 표 사이 18px — 표 margin 은 메일 프로그램마다 무시되기도 해서 높이 18px 빈 줄로 띄운다
'<div style="height:18px;line-height:18px;font-size:1px">&nbsp;</div>'
'<table style="border-collapse:collapse;min-width:640px;margin:0">'
f'<thead><tr style="{bg}"><th style="{td}">No</th><th style="{td}">제품 코드</th><th style="{td}">제품명</th>'
f'<th style="{td}">수량</th><th style="{td}">단가(원)</th><th style="{td}">금액(원)</th>'
f'<th style="{td}">전체 무게(kg)</th><th style="{td}">PP 사용량(kg)</th><th style="{td}">은(Ag) 함유량</th>'
f'<th style="{td}">비고</th></tr></thead>'
f'<tbody>{"".join(rows)}</tbody>'
f'<tfoot><tr><th colspan="3" style="{td}{bg}text-align:right">합계</th>'
f'<th style="{td}{bg}{r}">{total:,}</th><th style="{td}{bg}"></th><th style="{td}{bg}{r}">{e(foot_amount)}</th>'
f'<th style="{td}{bg}{r}">{e(foot_pp)}</th><th style="{td}{bg}{r}">{e(foot_use)}</th><th style="{td}{bg}{r}">{e(foot_ag)}</th>'
f'<th style="{td}{bg}"></th></tr></tfoot></table>'
"<p>입고 예정일까지 물류로 입고 부탁드리며, 일정이 바뀌면 회신 부탁드립니다.</p>"
f'<p style="color:#555">발주 담당: {e(who)} (<a href="mailto:{e(sender_email)}">{e(sender_email)}</a>)</p></div>'
)
return {"subject": subject, "text": "\n".join(text), "html": html}
# ════════════════════════════════════════════════════════════
# 상품 정보(2026-10-16, 마이그레이션 004) — 단가·무게(개당 g = PP량)·은(Ag) 함유량(%) 수기 입력
# 은 함량(g/개) = 무게 × 은 함유량 ÷ 100 — 저장하지 않고 계산(silver_g).
# ════════════════════════════════════════════════════════════
PRODUCT_LIMITS = {"unit_price": ("단가", Decimal("1000000000"), 2), "weight_g": ("무게", Decimal("1000000"), 2),
"silver_pct": ("은 함유량", Decimal("100"), 4)}
def to_dec(v: Any) -> Decimal | None:
if v is None or v == "":
return None
try:
return Decimal(str(v))
except (InvalidOperation, ValueError):
return None
def fmt_num(v: Any, places: int = 2) -> str:
"""1234.50 → '1,234.5', 1234 → '1,234' (소수 끝 0 은 뺀다)."""
d = to_dec(v)
if d is None:
return ""
q = d.quantize(Decimal(1).scaleb(-places), rounding=ROUND_HALF_UP)
s = f"{q:,.{places}f}"
return s.rstrip("0").rstrip(".") if "." in s else s
def silver_g(weight_g: Any, silver_pct: Any) -> Decimal | None:
w, p = to_dec(weight_g), to_dec(silver_pct)
if w is None or p is None:
return None
return (w * p / Decimal(100)).quantize(Decimal("0.0001"), rounding=ROUND_HALF_UP)
def line_amount(qty: int, unit_price: Any) -> Decimal | None:
p = to_dec(unit_price)
return None if p is None else (p * int(qty)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
def order_totals(lines: list[dict[str, Any]]) -> dict[str, Any]:
"""발주 금액 합(단가 있는 줄만, 없으면 None)·단가 없는 줄 수·PP 총량(= 전체 무게, kg)·은 총량(g)·
PP 사용량(kg, 무게·은 함유량이 다 있는 줄의 전체 무게 − 은 무게 — 메일 표, 2026-10-19)."""
amount = pp = ag = use = None
missing = 0
for x in lines:
q = int(x["qty"])
a = line_amount(q, x.get("unit_price"))
if a is None:
missing += 1
else:
amount = (amount or Decimal(0)) + a
w = to_dec(x.get("weight_g"))
if w is not None:
pp = (pp or Decimal(0)) + w * q / Decimal(1000)
p = to_dec(x.get("silver_pct"))
if w is not None and p is not None: # 개당 은 g 를 반올림하기 전 값으로 곱한다(합계 오차 방지)
ag = (ag or Decimal(0)) + w * p / Decimal(100) * q
use = (use or Decimal(0)) + w * q * (Decimal(100) - p) / Decimal(100000)
return {"amount": amount, "missing_price": missing if amount is not None else len(lines), "pp_kg": pp, "silver_g": ag,
"pp_use_kg": use}
def parse_decimal(raw: Any, *, key: str) -> Decimal | None:
"""상품 정보 칸 하나 — 빈칸은 None(미입력), 숫자·쉼표·0 이상·한도 안·소수 자리."""
label, limit, places = PRODUCT_LIMITS[key]
s = str(raw if raw is not None else "").replace(",", "").replace("%", "").strip()
if not s:
return None
try:
d = Decimal(s)
except InvalidOperation:
raise ValueError(f"{label}은(는) 숫자로 입력하세요.") from None
if not d.is_finite() or d < 0:
raise ValueError(f"{label}은(는) 0 이상이어야 합니다.")
if d > limit:
raise ValueError(f"{label}이(가) 너무 큽니다(최대 {fmt_num(limit, 0)}).")
return d.quantize(Decimal(1).scaleb(-places), rounding=ROUND_HALF_UP)
def validate_product_values(values: dict[str, Any]) -> dict[str, Decimal | None]:
"""{"unit_price","weight_g","silver_pct"} → 정리된 값. 틀리면 ValueError(칸 이름 포함)."""
return {k: parse_decimal(values.get(k), key=k) for k in PRODUCT_LIMITS}
def has_values(p: dict[str, Any]) -> bool:
"""단가·무게·은 함유량 중 하나라도 넣었나 — 넣은 상품은 다시 불러와도 그대로 둔다."""
return any(p.get(k) is not None for k in PRODUCT_LIMITS)
# ════════════════════════════════════════════════════════════
# 입고증 사진(2026-10-16, 마이그레이션 003)
# ════════════════════════════════════════════════════════════
MAX_PHOTOS = 10 # 입고 한 건에
MAX_PHOTO_BYTES = 10 * 1024 * 1024 # 한 장(브라우저가 줄여서 보내므로 보통 0.3~1MB)
def sniff_image(data: bytes) -> str | None:
"""파일 머리로 이미지 종류 판단(브라우저가 보낸 종류는 믿지 않는다). 모르면 None."""
if data[:3] == b"\xff\xd8\xff":
return "image/jpeg"
if data[:8] == b"\x89PNG\r\n\x1a\n":
return "image/png"
if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
return "image/webp"
if data[:6] in (b"GIF87a", b"GIF89a"):
return "image/gif"
if data[4:12] in (b"ftypheic", b"ftypheix", b"ftypmif1", b"ftyphevc", b"ftypheif"):
return "image/heic" # 아이폰 원본 — 사파리 외 브라우저는 미리보기 못 함(내려받기)
return None
def validate_photos(files: list[tuple[str, bytes]], *, existing: int = 0) -> list[dict[str, Any]]:
"""[(파일 이름, 내용)] → [{filename, content_type, data}]. 빈 파일은 건너뛴다. 하나라도 틀리면 ValueError."""
out: list[dict[str, Any]] = []
for name, data in files:
if not data:
continue
name = (name or "photo").replace("\\", "/").rsplit("/", 1)[-1][:120]
if len(data) > MAX_PHOTO_BYTES:
raise ValueError(f"사진이 너무 큽니다(한 장 {MAX_PHOTO_BYTES // 1024 // 1024}MB까지): {name}")
ctype = sniff_image(data)
if ctype is None:
raise ValueError(f"사진 파일(JPG·PNG·WEBP·GIF·HEIC)만 올릴 수 있습니다: {name}")
out.append({"filename": name, "content_type": ctype, "data": data})
if existing + len(out) > MAX_PHOTOS:
raise ValueError(f"입고 한 건에 사진은 {MAX_PHOTOS}장까지입니다.")
return out
# ════════════════════════════════════════════════════════════
# 입고 요청 메일(2026-10-19, 마이그레이션 005) — 입고 담당이 입고를 저장한 뒤 물류센터 입고 담당자에게
# "전산 등록 부탁" 메일(입고 담당 본인 Gmail). 받는 사람 = 옵션 → 물류센터 이메일, 참조 기본 = king@·bj@dbxcorp.co.kr.
# 본문 = 입고 상품 표(상품 이름·상품 코드·입고 수량·비고) + 입고증 사진을 본문 안 이미지(CID, 첨부 아님, 가로 600px 이하).
# ════════════════════════════════════════════════════════════
SETTING_LOGISTICS_EMAILS = "logistics_emails"
SETTING_RECEIPT_MAIL_CC = "receipt_mail_cc"
SETTING_ORDER_MAIL_CC = "order_mail_cc" # 발주 메일 참조 기본값(2026-10-19 — king@, 옵션 → 공장에서 고침)
SETTING_DEFAULTS = {SETTING_LOGISTICS_EMAILS: "", SETTING_RECEIPT_MAIL_CC: "king@dbxcorp.co.kr, bj@dbxcorp.co.kr",
SETTING_ORDER_MAIL_CC: "king@dbxcorp.co.kr"}
MAIL_IMAGE_MAX_W = 600
def clean_emails(raw: Any, *, label: str) -> str:
"""옵션 저장용 — 주소 검사 후 'a@x.com, b@y.com' 로 다시 씀(비우면 '')."""
return ", ".join(parse_emails(raw, label=label))
def mail_images(photos: list[dict[str, Any]]) -> tuple[list[dict[str, Any]], int]:
"""입고증 사진 → 메일 본문용 JPEG(가로 최대 600px, 세로는 비율대로, 회전 정보 반영).
반환 ([{cid, data, width, height}], 못 넣은 장수) — HEIC 등 서버가 못 여는 사진은 빼고 센다."""
from io import BytesIO # noqa: WPS433
from PIL import Image, ImageOps # noqa: WPS433
out: list[dict[str, Any]] = []
skipped = 0
for ph in photos:
try:
im = Image.open(BytesIO(bytes(ph["data"])))
if im.format == "JPEG":
im.draft("RGB", (MAIL_IMAGE_MAX_W * 2, MAIL_IMAGE_MAX_W * 2)) # 큰 JPEG 는 줄여서 읽기(빠름)
im = ImageOps.exif_transpose(im)
if im.mode not in ("RGB", "L"):
rgba = im.convert("RGBA")
bg = Image.new("RGB", rgba.size, (255, 255, 255))
bg.paste(rgba, mask=rgba.split()[-1])
im = bg
if im.width > MAIL_IMAGE_MAX_W:
im = im.resize((MAIL_IMAGE_MAX_W, max(1, round(im.height * MAIL_IMAGE_MAX_W / im.width))), Image.LANCZOS)
buf = BytesIO()
im.convert("RGB").save(buf, "JPEG", quality=85, optimize=True)
except Exception: # noqa: BLE001 — HEIC·깨진 파일은 본문에서 뺀다(입고 기록의 사진은 그대로)
skipped += 1
continue
out.append({"cid": f"inout-photo-{ph['id']}@dbx", "data": buf.getvalue(), "width": im.width, "height": im.height})
return out, skipped
def receipt_mail_subject(receipt_date: date) -> str:
d = receipt_date
return f"[입고 요청] {d.year}년 {d.month:02d}월 {d.day:02d}일({WEEKDAYS_KO[d.weekday()]}) 입고 요청 합니다."
def receipt_mail(order: dict[str, Any], receipt: dict[str, Any], *, images: list[dict[str, Any]], skipped: int = 0,
sender_name: str, sender_email: str) -> dict[str, str]:
"""입고 1건 → 제목·글 본문·HTML 본문. 이미지는 <img src="cid:…"> (보낼 때 gmail.build_message 가 본문에 붙임).
비고 = 그 발주 품목의 줄 메모. 값은 모두 escape."""
memo_of = {int(ln["id"]): (ln.get("memo") or "") for ln in order["lines"]}
rows = [{"name": x["item_name"], "code": x["item_code"], "qty": int(x["qty"]), "note": memo_of.get(int(x["order_line_id"]), "")}
for x in receipt["lines"]]
total = sum(r["qty"] for r in rows)
who = sender_name or sender_email
when = fmt_date(receipt["receipt_date"])
info = f"입고일 {when} · 발주번호 {order['order_no']} · 공장 {order['factory_name']}"
lead = "입고된 아래 리스트 상품을 전산 등록 부탁드립니다."
# 글 본문(HTML 을 못 보는 메일 프로그램용)
text = ["안녕하세요.", "", lead, "", info, "", "[입고 상품] 상품 이름 · 상품 코드 · 입고 수량 · 비고"]
text += [f"- {r['name']} · {r['code']} · {r['qty']:,}개" + (f" · {r['note']}" if r["note"] else "") for r in rows]
text.append(f"합계 {total:,}개")
if receipt.get("memo"):
text += ["", f"메모: {receipt['memo']}"]
if images or skipped:
text += ["", f"입고 인증 사진 {len(images)}장(본문 이미지)" + (f", 본문에 넣지 못한 사진 {skipped}장(HEIC 등)" if skipped else "")]
text += ["", f"입고 담당: {who} ({sender_email})"]
# HTML 본문
e = _html.escape
td = "padding:6px 10px;border:1px solid #d9dce1;"
r_ = "text-align:right;white-space:nowrap;"
bg = "background:#f6f7f9;"
body_rows = "".join(
f'<tr><td style="{td}">{e(r["name"])}</td><td style="{td}font-family:Consolas,monospace">{e(r["code"])}</td>'
f'<td style="{td}{r_}">{r["qty"]:,}</td><td style="{td}">{e(r["note"])}</td></tr>' for r in rows)
imgs = "".join(
f'<p style="margin:8px 0"><img src="cid:{e(im["cid"])}" width="{im["width"]}" height="{im["height"]}" alt="입고 인증 사진 {i}" '
f'style="display:block;width:{im["width"]}px;max-width:100%;height:auto;border:1px solid #d9dce1"></p>'
for i, im in enumerate(images, start=1))
photo_block = ""
if images or skipped:
photo_block = (f'<p style="margin:18px 0 4px"><b>입고 인증 사진</b> <span style="color:#777">{len(images)}장</span></p>{imgs}'
+ (f'<p style="color:#777">본문에 넣지 못한 사진 {skipped}장(HEIC 등) — ERP 입고 기록에서 볼 수 있습니다.</p>' if skipped else ""))
html = (
'<div style="font-family:\'Malgun Gothic\',\'Apple SD Gothic Neo\',sans-serif;font-size:14px;color:#1d1d1f;line-height:1.6">'
f"<p>안녕하세요.<br>{e(lead)}</p>"
f'<p style="color:#555;margin:0 0 8px">{e(info)}</p>'
'<table style="border-collapse:collapse;min-width:480px">'
f'<thead><tr style="{bg}"><th style="{td}">상품 이름</th><th style="{td}">상품 코드</th><th style="{td}">입고 수량</th>'
f'<th style="{td}">비고</th></tr></thead><tbody>{body_rows}</tbody>'
f'<tfoot><tr><th colspan="2" style="{td}{bg}text-align:right">합계</th><th style="{td}{bg}{r_}">{total:,}</th>'
f'<th style="{td}{bg}"></th></tr></tfoot></table>'
+ (f'<p style="margin:10px 0 0">메모: {e(str(receipt["memo"]))}</p>' if receipt.get("memo") else "")
+ photo_block
+ f'<p style="color:#555;margin-top:18px">입고 담당: {e(who)} (<a href="mailto:{e(sender_email)}">{e(sender_email)}</a>)</p></div>'
)
return {"subject": receipt_mail_subject(receipt["receipt_date"]), "text": "\n".join(text), "html": html}
def inline_preview_html(html: str, images: list[dict[str, Any]]) -> str:
"""미리보기 창용 — cid: 를 data: 로 바꿔 브라우저에서 바로 보이게(보내는 메일은 cid 그대로)."""
import base64 # noqa: WPS433
for im in images:
html = html.replace(f'src="cid:{_html.escape(im["cid"])}"',
f'src="data:image/jpeg;base64,{base64.b64encode(im["data"]).decode("ascii")}"')
return html
# ════════════════════════════════════════════════════════════
# 사방넷 입고 파일(2026-10-19) — 입고 1건 → 엑셀. 1행 제목 A 상품코드 · B 가용수량 · C 불용수량,
# A = 코드표(itemcode_db single_items)의 사방넷 코드, B = 입고 수량, C = 수량이 아니라 상품 이름(사용자 지정).
# ════════════════════════════════════════════════════════════
SABANGNET_HEADER = ("상품코드", "가용수량", "불용수량")
def sabangnet_rows(receipt: dict[str, Any], codes: dict[str, str]) -> tuple[list[list[Any]], list[str]]:
"""입고 품목 → (엑셀 줄 [사방넷 코드, 입고 수량, 상품 이름], 사방넷 코드가 없는 품목 "코드 이름" 목록)."""
rows: list[list[Any]] = []
missing: list[str] = []
for x in receipt["lines"]:
code = (codes.get(str(x["item_code"]).strip().upper()) or "").strip()
if not code:
missing.append(f"{x['item_code']} {x['item_name']}".strip())
rows.append([code, int(x["qty"]), str(x["item_name"] or "")])
return rows, missing
def sabangnet_xlsx(rows: list[list[Any]]) -> bytes:
"""제목 행(굵게·회색 바탕) + 줄. 상품코드·불용수량(상품 이름)은 글자 칸(앞자리 0 보존)."""
from io import BytesIO # noqa: WPS433
from openpyxl import Workbook # noqa: WPS433
from openpyxl.styles import Font, PatternFill # noqa: WPS433
wb = Workbook()
ws = wb.active
ws.title = "입고"
ws.append(list(SABANGNET_HEADER))
for c in ws[1]:
c.font = Font(bold=True)
c.fill = PatternFill(start_color="FFE7E9ED", end_color="FFE7E9ED", fill_type="solid")
for code, qty, name in rows:
ws.append([code, qty, name])
r = ws.max_row
ws.cell(row=r, column=1).number_format = "@"
ws.cell(row=r, column=3).number_format = "@"
for letter, col in (("A", 0), ("B", 1), ("C", 2)):
longest = max(sum(2 if ord(ch) > 0x1100 else 1 for ch in str(v)) for v in [SABANGNET_HEADER[col]] + [r[col] for r in rows])
ws.column_dimensions[letter].width = max(10, min(60, longest + 2))
buf = BytesIO()
wb.save(buf)
return buf.getvalue()
def sabangnet_filename(order: dict[str, Any], receipt: dict[str, Any]) -> str:
return f"사방넷_입고_{receipt['receipt_date']:%Y%m%d}_{order['order_no']}.xlsx"
# ════════════════════════════════════════════════════════════
# 발주 알림 메일(2026-10-19) — 발주 담당이 발주 메일을 보낼 때 입고 담당(옵션 → 담당자)에게 같은 Gmail 로 따로 자동 발송.
# 내용 = 발주번호·발주일·제품 코드·제품명·수량만(단가·무게 등은 넣지 않음), 제목 = 발주 메일과 같음.
# ════════════════════════════════════════════════════════════
def order_notice_mail(order: dict[str, Any], *, subject: str, sender_name: str, sender_email: str) -> dict[str, str]:
e = _html.escape
lines = order["lines"]
total = sum(int(x["qty"]) for x in lines)
who = sender_name or sender_email
when = fmt_date(order["order_date"])
text = ["입고 담당자님, 안녕하세요.", "", "아래와 같이 공장에 발주했습니다. 입고 준비에 참고해 주세요.", "",
f"- 발주번호: {order['order_no']}", f"- 발주일: {when}", "", "[발주 품목] 제품 코드 · 제품명 · 수량"]
text += [f"- {x['item_code']} · {x['item_name']} · {int(x['qty']):,}개" for x in lines]
text += [f"합계 {total:,}개", "", f"발주 담당: {who} ({sender_email})"]
td = "padding:4px 10px;border:1px solid #d9dce1;font-size:14px;line-height:20px;"
th = f"{td}background:#f6f7f9;font-weight:700;white-space:nowrap;"
r = "text-align:right;white-space:nowrap;"
facts = (f'<tr><th style="{th}text-align:left">발주번호</th><td style="{td}">{e(order["order_no"])}</td>'
f'<th style="{th}text-align:left">발주일</th><td style="{td}">{e(when)}</td></tr>')
rows = "".join(f'<tr><td style="{td}font-family:Consolas,monospace">{e(x["item_code"])}</td><td style="{td}">{e(x["item_name"])}</td>'
f'<td style="{td}{r}">{int(x["qty"]):,}</td></tr>' for x in lines)
html = (
'<div style="font-family:\'Malgun Gothic\',\'Apple SD Gothic Neo\',sans-serif;font-size:14px;color:#1d1d1f;line-height:1.6">'
"<p>입고 담당자님, 안녕하세요.<br>아래와 같이 공장에 발주했습니다. 입고 준비에 참고해 주세요.</p>"
f'<table cellpadding="0" cellspacing="0" style="border-collapse:collapse;margin:8px 0 0">{facts}</table>'
'<div style="height:18px;line-height:18px;font-size:1px">&nbsp;</div>'
'<table cellpadding="0" cellspacing="0" style="border-collapse:collapse;min-width:420px">'
f'<thead><tr><th style="{th}">제품 코드</th><th style="{th}">제품명</th><th style="{th}">수량</th></tr></thead>'
f'<tbody>{rows}</tbody>'
f'<tfoot><tr><th colspan="2" style="{th}text-align:right">합계</th><th style="{th}{r}">{total:,}</th></tr></tfoot></table>'
f'<p style="color:#555;margin-top:18px">발주 담당: {e(who)} (<a href="mailto:{e(sender_email)}">{e(sender_email)}</a>)</p></div>'
)
return {"subject": subject, "text": "\n".join(text), "html": html}
@@ -0,0 +1,28 @@
{# 상태 배지 — 발주서(open·partial·done·over·closed·cancelled) / 품목(none·partial·done·over) #}
{% macro status_badge(status, label) -%}
<span class="io-badge io-st-{{ status }}">{{ label }}</span>
{%- endmacro %}
{# 진행률 막대 — 입고 ÷ 발주 #}
{% macro progress(summary) -%}
<span class="io-progress" title="입고 {{ '{:,}'.format(summary.received) }} / 발주 {{ '{:,}'.format(summary.ordered) }}">
<span class="io-progress-bar{% if summary.over %} is-over{% endif %}" style="width:{{ summary.pct }}%"></span>
</span><span class="io-progress-pct">{{ summary.pct }}%</span>
{%- endmacro %}
{# 날짜 서식 — 2026.10.17(토) / 2026.10.17(토) 15:14 (2026-10-17 요청, 메일·JSON 은 store.fmt_date·fmt_datetime) #}
{% macro ymd(d) -%}{% if d %}{{ d.strftime('%Y.%m.%d') }}({{ '월화수목금토일'[d.weekday()] }}){% endif %}{%- endmacro %}
{% macro ymdhm(d) -%}{% if d %}{{ ymd(d) }} {{ d.strftime('%H:%M') }}{% endif %}{%- endmacro %}
{# 발주서 상태 — 모든 품목이 입고완료·초과입고면 초록 "✓ 전체 입고 완료"(초과가 있으면 "초과 포함"), 나머지는 상태 배지 #}
{% macro order_badge(status, label) -%}
{% if status in ('done', 'over') %}<span class="io-badge io-st-done io-st-all">✓ {{ label }}</span>{% if status == 'over' %}<span class="io-badge-note">초과 포함</span>{% endif %}
{%- else %}{{ status_badge(status, label) }}{% endif %}
{%- endmacro %}
{# 입고 예정일 — 지났는데 남은 게 있으면 빨강 "지연 N일" #}
{% macro due(due_date, today, active) -%}
{% if due_date %}{{ ymd(due_date) }}{% if active and due_date < today %} <span class="io-late">지연 {{ (today - due_date).days }}일</span>{% elif active %} <span class="erp-muted">D-{{ (due_date - today).days }}</span>{% endif %}{% else %}<span class="erp-muted">-</span>{% endif %}
{%- endmacro %}
{% macro n(v) -%}{{ '{:,}'.format(v or 0) }}{%- endmacro %}
@@ -0,0 +1,36 @@
{# 입출고 관리 공용 상단: 탭(발주 목록·미입고 현황) + 담당 표시 + 새 발주서 + 옵션 톱니(관리자, 팝업) + 알림 문구(?msg=) #}
<div class="io-nav">
<a class="erp-btn {% if tab == 'orders' %}erp-btn-primary{% else %}erp-btn-outline{% endif %}" href="/inout/">발주 목록</a>
<a class="erp-btn {% if tab == 'pending' %}erp-btn-primary{% else %}erp-btn-outline{% endif %}" href="/inout/pending">미입고 현황</a>
<span class="io-nav-gap"></span>
<span class="io-roles erp-muted">
{% if perms.can_order %}<span class="erp-badge erp-badge-neutral">발주 담당</span>{% endif %}
{% if perms.can_receive %}<span class="erp-badge erp-badge-neutral">입고 담당</span>{% endif %}
{% if not perms.can_order and not perms.can_receive %}조회만 가능 — 담당 지정은 옵션(관리자){% endif %}
</span>
{% if perms.can_order %}<a class="erp-btn erp-btn-primary" href="/inout/orders/new">+ 새 발주서</a>{% endif %}
{% if perms.admin %}
<button type="button" class="io-gear" id="io-options-btn" title="입출고 관리 옵션" aria-label="입출고 관리 옵션"
aria-haspopup="dialog" {% if open_options %}data-open="1"{% endif %}>
<svg viewBox="0 0 24 24" width="20" height="20" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
<circle cx="12" cy="12" r="3"/>
<path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 1 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 1 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 1 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 1 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"/>
</svg>
</button>
{% endif %}
</div>
{% if msg %}<p class="io-flash" role="status">{{ msg }}</p>{% endif %}
{% if perms.admin %}
{# 옵션 팝업 — 내용은 열 때 GET /inout/settings?panel=1 로 받아 넣고, 저장은 제자리에서(inout.js) #}
<dialog class="io-dlg" id="io-options" aria-labelledby="io-options-title" tabindex="-1">
<header class="io-dlg-head">
<h2 id="io-options-title">입출고 관리 옵션</h2>
<button type="button" class="io-dlg-x" data-close aria-label="닫기" title="닫기">
<svg viewBox="0 0 24 24" width="20" height="20" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M6 6l12 12M18 6L6 18"/></svg>
</button>
</header>
<p class="io-dlg-msg" role="status" hidden></p>
<div class="io-dlg-body" id="io-options-body"><p class="erp-muted">불러오는 중…</p></div>
</dialog>
{% endif %}
@@ -0,0 +1,155 @@
{% from "inout/_macros.html" import ymd %}
{# 옵션 팝업 내용(GET /inout/settings?panel=1) — 탭: 담당자 · 공장 · 상품 정보(004). 폼 저장은 inout.js 가 제자리에서(X-Inout-Options: 1 → JSON).
공장 줄은 표(<table>) 안에 폼을 둘 수 없어 입력칸에 form="…" 속성으로 표 밖 폼에 묶는다 — 열이 머리 줄과 맞는다. #}
<div class="io-dlg-tabs" role="tablist" aria-label="옵션 분류">
<button type="button" role="tab" class="is-active" aria-selected="true" data-pane="roles">담당자</button>
<button type="button" role="tab" aria-selected="false" data-pane="factories" tabindex="-1">공장 <span class="io-dlg-count">{{ factories|length }}</span></button>
<button type="button" role="tab" aria-selected="false" data-pane="products" tabindex="-1">상품 정보 <span class="io-dlg-count">{{ products|length }}</span></button>
<button type="button" role="tab" aria-selected="false" data-pane="logistics" tabindex="-1">물류센터</button>
</div>
<section class="io-dlg-pane" data-pane="roles" role="tabpanel">
<p class="io-help">
<b>발주 담당</b> — 발주서 작성·고치기·잔량 종결·취소. <b>입고 담당</b> — 물류에 들어온 입고 수량 입력·지우기.
그 밖의 사람은 조회만 합니다. ERP 관리자는 지정 없이도 둘 다 할 수 있습니다.
후보 = ERP 관리자 화면에서 <b>입출고 관리</b> 권한을 받은 사용자.
</p>
<form method="post" action="/inout/settings/roles" class="io-dlg-form">
<table class="io-dlg-table">
<thead><tr><th>사용자</th>{% for role, label in role_labels.items() %}<th class="io-c">{{ label }}</th>{% endfor %}</tr></thead>
<tbody>
{% for c in candidates %}
<tr>
<td><b class="io-user">{{ c.name or c.email }}</b><span class="io-sub">{{ c.email }}</span></td>
{% for role in role_labels %}
<td class="io-c"><input type="checkbox" name="{{ role }}_email" value="{{ c.email }}" {% if c.email in roles[role] %}checked{% endif %}
aria-label="{{ c.email }} {{ role_labels[role] }}" /></td>
{% endfor %}
</tr>
{% else %}
<tr><td colspan="3" class="io-empty">입출고 관리 권한을 받은 사용자가 없습니다 — ERP 관리자 화면에서 먼저 권한을 주세요.</td></tr>
{% endfor %}
</tbody>
</table>
<div class="io-dlg-actions"><button type="submit" class="erp-btn erp-btn-primary">담당자 저장</button></div>
</form>
</section>
<section class="io-dlg-pane" data-pane="factories" role="tabpanel" hidden>
<p class="io-help">발주서에서 고르는 공장(발주처)입니다. <b>이메일</b>은 발주 메일을 받을 주소(여러 개는 쉼표). 발주 기록이 있는 공장은 지우지 말고 <b>사용</b>을 끄면 목록에서 숨겨집니다.</p>
<form method="post" action="/inout/settings/order-mail" class="io-dlg-form io-ordercc-form">
<label class="io-logi-field"><span>발주 메일 참조 <small>(모든 발주 메일의 참조 칸에 미리 들어감 — 보낼 때 고칠 수 있음, 여러 개는 쉼표)</small></span>
<span class="io-ordercc-row"><input class="io-in" type="text" inputmode="email" name="order_mail_cc" value="{{ settings.order_mail_cc }}" maxlength="1000"
aria-label="발주 메일 참조" />
<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm"{% if not settings_ready %} disabled title="DB 마이그레이션 inout_db 005 필요"{% endif %}>저장</button></span></label>
</form>
{% for f in factories %}<form method="post" action="/inout/settings/factories" id="io-f{{ f.id }}" class="io-dlg-form"><input type="hidden" name="id" value="{{ f.id }}" /></form>{% endfor %}
<form method="post" action="/inout/settings/factories" id="io-fnew" class="io-dlg-form"><input type="hidden" name="is_active" value="1" /></form>
<table class="io-dlg-table io-factory-table">
<colgroup><col class="w-name" /><col class="w-man" /><col class="w-tel" /><col class="w-mail" /><col class="w-memo" /><col class="w-sort" /><col class="w-use" /><col class="w-cnt" /><col class="w-btn" /></colgroup>
<thead><tr><th>공장 이름</th><th>담당자</th><th>연락처</th><th title="발주 메일을 받을 주소 — 여러 개는 쉼표로">이메일</th><th>메모</th><th class="io-c">순서</th><th class="io-c">사용</th><th class="io-c">발주</th><th></th></tr></thead>
<tbody>
{% for f in factories %}
{% set fid = 'io-f' ~ f.id %}
<tr class="{% if not f.is_active %}is-inactive{% endif %}">
<td><input class="io-in" form="{{ fid }}" type="text" name="name" value="{{ f.name }}" maxlength="100" required aria-label="공장 이름" /></td>
<td><input class="io-in" form="{{ fid }}" type="text" name="manager" value="{{ f.manager }}" maxlength="100" aria-label="담당자" /></td>
<td><input class="io-in" form="{{ fid }}" type="tel" name="contact" value="{{ f.contact }}" maxlength="200" aria-label="연락처" /></td>
<td><input class="io-in" form="{{ fid }}" type="text" inputmode="email" name="email" value="{{ f.email }}" maxlength="600" aria-label="이메일" placeholder="발주 메일 받는 주소" /></td>
<td><input class="io-in" form="{{ fid }}" type="text" name="memo" value="{{ f.memo }}" maxlength="500" aria-label="메모" /></td>
<td class="io-c"><input class="io-in io-in-num" form="{{ fid }}" type="number" name="sort_order" value="{{ f.sort_order }}" aria-label="순서" /></td>
<td class="io-c"><input form="{{ fid }}" type="checkbox" name="is_active" value="1" {% if f.is_active %}checked{% endif %} aria-label="사용" /></td>
<td class="io-c io-sub">{{ f.order_count }}건</td>
<td class="io-btns">
<button form="{{ fid }}" type="submit" class="erp-btn erp-btn-outline erp-btn-sm">저장</button>
{% if not f.order_count %}<button form="{{ fid }}" type="submit" class="erp-btn erp-btn-outline erp-btn-sm" formaction="/inout/settings/factories/{{ f.id }}/delete"
formnovalidate data-confirm="공장 '{{ f.name }}' 을(를) 지울까요?">지우기</button>{% endif %}
</td>
</tr>
{% endfor %}
<tr class="io-new-row">
<td><input class="io-in" form="io-fnew" type="text" name="name" maxlength="100" required placeholder="새 공장 이름" aria-label="새 공장 이름" /></td>
<td><input class="io-in" form="io-fnew" type="text" name="manager" maxlength="100" placeholder="담당자" aria-label="담당자" /></td>
<td><input class="io-in" form="io-fnew" type="tel" name="contact" maxlength="200" placeholder="010-0000-0000" aria-label="연락처" /></td>
<td><input class="io-in" form="io-fnew" type="text" inputmode="email" name="email" maxlength="600" placeholder="factory@example.com" aria-label="이메일" /></td>
<td><input class="io-in" form="io-fnew" type="text" name="memo" maxlength="500" placeholder="메모" aria-label="메모" /></td>
<td class="io-c"><input class="io-in io-in-num" form="io-fnew" type="number" name="sort_order" value="0" aria-label="순서" /></td>
<td></td><td></td>
<td class="io-btns"><button form="io-fnew" type="submit" class="erp-btn erp-btn-primary erp-btn-sm">+ 추가</button></td>
</tr>
</tbody>
</table>
</section>
<section class="io-dlg-pane" data-pane="products" role="tabpanel" hidden>
{% if not products_ready %}
<p class="io-error">DB 마이그레이션 inout_db 004(상품 정보)가 아직 적용되지 않았습니다 — 관리자에게 알려 주세요.</p>
{% else %}
<p class="io-help">
코드표의 단품을 불러와 <b>단가</b>(원)·<b>무게</b>(개당 g = PP량)·<b>은(Ag) 함유량</b>(%)을 넣습니다 — 은 함량(g)은 무게 × %로 자동 계산.
값을 넣은 상품은 다시 불러와도 그대로이고, 지운 단품은 다음 불러오기에서 빠집니다. 발주서 제품은 이 목록에서 고르며, 발주할 때의 값이 발주서에 남습니다.
</p>
<div class="io-prod-bar">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" id="io-prod-import">단품 불러오기</button>
<input type="search" class="io-in io-prod-search" id="io-prod-search" placeholder="코드·제품명 찾기" aria-label="상품 찾기" />
<span class="io-sub" id="io-prod-count">{{ products|length }}개{% if excluded %} · 제외 {{ excluded|length }}개{% endif %}</span>
<span class="io-nav-gap"></span>
<button type="button" class="erp-btn erp-btn-primary erp-btn-sm" id="io-prod-save" disabled>변경 저장 <span id="io-prod-dirty"></span></button>
</div>
{% if products %}
<div class="io-prod-scroll">
<table class="io-dlg-table io-prod-table">
<colgroup><col class="w-code" /><col /><col class="w-num" /><col class="w-num" /><col class="w-num" /><col class="w-ag" /><col class="w-del" /></colgroup>
<thead><tr><th>코드</th><th>제품명</th><th class="io-r">단가(원)</th><th class="io-r">무게·PP(g/개)</th><th class="io-r">은 함유량(%)</th><th class="io-r">은(g/개)</th><th></th></tr></thead>
<tbody>
{% for p in products %}
<tr data-code="{{ p.item_code }}" data-search="{{ (p.item_code ~ ' ' ~ p.item_name)|lower }}">
<td class="io-code">{{ p.item_code }}</td>
<td class="io-prod-name">{{ p.item_name }}</td>
<td><input class="io-in io-in-num" data-key="unit_price" value="{{ fmt_num(p.unit_price) if p.unit_price is not none else '' }}" inputmode="decimal" aria-label="{{ p.item_code }} 단가" /></td>
<td><input class="io-in io-in-num" data-key="weight_g" value="{{ fmt_num(p.weight_g) if p.weight_g is not none else '' }}" inputmode="decimal" aria-label="{{ p.item_code }} 무게" /></td>
<td><input class="io-in io-in-num" data-key="silver_pct" value="{{ fmt_num(p.silver_pct, 4) if p.silver_pct is not none else '' }}" inputmode="decimal" aria-label="{{ p.item_code }} 은 함유량" /></td>
<td class="io-r io-ag" title="무게 × 은 함유량 ÷ 100">{{ fmt_num(p.silver_g, 4) if p.silver_g is not none else '-' }}</td>
<td class="io-r"><button type="button" class="io-icon-btn" data-exclude="{{ p.item_code }}" title="지우기 — 다음 불러오기에서도 뺌" aria-label="{{ p.item_code }} 지우기">✕</button></td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="io-empty">아직 불러온 단품이 없습니다 — [단품 불러오기]를 누르세요. (그 전에는 발주서에서 코드표 단품을 바로 고릅니다)</p>
{% endif %}
{% if excluded %}
<details class="io-excluded">
<summary>제외 목록 {{ excluded|length }}개 — 불러오기에서 빠지는 단품</summary>
<ul>
{% for x in excluded %}
<li><span class="io-code">{{ x.item_code }}</span> {{ x.item_name }} <span class="io-sub">· {{ ymd(x.excluded_at) }}</span>
<button type="button" class="io-link-btn" data-restore="{{ x.item_code }}">되살리기</button></li>
{% endfor %}
</ul>
</details>
{% endif %}
{% endif %}
</section>
<section class="io-dlg-pane" data-pane="logistics" role="tabpanel" hidden>
{% if not settings_ready %}
<p class="io-error">DB 마이그레이션 inout_db 005(물류센터 이메일·입고 요청 메일)가 아직 적용되지 않았습니다 — 관리자에게 알려 주세요.</p>
{% endif %}
<p class="io-help">
입고 담당이 <b>입고 저장</b>을 누르면 물류센터 입고 담당자에게 보낼 <b>입고 요청 메일</b>(전산 등록 부탁 · 입고 상품 표 · 입고증 사진)을
미리 보여 주고, [메일 발송]을 눌러 입고 담당 본인 Gmail 로 보냅니다. 아래 주소가 받는 사람·참조 칸에 미리 들어갑니다(보낼 때 고칠 수 있음).
</p>
<form method="post" action="/inout/settings/logistics" class="io-dlg-form io-logi-form">
<label class="io-logi-field"><span>물류센터 담당자 이메일 <small>(받는 사람 — 여러 개는 쉼표)</small></span>
<input class="io-in" type="text" inputmode="email" name="logistics_emails" value="{{ settings.logistics_emails }}" maxlength="1000"
placeholder="logistics@example.com" aria-label="물류센터 담당자 이메일" /></label>
<label class="io-logi-field"><span>입고 요청 메일 참조 <small>(여러 개는 쉼표)</small></span>
<input class="io-in" type="text" inputmode="email" name="receipt_mail_cc" value="{{ settings.receipt_mail_cc }}" maxlength="1000"
aria-label="입고 요청 메일 참조" /></label>
<div class="io-dlg-actions"><button type="submit" class="erp-btn erp-btn-primary"{% if not settings_ready %} disabled{% endif %}>물류센터 저장</button></div>
</form>
</section>
<p class="io-dlg-foot">코드표(단품) 연결: {{ items_status }}</p>
@@ -0,0 +1,71 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import order_badge, progress, due, n, ymd %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261019g" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="io-filter" method="get" action="/inout/">
{# 상태 = 링크(다른 거르기 값 유지). 검색 칸 Enter 는 아래 [찾기] — 상태는 숨은 칸 값 그대로 #}
{% set keep = {'factory': filters.factory or '', 'q': filters.q, 'from': filters['from'], 'to': filters['to']} %}
<div class="io-seg" role="group" aria-label="상태">
{% for key, f in status_filters.items() %}
<a href="/inout/?{{ dict(keep, status=key) | urlencode }}" class="io-seg-btn{% if filters.status == key %} is-active{% endif %}"
{% if filters.status == key %}aria-current="true"{% endif %}>{{ f[0] }}</a>
{% endfor %}
</div>
<input type="hidden" name="status" value="{{ filters.status }}" />
<select class="erp-select" name="factory" aria-label="공장" onchange="this.form.submit()">
<option value="">전체 공장</option>
{% for f in factories %}<option value="{{ f.id }}" {% if filters.factory == f.id %}selected{% endif %}>{{ f.name }}{% if not f.is_active %} (사용 안 함){% endif %}</option>{% endfor %}
</select>
<label class="io-date">발주일 <input class="erp-input" type="date" name="from" value="{{ filters['from'] }}" /></label>
<span class="erp-muted">~</span>
<input class="erp-input" type="date" name="to" value="{{ filters['to'] }}" aria-label="발주일 끝" />
<input class="erp-input io-search" type="search" name="q" value="{{ filters.q }}" placeholder="발주번호·제품 코드·제품 이름" />
<button type="submit" class="erp-btn erp-btn-outline">찾기</button>
</form>
<div class="erp-card-block">
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr>
<th>발주번호</th><th>공장</th><th>제품</th><th>발주일</th><th>입고 예정일</th>
<th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">미입고</th><th>진행</th><th>상태</th>
{% if perms.super %}<th class="io-col-trash"><span class="sr-only">삭제</span></th>{% endif %}
</tr></thead>
<tbody>
{% for o in orders %}
{% set active = o.status in ('open', 'partial') %}
<tr class="io-row-link" data-href="/inout/orders/{{ o.id }}">
<td><a href="/inout/orders/{{ o.id }}" class="io-order-no">{{ o.order_no }}</a></td>
<td>{{ o.factory_name }}</td>
<td class="io-items">{{ o.items_label }}<div class="erp-row-sub">{{ o.line_count }}종</div></td>
<td>{{ ymd(o.order_date) }}</td>
<td>{{ due(o.due_date, today, active) }}</td>
<td class="io-num">{{ n(o.summary.ordered) }}</td>
<td class="io-num">{{ n(o.summary.received) }}</td>
<td class="io-num{% if o.summary.remaining and active %} io-remaining{% endif %}">{{ n(o.summary.remaining) }}{% if o.summary.over %}<div class="io-over-sub">초과 +{{ n(o.summary.over) }}</div>{% endif %}</td>
<td class="io-progress-cell">{{ progress(o.summary) }}</td>
<td class="io-status-cell">{{ order_badge(o.status, o.status_label) }}</td>
{% if perms.super %}
{# 수퍼관리자만 — 완전 삭제(품목·입고 기록·사진·메일 기록까지) #}
<td class="io-col-trash"><form method="post" action="/inout/orders/{{ o.id }}/delete"
data-erp-confirm="{{ o.order_no }} 발주서를 완전히 삭제할까요?{% if o.summary.received %} 입고 {{ n(o.summary.received) }}개 기록과 입고증 사진{% else %} 품목{% endif %}·발주 메일 기록까지 모두 지워지고 되돌릴 수 없습니다.">
<input type="hidden" name="back" value="{{ request.url.path }}{% if request.url.query %}?{{ request.url.query }}{% endif %}" />
<button type="submit" class="io-icon-btn io-del-btn" title="발주 삭제(수퍼관리자)" aria-label="{{ o.order_no }} 발주 삭제">
<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 7h16M9 7V4h6v3M6 7l1 13h10l1-13M10 11v6M14 11v6"/></svg>
</button></form></td>
{% endif %}
</tr>
{% else %}
<tr><td colspan="{{ 11 if perms.super else 10 }}" class="erp-empty">{% if filters.status == 'active' %}진행 중인 발주가 없습니다.{% else %}조건에 맞는 발주가 없습니다.{% endif %}</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261019c" defer></script>{% endblock %}
@@ -0,0 +1,256 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import status_badge, order_badge, progress, due, n, ymd, ymdhm %}
{#- 메일 창(발주 메일 · 입고 요청 메일 같은 모양) — 열면 미리보기 GET, [메일 발송]을 눌러야 보낸다(inout.js initMail) -#}
{%- macro mail_dialog(id, title, open_url='', open_title='') -%}
<dialog class="io-dlg io-mail-dlg" id="{{ id }}" aria-labelledby="{{ id }}-title" tabindex="-1"
{%- if open_url %} data-open-url="{{ open_url }}" data-open-title="{{ open_title }}"{% endif %}>
<header class="io-dlg-head">
<h2 id="{{ id }}-title" data-mail-title>{{ title }}</h2>
<button type="button" class="io-dlg-x" data-close aria-label="닫기" title="닫기">
<svg viewBox="0 0 24 24" width="20" height="20" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" aria-hidden="true"><path d="M6 6l12 12M18 6L6 18"/></svg>
</button>
</header>
<p class="io-dlg-msg" role="status" hidden></p>
<div class="io-dlg-body" data-mail-body><p class="erp-muted">불러오는 중…</p></div>
<footer class="io-dlg-footbar" data-mail-foot hidden>
<button type="button" class="io-link-btn" data-gmail-disconnect>Gmail 연결 끊기</button>
<span class="io-nav-gap"></span>
<button type="button" class="erp-btn erp-btn-outline" data-close>취소</button>
<button type="button" class="erp-btn erp-btn-primary" data-mail-send>메일 발송</button>
</footer>
</dialog>
{%- endmacro -%}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261019g" />{% endblock %}
{% block content %}
{% set active = order.status in ('open', 'partial') %}
{% set receiving = perms.can_receive and can_receive_now %}
{# 전체 입고 완료(모든 품목 입고완료·초과) — 입고 칸·[입고 저장]을 흐리게 막는다(서버도 거절, 2026-10-19). 입고 기록을 지우면 다시 열림 #}
{% set recv_done = order.status in ('done', 'over') %}
{% set dis = ' disabled' if recv_done else '' %}
{% set photo_admin = perms.can_receive and not order.cancelled_at %}
<section class="io">
{% include "inout/_nav.html" %}
<div class="erp-card-block io-head">
<div class="io-head-main">
<div class="io-head-title">
<h2>{{ order.order_no }}</h2>{{ order_badge(order.status, order.status_label) }}
</div>
<dl class="io-head-meta">
<div><dt>공장</dt><dd>{{ order.factory_name }}{% if order.factory_manager or order.factory_contact %}<span class="io-factory-who">{{ order.factory_manager }}{% if order.factory_manager and order.factory_contact %} · {% endif %}{{ order.factory_contact }}</span>{% endif %}</dd></div>
<div><dt>발주일</dt><dd>{{ ymd(order.order_date) }}</dd></div>
<div><dt>입고 예정일</dt><dd>{{ due(order.due_date, today, active) }}</dd></div>
<div><dt>진행</dt><dd>{{ progress(order.summary) }}</dd></div>
<div><dt>발주 메일</dt><dd>{% if order.mails %}{% set last = order.mails[-1] %}<span class="io-mail-sent">보냄 {{ ymdhm(last.sent_at) }}</span><span class="io-factory-who">{{ last.sent_by }} → {{ last.to_addrs }}{% if order.mails|length > 1 %} · 모두 {{ order.mails|length }}번{% endif %}</span>{% else %}<span class="erp-muted">아직 안 보냄</span>{% endif %}</dd></div>
{% if order.memo %}<div class="io-wide"><dt>메모</dt><dd>{{ order.memo }}</dd></div>{% endif %}
{% if order.closed_at %}<div class="io-wide"><dt>종결</dt><dd>{{ ymd(order.closed_at) }} · {{ order.closed_by }}{% if order.close_reason %} — {{ order.close_reason }}{% endif %}</dd></div>{% endif %}
{% if order.cancelled_at %}<div class="io-wide"><dt>취소</dt><dd>{{ ymd(order.cancelled_at) }} · {{ order.cancelled_by }}</dd></div>{% endif %}
</dl>
</div>
<div class="io-kpis io-kpis-head">
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">발주</div><div class="erp-summary-value">{{ n(order.summary.ordered) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">입고</div><div class="erp-summary-value">{{ n(order.summary.received) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini{% if order.summary.remaining and active %} io-kpi-remaining{% endif %}"><div class="erp-summary-label">미입고</div><div class="erp-summary-value">{{ n(order.summary.remaining) }}</div></div>
{% if order.summary.over %}<div class="erp-summary-card erp-summary-card--mini io-kpi-over"><div class="erp-summary-label">초과</div><div class="erp-summary-value">+{{ n(order.summary.over) }}</div></div>{% endif %}
</div>
{% if perms.can_order and not order.cancelled_at %}
<div class="io-head-actions">
<button type="button" class="erp-btn erp-btn-primary erp-btn-sm io-mail-btn" id="io-mail-btn" data-order="{{ order.id }}"
{% if open_mail %}data-open="1"{% endif %} aria-haspopup="dialog">
<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="3" y="5" width="18" height="14" rx="2"/><path d="m3 7 9 6 9-6"/></svg>
{% if order.mails %}발주 메일 다시 보내기{% else %}발주 메일 보내기{% endif %}</button>
<a class="erp-btn erp-btn-outline erp-btn-sm" href="/inout/orders/{{ order.id }}/edit">발주서 고치기</a>
{% if order.closed_at %}
<form method="post" action="/inout/orders/{{ order.id }}/reopen"><button class="erp-btn erp-btn-outline erp-btn-sm" type="submit">종결 풀기</button></form>
{% elif order.summary.remaining %}
<form method="post" action="/inout/orders/{{ order.id }}/close" class="io-close-form" data-erp-confirm="남은 미입고 {{ n(order.summary.remaining) }}개를 더 기다리지 않고 종결할까요? 미입고 현황에서 빠집니다.">
<input class="erp-input io-close-reason" type="text" name="reason" maxlength="500" placeholder="종결 사유(선택)" />
<button class="erp-btn erp-btn-outline erp-btn-sm" type="submit">잔량 종결</button>
</form>
{% endif %}
{% if not order.receipts %}
<form method="post" action="/inout/orders/{{ order.id }}/cancel" data-erp-confirm="이 발주서를 취소할까요? (입고 기록이 없을 때만)">
<button class="erp-btn erp-btn-danger erp-btn-sm" type="submit">발주 취소</button>
</form>
{% endif %}
</div>
{% endif %}
</div>
{% if error %}<div class="io-error" role="alert">{% for line in error.split('\n') %}<div>{{ line }}</div>{% endfor %}</div>{% endif %}
<form method="post" action="/inout/orders/{{ order.id }}/receipts" class="erp-card-block io-block" id="io-receipt-form" enctype="multipart/form-data">
{# Enter 키 = 이 버튼(일반 저장). 없으면 폼의 첫 제출 버튼인 [초과 입고로 저장]이 눌려 확인 없이 초과가 저장된다 #}
{% if receiving %}<button type="submit" class="io-default-submit" tabindex="-1" aria-hidden="true"{{ dis }}>입고 저장</button>{% endif %}
<input type="hidden" name="confirm_over" value="" id="io-confirm-over" />
<div class="erp-card-block-head">
<h2>품목</h2>
{% if receiving and recv_done %}<span class="erp-muted io-recv-done-note">✓ 전체 입고 완료 — 더 입고할 수 없습니다(잘못 넣은 입고는 아래 입고 기록에서 지운 뒤 다시 넣으세요)</span>
{% elif receiving %}<span class="erp-muted">물류에 들어온 수량을 [이번 입고]에 넣고 저장 — 여러 번 나눠 넣어도 됩니다</span>
{% elif perms.can_receive and order.closed_at %}<span class="erp-muted">종결된 발주서 — 입고하려면 발주 담당이 종결을 풀어야 합니다</span>{% endif %}
</div>
{% if over %}
<div class="io-over-box" role="alert">
<b>발주보다 많이 입고하려고 합니다.</b> 맞으면 [초과 입고로 저장]을 누르세요.
<ul>{% for o in over %}<li>{% if not items_limited %}<span class="io-code">{{ o.item_code }}</span> {% endif %}{{ o.item_name }} — 발주 {{ n(o.ordered) }}개, 입고 후 {{ n(o.after) }}개 (<b>+{{ n(o.over) }}</b>)</li>{% endfor %}</ul>
{% if photos_lost %}<p class="io-photo-lost">고른 입고증 사진은 다시 첨부해야 합니다(화면이 다시 열리면서 빠졌습니다).</p>{% endif %}
<button type="submit" class="io-btn-over" name="confirm_over" value="1">초과 입고로 저장</button>
<span class="erp-muted">숫자를 고치려면 아래 칸을 고친 뒤 [입고 저장]</span>
</div>
{% elif photos_lost %}
<p class="io-error">고른 입고증 사진은 다시 첨부해야 합니다(화면이 다시 열리면서 빠졌습니다).</p>
{% endif %}
<div class="erp-table-wrap">
<table class="erp-table io-table">
{# 입고 담당(발주 담당 아님) = 제품 이름·발주 수량(+ 이번 입고)만, 발주 담당 = 단가·금액·PP·은 함께 #}
<thead><tr><th class="io-col-no">#</th>{% if not items_limited %}<th>제품 코드</th>{% endif %}<th>제품</th><th class="io-num">발주</th>
{% if show_prices %}<th class="io-num io-col-money">단가(원)</th><th class="io-num io-col-money">금액(원)</th><th class="io-num io-col-spec">PP(g/개)</th><th class="io-num io-col-spec">은(Ag)</th>{% endif %}
{% if not items_limited %}<th class="io-num">입고</th><th class="io-num">미입고</th><th>상태</th>{% endif %}
{% if receiving %}<th class="io-col-recv">이번 입고</th>{% endif %}</tr></thead>
<tbody>
{% for ln in order.lines %}
<tr>
<td class="io-col-no">{{ loop.index }}</td>
{% if not items_limited %}<td class="io-code">{{ ln.item_code }}</td>{% endif %}
<td>{{ ln.item_name }}{% if ln.memo %}<div class="erp-row-sub">{{ ln.memo }}</div>{% endif %}</td>
<td class="io-num">{{ n(ln.qty) }}</td>
{% if show_prices %}
{% set amt = line_amount(ln.qty, ln.unit_price) %}{% set ag = silver_g(ln.weight_g, ln.silver_pct) %}
<td class="io-num io-col-money">{{ fmt_num(ln.unit_price) if ln.unit_price is not none else '-' }}</td>
<td class="io-num io-col-money">{{ fmt_num(amt) if amt is not none else '-' }}</td>
<td class="io-num io-col-spec">{{ fmt_num(ln.weight_g) if ln.weight_g is not none else '-' }}</td>
<td class="io-num io-col-spec">{% if ln.silver_pct is not none %}{{ fmt_num(ln.silver_pct, 4) }}%{% if ag is not none %}<div class="erp-row-sub">{{ fmt_num(ag, 4) }}g/개</div>{% endif %}{% else %}-{% endif %}</td>
{% endif %}
{% if not items_limited %}
<td class="io-num">{{ n(ln.received) }}</td>
<td class="io-num{% if ln.remaining and active %} io-remaining{% endif %}">{{ n(ln.remaining) }}{% if ln.over %}<div class="io-over-sub">초과 +{{ n(ln.over) }}</div>{% endif %}</td>
<td>{{ status_badge(ln.status, ln.status_label) }}</td>
{% endif %}
{% if receiving %}<td class="io-col-recv"><input class="erp-input io-qty io-recv" type="text" inputmode="numeric" name="qty_{{ ln.id }}"
value="{{ receipt_form.qty.get(ln.id, '') }}" data-remaining="{{ ln.remaining }}" data-ordered="{{ ln.qty }}" data-received="{{ ln.received }}"
data-code="{{ ln.item_code }}" data-name="{{ ln.item_name }}" placeholder="{{ ln.remaining if ln.remaining and not items_limited else '' }}"
aria-label="{{ ln.item_name }} 이번 입고 수량"{{ dis }} /></td>{% endif %}
</tr>
{% endfor %}
</tbody>
{% if show_prices and order.lines %}
<tfoot><tr class="io-total-row">
<td colspan="3">합계</td>
<td class="io-num">{{ n(order.summary.ordered) }}</td>
<td class="io-num io-col-money"></td>
<td class="io-num io-col-money"><b>{{ fmt_num(totals.amount) if totals.amount is not none else '-' }}</b>{% if totals.missing_price %}<div class="erp-row-sub">단가 미입력 {{ totals.missing_price }}종 제외</div>{% endif %}</td>
<td class="io-num io-col-spec">{% if totals.pp_kg is not none %}{{ fmt_num(totals.pp_kg, 3) }}kg{% else %}-{% endif %}</td>
<td class="io-num io-col-spec">{% if totals.silver_g is not none %}{{ fmt_num(totals.silver_g, 2) }}g{% else %}-{% endif %}</td>
{% if not items_limited %}<td colspan="3"></td>{% endif %}
{% if receiving %}<td></td>{% endif %}
</tr></tfoot>
{% endif %}
</table>
</div>
{% if receiving %}
<div class="io-receipt-bar{% if recv_done %} is-locked{% endif %}"{% if recv_done %} aria-disabled="true" title="전체 입고 완료 — 더 입고할 수 없습니다"{% endif %}>
<label class="erp-field"><span>입고일 *</span><input type="date" name="receipt_date" value="{{ receipt_form.receipt_date }}" required{{ dis }} /></label>
<label class="erp-field io-grow"><span>메모</span><input type="text" name="memo" value="{{ receipt_form.memo }}" maxlength="500" placeholder="차량·박스 수·검수 메모 등"{{ dis }} /></label>
<div class="erp-field io-photo-field">
<span>입고증 사진 <small>(최대 {{ max_photos }}장)</small></span>
<label class="io-photo-pick">
<input type="file" name="photos" accept="image/*" multiple id="io-photo-input" class="io-photo-input" data-max="{{ max_photos }}"{{ dis }} />
<svg class="io-photo-pick-icon" viewBox="0 0 24 24" width="28" height="28" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 8h3l2-3h6l2 3h3v11H4z"/><circle cx="12" cy="13" r="3.5"/></svg>
입고증 업로드
</label>
</div>
<button type="button" class="erp-btn erp-btn-outline" id="io-fill-remaining"{{ dis }}>남은 수량 모두 채우기</button>
<button type="submit" class="erp-btn erp-btn-primary io-recv-save"{{ dis }}>입고 저장 <span id="io-recv-total"></span></button>
<div class="io-photo-previews" id="io-photo-previews" aria-live="polite"></div>
</div>
{% endif %}
</form>
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>입고 기록</h2><span class="erp-muted">{{ order.receipts|length }}회</span></div>
{% if order.receipts %}
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>입고일</th><th>품목별 수량</th><th class="io-num">합계</th><th>입고증</th><th>입력</th><th>입고 요청 메일 · 사방넷</th>{% if photo_admin %}<th></th>{% endif %}</tr></thead>
<tbody>
{% for r in order.receipts %}
<tr>
<td>{{ ymd(r.receipt_date) }}{% if r.memo %}<div class="erp-row-sub">{{ r.memo }}</div>{% endif %}</td>
<td>{% for x in r.lines %}<span class="io-chip">{% if items_limited %}{{ x.item_name }}{% else %}<span class="io-code">{{ x.item_code }}</span>{% endif %} {{ n(x.qty) }}</span>{% endfor %}</td>
<td class="io-num">{{ n(r.total) }}</td>
<td class="io-photos-cell">
{% for ph in r.photos %}
<button type="button" class="io-thumb" data-photo="{{ ph.id }}" data-receipt="{{ r.id }}" data-type="{{ ph.content_type }}"
data-name="{{ ph.filename }}" title="{{ ph.filename }} — 크게 보기" aria-label="입고증 사진 크게 보기 {{ loop.index }}">
{% if ph.content_type == 'image/heic' %}<span class="io-thumb-heic">HEIC</span>{% else %}<img src="/inout/photos/{{ ph.id }}" alt="" loading="lazy" />{% endif %}
</button>
{% endfor %}
{% if photo_admin and r.photos|length < max_photos %}
<form method="post" action="/inout/orders/{{ order.id }}/receipts/{{ r.id }}/photos" enctype="multipart/form-data" class="io-add-photo-form">
<label class="io-thumb io-thumb-add" title="입고증 사진 더하기">
<input type="file" name="photos" accept="image/*" multiple class="io-photo-input io-photo-auto" data-max="{{ max_photos - r.photos|length }}" aria-label="입고증 사진 더하기" />
<span aria-hidden="true">+</span>
</label>
</form>
{% elif not r.photos %}<span class="erp-muted">-</span>{% endif %}
</td>
<td class="erp-muted">{{ r.created_by }}<div class="erp-row-sub">{{ ymdhm(r.created_at) }}</div></td>
<td class="io-rmail-cell">
{% if r.mails %}{% set lm = r.mails[-1] %}<span class="io-mail-sent">보냄 {{ ymdhm(lm.sent_at) }}</span>
<div class="erp-row-sub">{{ lm.sent_by }}{% if r.mails|length > 1 %} · 모두 {{ r.mails|length }}번{% endif %}</div>{% endif %}
{% if perms.can_receive %}<button type="button" class="erp-btn erp-btn-outline erp-btn-sm io-rmail-btn" aria-haspopup="dialog"
data-url="/inout/orders/{{ order.id }}/receipts/{{ r.id }}/mail" data-title="입고 요청 메일 · {{ ymd(r.receipt_date) }} 입고 {{ n(r.total) }}개">
{% if r.mails %}다시 보내기{% else %}보내기{% endif %}</button>
{% elif not r.mails %}<span class="erp-muted">-</span>{% endif %}
{% if perms.can_order or perms.can_receive %}
<a class="erp-btn erp-btn-outline erp-btn-sm io-sabang-btn" href="/inout/orders/{{ order.id }}/receipts/{{ r.id }}/sabangnet.xlsx"
title="사방넷 입고 엑셀 — 상품코드(사방넷 코드)·가용수량(입고 수량)·불용수량(상품 이름)" download>사방넷 입고 파일</a>
{% endif %}
</td>
{% if photo_admin %}
<td><form method="post" action="/inout/orders/{{ order.id }}/receipts/{{ r.id }}/delete"
data-erp-confirm="{{ ymd(r.receipt_date) }} 입고 {{ n(r.total) }}개 기록을 지울까요? 그만큼 다시 미입고가 되고 입고증 사진도 지워집니다.">
<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm">지우기</button></form></td>
{% endif %}
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-empty">아직 입고된 것이 없습니다.</p>
{% endif %}
</div>
{# 입고증 사진 크게 보기 — 앞뒤 넘기기(←/→), 원본 열기, 지우기(입고 담당) #}
<dialog class="io-viewer" id="io-viewer" tabindex="-1" aria-label="입고증 사진" data-order="{{ order.id }}" data-can-delete="{{ '1' if photo_admin else '' }}">
<div class="io-viewer-bar">
<span class="io-viewer-title" id="io-viewer-title"></span>
<a class="io-viewer-btn" id="io-viewer-open" href="#" target="_blank" rel="noopener">원본</a>
{% if photo_admin %}<form method="post" id="io-viewer-del" data-erp-confirm="이 입고증 사진을 지울까요?"><button type="submit" class="io-viewer-btn">지우기</button></form>{% endif %}
<button type="button" class="io-viewer-btn" data-close aria-label="닫기">✕</button>
</div>
<button type="button" class="io-viewer-nav is-prev" data-step="-1" aria-label="이전 사진">‹</button>
<img class="io-viewer-img" id="io-viewer-img" alt="입고증 사진" />
<p class="io-viewer-heic" id="io-viewer-heic" hidden>HEIC 사진은 이 브라우저에서 미리 볼 수 없습니다 — [원본]으로 내려받으세요.</p>
<button type="button" class="io-viewer-nav is-next" data-step="1" aria-label="다음 사진">›</button>
</dialog>
{% if perms.can_order and not order.cancelled_at %}
{# 발주 메일 — 열면 GET /inout/orders/{id}/mail 로 미리보기, [메일 발송]을 눌러야 보낸다(발주 담당 본인 Gmail) #}
{{ mail_dialog('io-mail', '발주 메일 보내기 · ' ~ order.order_no) }}
{% endif %}
{% if perms.can_receive and order.receipts %}
{# 입고 요청 메일(005) — 물류센터 입고 담당자에게 전산 등록 부탁(입고 담당 본인 Gmail). 입고 저장 뒤 ?rmail={입고 id} 면 바로 연다 #}
{% set open_r = order.receipts | selectattr('id', 'equalto', open_rmail) | list if open_rmail else [] %}
{% if open_r %}
{{ mail_dialog('io-rmail', '입고 요청 메일', '/inout/orders/' ~ order.id ~ '/receipts/' ~ open_r[0].id ~ '/mail',
'입고 요청 메일 · ' ~ ymd(open_r[0].receipt_date) ~ ' 입고 ' ~ n(open_r[0].total) ~ '개') }}
{% else %}{{ mail_dialog('io-rmail', '입고 요청 메일') }}{% endif %}
{% endif %}
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261019c" defer></script>{% endblock %}
@@ -0,0 +1,83 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261019g" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="erp-card-block io-order-form" method="post" id="io-order-form"
action="{% if order %}/inout/orders/{{ order.id }}/edit{% else %}/inout/orders/new{% endif %}">
<div class="erp-card-block-head">
<h2>{% if order %}발주서 고치기 · {{ order.order_no }}{% else %}새 발주서{% endif %}</h2>
<span class="erp-muted">{% if from_catalog %}제품은 옵션 → 상품 정보의 단품에서 고릅니다(단가 함께){% else %}제품은 코드표의 단품에서 고릅니다{% endif %}</span>
</div>
{% if error %}<div class="io-error" role="alert">{% for line in error.split('\n') %}<div>{{ line }}</div>{% endfor %}</div>{% endif %}
{% if not items_enabled %}<div class="io-error" role="alert">제품을 고를 목록이 없습니다 — 관리자가 옵션 → 상품 정보에서 단품을 불러오거나 코드표 DB(ITEMCODE_DB_URL)를 연결해야 합니다.</div>{% endif %}
<div class="erp-form-grid">
<label class="erp-field"><span>공장 *</span>
<select name="factory_id" required>
<option value="">공장 고르기</option>
{% for f in factories %}<option value="{{ f.id }}" {% if vals.factory_id|string == f.id|string %}selected{% endif %}>{{ f.name }}</option>{% endfor %}
</select>
{% if not factories %}<span class="io-hint">공장이 없습니다 — 관리자가 옵션에서 먼저 공장을 추가해야 합니다.</span>{% endif %}
</label>
<label class="erp-field"><span>발주일 *</span><input type="date" name="order_date" value="{{ vals.order_date }}" required /></label>
<label class="erp-field"><span>입고 예정일</span><input type="date" name="due_date" value="{{ vals.due_date }}" /></label>
<label class="erp-field"><span>메모</span><input type="text" name="memo" value="{{ vals.memo }}" maxlength="500" placeholder="공장 전달 사항 등" /></label>
</div>
<div class="erp-table-wrap">
<table class="erp-table io-table io-lines" id="io-lines">
<thead><tr><th class="io-col-no">#</th><th>제품(코드·이름으로 검색)</th><th class="io-col-qty">발주 수량</th><th class="io-col-money">단가(원)</th><th class="io-col-money">금액(원)</th><th>줄 메모</th><th class="io-col-del"></th></tr></thead>
<tbody>
{% for ln in lines %}
{% set received = (order.lines | selectattr('item_code', 'equalto', ln.code) | map(attribute='received') | first) if order else 0 %}
<tr class="io-line" data-price="{{ ln.price if ln.price is not none else '' }}">
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="{{ ln.code }}" />
<input type="hidden" name="item_name" value="{{ ln.name }}" />
<input class="erp-input io-item-search" type="text" value="{{ ln.code }}{% if ln.name %} · {{ ln.name }}{% endif %}" autocomplete="off"
placeholder="코드 또는 이름" {% if received %}readonly title="입고된 제품은 바꿀 수 없습니다(수량은 바꿀 수 있음)"{% endif %} />
{% if received %}<div class="erp-row-sub">입고 {{ '{:,}'.format(received) }}개 — 제품은 그대로, 수량만 바꿀 수 있습니다</div>{% endif %}
</td>
<td class="io-col-qty"><input class="erp-input io-qty" type="text" inputmode="numeric" name="qty" value="{{ ln.qty }}" placeholder="0" /></td>
<td class="io-col-money io-price">{{ ln.price_label or '-' }}</td>
<td class="io-col-money io-amount">-</td>
<td><input class="erp-input" type="text" name="line_memo" value="{{ ln.memo }}" maxlength="500" /></td>
<td class="io-col-del">{% if not received %}<button type="button" class="erp-btn erp-btn-outline erp-btn-sm io-del" aria-label="이 줄 지우기" title="이 줄 지우기">✕</button>{% endif %}</td>
</tr>
{% endfor %}
</tbody>
<tfoot><tr><td colspan="7">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" id="io-add-line">+ 제품 줄 추가</button>
<span class="erp-muted io-total">합계 <b id="io-total-qty">0</b>개 · <b id="io-total-lines">0</b>종 · 금액 <b id="io-total-amount">0</b>원<span id="io-total-noprice"></span></span>
</td></tr></tfoot>
</table>
</div>
<template id="io-line-tpl">
<tr class="io-line">
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="" />
<input type="hidden" name="item_name" value="" />
<input class="erp-input io-item-search" type="text" value="" autocomplete="off" placeholder="코드 또는 이름" />
</td>
<td class="io-col-qty"><input class="erp-input io-qty" type="text" inputmode="numeric" name="qty" value="" placeholder="0" /></td>
<td class="io-col-money io-price">-</td>
<td class="io-col-money io-amount">-</td>
<td><input class="erp-input" type="text" name="line_memo" value="" maxlength="500" /></td>
<td class="io-col-del"><button type="button" class="erp-btn erp-btn-outline erp-btn-sm io-del" aria-label="이 줄 지우기" title="이 줄 지우기">✕</button></td>
</tr>
</template>
<div class="io-form-actions">
<a class="erp-btn erp-btn-outline" href="{% if order %}/inout/orders/{{ order.id }}{% else %}/inout/{% endif %}">취소</a>
<button type="submit" class="erp-btn erp-btn-primary">{% if order %}고친 내용 저장{% else %}발주서 저장{% endif %}</button>
</div>
</form>
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261019c" defer></script>{% endblock %}
@@ -0,0 +1,91 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import due, n, ymd %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261019g" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="io-filter" method="get" action="/inout/pending">
<select class="erp-select" name="factory" aria-label="공장" onchange="this.form.submit()">
<option value="">전체 공장</option>
{% for f in factories %}<option value="{{ f.id }}" {% if filters.factory == f.id %}selected{% endif %}>{{ f.name }}{% if not f.is_active %} (사용 안 함){% endif %}</option>{% endfor %}
</select>
<input class="erp-input io-search" type="search" name="q" value="{{ filters.q }}" placeholder="제품 코드·제품 이름·발주번호" />
<button type="submit" class="erp-btn erp-btn-outline">찾기</button>
<span class="io-nav-gap"></span>
<span class="erp-muted">진행 중인 발주(종결·취소 제외)의 남은 수량</span>
</form>
<div class="io-kpis">
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 수량</div><div class="erp-summary-value">{{ n(total_remaining) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 제품</div><div class="erp-summary-value">{{ n(items|length) }}종</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 발주 줄</div><div class="erp-summary-value">{{ n(rows|length) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini{% if over %} io-kpi-over{% endif %}"><div class="erp-summary-label">초과 입고</div><div class="erp-summary-value">{{ n(over|length) }}건</div></div>
</div>
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>제품별 미입고 합계</h2><span class="erp-muted">여러 발주에 걸친 남은 수량을 제품마다 더한 값</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>제품 코드</th><th>제품</th><th class="io-num">미입고</th><th class="io-num">발주 건수</th><th>가장 이른 입고 예정일</th></tr></thead>
<tbody>
{% for it in items %}
<tr>
<td class="io-code">{{ it.item_code }}</td><td>{{ it.item_name }}</td>
<td class="io-num io-remaining">{{ n(it.remaining) }}</td><td class="io-num">{{ it.orders }}</td>
<td>{{ due(it.earliest_due, today, True) }}</td>
</tr>
{% else %}
<tr><td colspan="5" class="erp-empty">미입고된 제품이 없습니다. 모두 들어왔습니다.</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% if rows %}
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>발주별 미입고</h2><span class="erp-muted">입고 예정일이 이른 순 — 지난 것은 빨강</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>입고 예정일</th><th>발주번호</th><th>공장</th><th>제품 코드</th><th>제품</th>
<th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">미입고</th></tr></thead>
<tbody>
{% for r in rows %}
<tr class="io-row-link{% if r.due_date and r.due_date < today %} is-late{% endif %}" data-href="/inout/orders/{{ r.order_id }}">
<td>{{ due(r.due_date, today, True) }}</td>
<td><a href="/inout/orders/{{ r.order_id }}" class="io-order-no">{{ r.order_no }}</a><div class="erp-row-sub">발주 {{ ymd(r.order_date) }}</div></td>
<td>{{ r.factory_name }}</td><td class="io-code">{{ r.item_code }}</td><td>{{ r.item_name }}</td>
<td class="io-num">{{ n(r.qty) }}</td><td class="io-num">{{ n(r.received) }}</td>
<td class="io-num io-remaining">{{ n(r.remaining) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endif %}
{% if over %}
<div class="erp-card-block io-block io-block-over">
<div class="erp-card-block-head"><h2>초과 입고</h2><span class="erp-muted">발주보다 많이 들어온 제품 — 공장과 확인이 필요합니다</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>발주번호</th><th>공장</th><th>제품 코드</th><th>제품</th><th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">초과</th></tr></thead>
<tbody>
{% for r in over %}
<tr class="io-row-link" data-href="/inout/orders/{{ r.order_id }}">
<td><a href="/inout/orders/{{ r.order_id }}" class="io-order-no">{{ r.order_no }}</a></td><td>{{ r.factory_name }}</td>
<td class="io-code">{{ r.item_code }}</td><td>{{ r.item_name }}</td>
<td class="io-num">{{ n(r.qty) }}</td><td class="io-num">{{ n(r.received) }}</td><td class="io-num io-over">+{{ n(r.over) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endif %}
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261019c" defer></script>{% endblock %}
+9
View File
@@ -0,0 +1,9 @@
# [말레이시아재고] 말레이시아 창고 재고관리 — `app/modules/malaysia/`, `malaysia_stock_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 같은 폴더 `README.md`.
> 정적 파일: `app/static/malaysia.js`, `malaysia_rack.js`, `malaysia_rack_view.js`. 템플릿: `templates/`.
> 상품은 `itemcode_db` 읽기 전용(`itemcode.py`). 세트 BOM 이 "누락"이면 `itemcode_ro` 의 `set_components` SELECT 권한부터 점검.
- 낱개(MT/MX/MZ) 입출고·조정, 세트(MY) BOM, 일일 재고조사(세트 → 낱개 자동 분해), 현재고 현황.
- 뚜껑(MD-)은 재고 집계 제외 — 단, 창고 랙에는 위치 확인용으로 배치 가능(`store.LID_ITEMS`).
- 권한키 `malaysia`.
+11
View File
@@ -0,0 +1,11 @@
# [공지] 긴급 공지 모듈 — `app/modules/notice/`, `project_db`(마이그레이션 024 `urgent_notice*`)
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/NOTICE_MODULE.md`.
> 정적 파일: `app/static/erp-notice.js`, `erp-notice.css`, `erp-notice-admin.js`.
- 수퍼관리자만 작성(`/notice/`, 진입 = ERP 왼쪽 아래 · Project ⚙ 옵션).
- 제목·내용(이미지 bytea)·띄울 시각·전체/고른 사람.
- ERP 모든 화면(`erp_base.html`·`main.html`·`admin.html` 의 `static/erp-notice.js`) 가로·세로 정가운데에
[확인] 누를 때까지 표시(Esc·바깥 클릭 무시), 확인 기록.
- 연결 풀은 `ProjectStore.pool` 공유(→ Project 모듈 DB 변경 시 영향 확인), 새 환경변수 없음.
- PC 알림 프로그램은 아직 미지원.
@@ -2,7 +2,7 @@
{% block head_extra %}
{# 프로젝트 화면 부품(설명 편집기·날짜 팝업·멤버 고르기)을 그대로 쓴다 — project.js 는 PJ_LIB_ONLY 로 부품만 #}
<link rel="stylesheet" href="/static/project.css?v=20261013i" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<script>window.PJ_LIB_ONLY = true; window.PJ_HOLIDAYS = {{ (pj_kr_holidays or {}) | tojson }};</script>
{% endblock %}
@@ -64,7 +64,7 @@
</section>
</div>
<script>window.NTC_PEOPLE = {{ people | tojson }};</script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
<script src="/static/erp-notice-admin.js?v=20261012b" defer></script>
{% endif %}
{% endblock %}
+67
View File
@@ -0,0 +1,67 @@
# [실적] 실적 모듈 — `app/modules/performance/`, `performance_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/PERFORMANCE_MODULE.md`(큰 문서 — `grep -n '^#'` 로 목차 보고 필요한 절만 읽기).
> 정적 파일: `app/static/performance.css`, `performance.js`. 템플릿: `templates/`. 테스트: `tests/`.
> 다른 모듈과 연결: 카페24 어댑터는 `app/integrations/cafe24` 토큰 재사용 · Project 주간 회의록 머리 카드가 `performance_store` 매출을 읽기 전용으로 씀 · `APP_ENCRYPTION_KEY` 는 입출고(Gmail 토큰)와 공유.
## 구조 (네 영역 분리)
1. 수집 — `adapters/`(쇼핑몰 하나 = 어댑터 파일 하나 + `registry.py` 한 줄 + SQL seed 한 줄) + `sync.py`(공통 동기화, 같은 쇼핑몰 동시 실행 차단, 쇼핑몰별 실패 격리).
2. 보안 — `security/`(AES-256-GCM, 키 버전, 비밀값 가리기) + `credentials.py`.
3. 계산 — `calc.py`(주 = 월~일, 수수료 반올림은 `commission()` 한 곳, 요율 이력) + `db.py`.
4. 화면 — `dashboard.py`/`router.py`/템플릿.
## 규칙
- 쇼핑몰 API 인증정보는 `.env` 가 아니라 **설정 화면에서 입력 → 마스터 키 `APP_ENCRYPTION_KEY` 로 암호화해 DB 저장**, secret 원문은 화면으로 다시 보내지 않는다.
- 쇼핑몰 API 는 백엔드에서만 호출, 오류·로그·raw 는 `redact` 후 저장.
- 매출 기준일: 결제 = 결제일, 취소·반품 = 발생일(`sync.sales_date_for`). 금액은 원 단위 정수.
- 권한키 `performance`. 설정 화면은 모듈 권한자 누구나(일반 사용자는 수수료율만), 수수료 외 설정 API 는 `is_admin`.
- 1단계는 모의 데이터(`is_sample`)·구조까지, 실제 수집은 쇼핑몰별로 공식 문서 확인 후 순차 구현.
- 쇼핑몰 화면 수치와 맞출 때는 필드 추측 말고 붙여넣기 비교 + 원본 필드 합계로 진단부터.
## 카페24 적립금 · 네이버 배송비·환불 (2026-10-19 규칙 변경)
- **카페24** 매출 = 결제합계 − 적립금 사용, 환불 = 실제 + 예치금(적립금 환불 제외). raw `points`. 주문 내역 창 **적립금 사용** 칸·합계.
- **네이버** 매출 = 판매금액(총) + 배송비(raw `goods`·`ship` — 배송 묶음마다 `deliveryFeeAmount` 한 번, 할인 안 뺌 = 판매분석 배송비, 10/18 87,500 확인), 환불 = 클레임 완료일(`CLAIM_COMPLETED_DATETIME`) 조회의 취소·반품 완료 상품주문 −결제금액(`naver:{상품주문}-RF`, raw `refund`). 주문 내역 창 **판매금액**(배송비 뺀 raw `goods` — 저장 금액은 판매금액+배송비)·**배송비·환불금액** 칸·합계 + 맨 아래 "그날 매출 = 판매금액 + 배송비 − 환불".
- 예전 규칙으로 받은 날은 [과거 매출 가져오기]로 다시 받아야 바뀜(최근 10일은 자동). 사용자 확인값 10/18: 카페24 적립금 16,820 · 네이버 배송비 87,500 · 환불 66,100 — 배포 뒤 대조.
## 매출 업데이트
- 진행 창에서 쇼핑몰별 [중지](그 쇼핑몰만 멈추고 다음 쇼핑몰로).
- **업데이트 중에도 [매출 업데이트] 누르기 가능**(2026-10-19) — 버튼이 "업데이트 중 · 진행 보기"로 바뀌고, 누르면 `GET /api/sync/current` 의 진행 중 작업(수동·자동)을 새로 시작하지 않고 진행 창으로 다시 연다.
- 서버 시작 때 남은 `perf_sync_runs` running 행은 `abandon_running_runs` 로 "중단됨(서버 재시작)" 정리(앱은 프로세스 하나 — 진행 작업은 메모리에만). 예전엔 30분(`STALE_RUN_AFTER`) 동안 버튼이 '업데이트 중'으로 막히고 그 쇼핑몰이 '이미 진행 중'으로 건너뛰어졌다.
- **자동 업데이트**(`auto_sync.py`, 웹 프로세스 데몬 스레드) — 매일 09~19시 정각·30분마다 오늘 포함 최근 10일, 진행 창 작업으로 돌고 다른 업데이트 중이면 그 회차 건너뜀. env `PERFORMANCE_AUTO_SYNC`·`_DAYS`·`_HOURS`.
- 쿠팡은 판매자배송 발주서 + 로켓그로스 주문을 결제일로 합산(WING 판매분석 대조는 원본 데이터 확인으로).
## 수동 입력
- 설정의 쇼핑몰별 **수동 입력** 토글(마이그레이션 002 `manual_input`·`perf_manual_sales`) — 켜면 일자별 표 날짜 칸에 총매출 직접 입력, 넣은 날은 API 값 대신(`daily_amounts` 한 곳).
- 일자별 표 [엑셀 업로드] 팝업(`manual_upload.py`, `POST /performance/api/manual-sales/upload`) — 1열 날짜·2열부터 쇼핑몰 이름 머리글, 수동 입력 켜진 쇼핑몰 열의 값 있는 칸만 반영(덮어씀, 빈 칸 그대로), 잘못된 칸이 하나라도 있으면 전부 저장 안 함, 샘플 = 모듈 폴더 `upload_sample.xlsx`.
- 열 순서 카페24·네이버·쿠팡(윙)·쿠팡(로켓)·오늘의집·G마켓·카카오·GS샵·11번가·롯데ON·토스·애터미아자몰(마이그레이션 003).
- 쿠팡(로켓)·애터미아자몰은 **수동 입력 전용**(`adapters/manual.py`, `manual_only` — 매출 업데이트에서 빠지고 인증 설정·연결 테스트 없음, 수동 입력 늘 켜짐).
## 매출 실적 화면 (2026-10-19)
- KPI 는 **수수료 차감 매출 하나만** 화면 왼쪽 한 줄(`.perf-kpi-line` — 금액 + 비교 기간 대비 %, 모든 기간 공통). 총매출·수수료·월/연 누적 카드는 뺐다.
- 일자별 표 기본 보기 = **수수료 차감 매출**(라우터 기본 `metric=net`, 예전에 고른 보기 localStorage 는 안 씀).
- 마지막 업데이트 옆 **다음 업데이트까지 남은 시간** 초 단위 실시간(`router._auto_sync_ctx` → `performance.js initNextUpdate`, 자동 업데이트 규칙 `auto_sync.next_slot` 과 같게 화면이 다음 회차 계산, 서버 시각으로 PC 시계 보정, 자동 업데이트 꺼지면 숨김).
- 일자별 표 매출 칸 아래 **광고비(ROAS%)** 주황 줄(`--perf-ad`, `dashboard._ad_lines`) — 광고비 탭과 같은 값(`ad_spend.channel_roas`). 쇼핑몰 → 광고 채널은 `dashboard.sales_ad_channels`: 카페24 = 구글·메타 두 줄(이름 붙임), 네이버 = 네이버, 나머지는 `ROAS_SALES_CODE`(쿠팡 ← 쿠팡(윙)). 일 합계 = 보이는 쇼핑몰 광고비 합, ROAS = **일 합계 금액 ÷ 일 합계 광고비**(2026-10-19 — 예전엔 광고비 있는 쇼핑몰 매출만 더했다; `roas` 총매출·`roas_net` 수수료 차감 매출 기준, 보기 기준에 따라 하나만). 광고비 표 없으면 줄 없음.
- **매출 단위** 원·천원·백만원 — 설정 "보기 설정"(누구나, 이 브라우저 쿠키 `perf_unit`), 서버가 `amount_text`(천원 정수·백만원 소수 한 자리)로 그림(`router._unit_ctx` → 템플릿 `amt`). 광고비 탭은 원 그대로.
- 설정의 진단 카드(쇼핑몰 원본 데이터 확인·카페24 매출 대조·일별 한 번에 비교)는 2026-10-19 화면에서 뺐다(서버 API `marketplaces/{code}/reconcile`·`daily-check` 는 진단용으로 남김).
## 광고비 (`/performance/ads`)
- 탭은 [매출 실적]·[광고비] + 맨 오른쪽 설정 톱니.
- `ad_spend.py`, 마이그레이션 005 `perf_ad_spend`. 구글·메타·네이버·쿠팡(윙)·쿠팡(로켓)·오늘의집·G마켓·카카오·GS샵·11번가·롯데ON·토스·애터미아자몰 일 광고비를 연·월·일로.
- 칸 = "광고비(ROAS%)"(ROAS = 그 쇼핑몰 매출 ÷ 광고비). 구글·메타·네이버는 계산 안 함 — 광고 보고서 ROAS(마이그레이션 006 `roas`·`metrics`).
- 날짜 칸 직접 입력 + 쿠팡(윙)·쿠팡(로켓)·네이버 광고 보고서 업로드.
- 쿠팡: 1열 날짜·19열 청구금액(+부가가치세).
- 네이버: 3열 기간·4열 총비용·12열 ROAS(구매완료 광고수익률(%)), 머리글 클릭 = 일자별 보고서 항목.
총비용·광고수익률은 **머리글 이름으로 찾음**(열 구성 바뀐 보고서 — 고정 12열이 비어 ROAS 누락됐던 문제, 2026-10-20). 광고수익률 칸이 없거나 비면 구매완료 전환매출액 ÷ 총비용. 저장된 `roas` 가 빈 예전 행은 `db.ad_roas` 가 metrics 에서 다시 구함(`ad_spend.roas_from_metrics`).
- 일자별 보고서 창: ROAS 열은 **광고비 열 바로 오른쪽**, 네이버 "구매완료 광고수익률(%)" 머리글은 "ROAS(%)"로 표기(`ad_spend._roas_next_to_spend` → `labels`, 저장 키는 파일 머리글 그대로 — 예전 업로드도 그대로 적용).
- 매출 대비 광고비 KPI.
- 광고 API 연동(마이그레이션 007 `perf_ad_credentials`·`perf_ad_source_status`) — 실적 설정 **광고 API 연동** 카드, 쇼핑몰과 같은 마스터 키로 암호화(AAD `perf:ad:…`), `ad_sources/`(채널 하나 = 파일 하나) + `ad_sync.py`, 매출 자동 업데이트 회차에 함께. 결과는 `perf_ad_spend` `source='api'`(초록 숫자, API 가 안 준 날은 예전 API 값만 지움).
- **구글 = Google Ads API**(2026-10-15) — 고객 ID·(MCC)·서비스 계정 JSON·API 버전(기본 v26). 개발자 토큰은 2026-09-09 구글 폐지 — 접근 등급은 서비스 계정의 Cloud 프로젝트, 머리글 안 보냄. 광고비 탭 [구글 광고 불러오기](보는 기간). 광고비 = 비용 × 1.1(부가세 포함)·ROAS(전환 가치 ÷ 비용, 구글 값 그대로)·항목.
- **메타 = 메타 마케팅 API**(2026-10-16, `ad_sources/meta_ads.py`, 새 마이그레이션 없음) — 광고 계정 ID(여러 개, 날짜별 합산)·액세스 토큰(ads_read, 시스템 사용자 토큰 권장)·앱 시크릿(선택)·API 버전(기본 v26.0). 광고비 = 지출 금액 그대로(메타는 이미 부가세 포함 — × 1.1 은 구글만)·ROAS = 구매 전환값 ÷ 지출 금액(광고 관리자 구매 ROAS). USD 등 외화 계정은 그날 환율로 원화 환산(`fx.py`, Frankfurter 중앙은행 고시 환율 종합, 키 없음). 상세보기 [합계 | 계정별] 탭, [메타 광고 불러오기]·자동 업데이트 회차.
@@ -16,6 +16,12 @@ from typing import Any
from ..adapters.base import AdapterContext, CredentialField, NotConfigured
# AdDay.metrics 안의 계정별 값(여러 광고 계정을 합치는 채널 — 메타, 2026-10-16):
# {ACCOUNTS_KEY: {계정 ID: {"name", "amount", "roas", "metrics"}}} — 상세보기 [합계 | 계정…] 탭(ad_spend.detail_tabs).
# "_" 로 시작하는 metrics 키는 일자별 표 열·합계에 넣지 않는다(ad_spend.detail_table).
ACCOUNTS_KEY = "_accounts"
@dataclass
class AdDay:
"""광고 API 가 돌려준 하루치 — 금액은 원 단위 정수, ROAS 는 %(없으면 None), 나머지 항목은 화면 이름 그대로."""
@@ -0,0 +1,389 @@
"""메타 광고(Meta Marketing API — Insights) — 날짜별 광고비·ROAS·보고서 항목.
인증(2026-10-16 사용자: 토큰·광고 계정 ID 준비 완료)
- 액세스 토큰 하나(시스템 사용자 토큰 권장 — 만료 없음. 사용자 토큰은 약 60일 뒤 만료) + 광고 계정 ID 여러 개.
토큰에 ads_read 권한이 있어야 하고, 토큰 주인(시스템 사용자 등)이 각 광고 계정에 배정돼 있어야 한다.
- 메타 문서대로 토큰은 access_token 매개변수로 보낸다. 앱 설정에서 "앱 시크릿 필요"를 켰다면 앱 시크릿을 넣어
appsecret_proof(HMAC-SHA256)를 같이 보낸다. 토큰은 오류 문구에 넣지 않고(주소도 넣지 않음),
ad_sync 가 저장된 비밀값을 다시 한 번 가린다. httpx 요청 로그(INFO)는 주소에 토큰이 들어가므로 켜지 않는다.
조회(GET /{버전}/act_{계정}/insights)
level=account · time_increment=1(하루씩) · time_range={since, until} · fields=spend·노출·클릭·구매 전환 등.
- 날짜는 광고 계정 시간대 기준. 광고가 없던 날은 행이 없다. 여러 계정은 날짜별로 더한다.
- 원화가 아닌 계정(USD 등, 2026-10-16)은 지출 금액·구매 전환값을 그날 환율로 원화 환산(fx.krw_rates — Frankfurter 중앙은행 고시 환율 종합,
그날 값이 없으면 앞 가장 가까운 날). 계정 탭에 원래 통화 지출·적용 환율. ROAS 는 비율이라 환율과 무관.
- 기여(어트리뷰션)는 메타가 광고 관리자 설정을 그대로 따른다(2025-06 부터 API 의 기여 매개변수는 무시됨) — 화면 값과 같다.
- 구매 전환값·구매수 = action_values·actions 의 구매 항목 하나(omni_purchase → purchase → 픽셀 구매 순서로 처음 있는 것).
메타는 같은 구매를 여러 action_type 에 같은 값으로 겹쳐 주므로 더하지 않는다.
- 금액(광고비) = 지출 금액 그대로(원 반올림) — **메타 지출 금액은 이미 부가세 포함**(2026-10-16 사용자 확인).
부가세를 더하는(× 1.1) 것은 비용이 부가세 별도인 구글만이다.
- ROAS(%) = 구매 전환값 ÷ 지출 금액 × 100 — 광고 관리자 "구매 ROAS" 와 같은 값, 지출 0 이면 없음.
- 나머지 항목(노출수·클릭수·클릭률·링크 클릭·구매수·구매 전환값)은 광고비 탭 메타 머리글 → 일자별 표.
API 버전은 설정 칸(기본 DEFAULT_VERSION) — 메타는 버전을 약 2년 뒤 종료하므로 종료 안내가 오면 설정에서 올린다.
"""
from __future__ import annotations
import hashlib
import hmac
import json
import re
from datetime import date
from decimal import ROUND_HALF_UP, Decimal
from typing import Any
import httpx
from ..adapters.base import AdapterContext, AdapterError, ApiError, AuthFailed, CredentialField, NotConfigured, TokenExpired
from .. import fx
from .base import ACCOUNTS_KEY, AdDay, AdSource
API_BASE = "https://graph.facebook.com"
DEFAULT_VERSION = "v26.0" # 2026-07-29 출시(2026-10 기준 최신)
MAX_DAYS = 366
MAX_ACCOUNTS = 30
MAX_PAGES = 50 # 계정 하나 페이지 상한(하루 한 줄이라 366일도 몇 쪽)
PURCHASE_TYPES = ("omni_purchase", "purchase", "offsite_conversion.fb_pixel_purchase")
INSIGHT_FIELDS = "date_start,account_id,account_name,account_currency,spend,impressions,clicks,inline_link_clicks,actions,action_values"
# 일자별 표(광고비 탭 메타 머리글) 항목 — 순서 = 열 순서. 클릭률·ROAS 합계는 ad_spend.detail_table 이 이름으로 다시 계산.
M_SPEND = "지출 금액(부가세 포함)" # = 광고비(메타 지출 금액은 부가세 포함 — 구글처럼 따로 더하지 않음)
M_IMPR, M_CLICKS, M_CTR, M_LINK = "노출수", "클릭수", "클릭률(%)", "링크 클릭"
M_PURCHASES, M_VALUE, M_ROAS = "구매수", "구매 전환값", "ROAS(%)"
M_FX = "적용 환율(원)" # 외화 계정 탭에만 — 그날 1 계정 통화 = ? 원(fx.krw_rates)
# 메타 오류 코드 → 고칠 곳 안내(오류 문구 뒤에 붙임). 권한 오류는 연결 테스트가 원인을 진단한다(_diagnose) —
# 불러오기에서 난 오류엔 그 안내를 붙이고, 연결 테스트 자체에서는 진단 결과로 바꿔 쓴다.
_DIAG_HINT = "(실적 설정 → 광고 API 연동 → 메타 [연결 테스트]가 원인을 진단합니다)"
_HINTS = {
190: "토큰이 만료됐거나 무효입니다. 비즈니스 설정 → 시스템 사용자에서 토큰을 다시 만들어 [액세스 토큰]에 넣으세요(시스템 사용자 토큰은 만료 없음).",
102: "토큰을 읽을 수 없습니다. 토큰을 다시 복사해 넣으세요.",
200: "토큰에 권한이 없습니다. 토큰을 만들 때 ads_read 권한을 고르고, 토큰 주인(시스템 사용자)을 이 광고 계정에 배정했는지 확인하세요"
+ _DIAG_HINT + ".",
10: "토큰에 권한이 없습니다(ads_read). 앱·토큰 권한을 확인하세요.",
100: "요청 값이 올바르지 않습니다 — 광고 계정 ID 가 맞는지, 토큰 주인이 그 계정을 볼 수 있는지 확인하세요.",
803: "광고 계정 ID 를 찾을 수 없습니다(숫자만, act_ 는 있어도 됨).",
4: "메타 API 호출 한도에 걸렸습니다. 잠시 뒤 다시 누르세요.",
17: "메타 API 호출 한도에 걸렸습니다. 잠시 뒤 다시 누르세요.",
613: "메타 API 호출 한도에 걸렸습니다. 잠시 뒤 다시 누르세요.",
80000: "광고 계정 호출 한도에 걸렸습니다. 잠시 뒤 다시 누르세요.",
80004: "광고 계정 호출 한도에 걸렸습니다. 잠시 뒤 다시 누르세요.",
2635: "API 버전이 종료됐습니다 — 실적 설정에서 API 버전을 최신으로 바꾸세요.",
}
_RATE_LIMIT = {4, 17, 613, 80000, 80004}
_AUTH = {10, 102, 200}
_ACCOUNT_STATUS = {1: "운영 중", 2: "사용 중지", 3: "미결제", 7: "검토 대기", 8: "결제 대기", 9: "유예 기간", 100: "종료 대기", 101: "종료"}
def _http(ctx: AdapterContext) -> httpx.Client:
"""HTTP 클라이언트 — 테스트가 바꿔 끼운다."""
return httpx.Client(timeout=ctx.timeout_sec)
def parse_account_ids(raw: str) -> list[str]:
"""'act_123, 456\\n789' → ['123', '456', '789'](순서 유지·중복 제거). 형식이 틀리면 ValueError."""
out: list[str] = []
for part in re.split(r"[\s,;]+", raw or ""):
if not part:
continue
v = part[4:] if part.lower().startswith("act_") else part
if not re.fullmatch(r"\d{5,20}", v):
raise ValueError("광고 계정 ID 는 숫자여야 합니다(act_ 는 있어도 됨, 여러 개는 쉼표나 줄바꿈으로 구분).")
if v not in out:
out.append(v)
if len(out) > MAX_ACCOUNTS:
raise ValueError(f"광고 계정은 {MAX_ACCOUNTS}개까지 넣을 수 있습니다.")
return out
def _num(v: Any) -> Decimal:
"""메타 응답 숫자(문자열로 옴, 0 이면 빠지기도 함) → Decimal."""
if v is None or v == "":
return Decimal(0)
try:
return Decimal(str(v))
except ArithmeticError:
return Decimal(0)
def _won(v: Decimal) -> int:
return int(v.quantize(Decimal(1), rounding=ROUND_HALF_UP))
def _purchase(items: Any) -> Decimal:
"""actions / action_values 목록에서 구매 값 하나(PURCHASE_TYPES 순서로 처음 있는 것 — 겹친 값을 더하지 않는다)."""
by_type = {str((i or {}).get("action_type")): (i or {}).get("value") for i in (items or []) if isinstance(i, dict)}
for t in PURCHASE_TYPES:
if t in by_type:
return _num(by_type[t])
return Decimal(0)
def _meta_error(resp: httpx.Response) -> tuple[int, str]:
"""메타 오류 응답 {"error": {"message", "code", "error_subcode", ...}} → (코드, 문구)."""
try:
err = (resp.json() or {}).get("error") or {}
except ValueError:
return 0, f"HTTP {resp.status_code}"
if not isinstance(err, dict):
return 0, f"HTTP {resp.status_code}"
msg = str(err.get("error_user_msg") or err.get("message") or f"HTTP {resp.status_code}")
try:
code = int(err.get("code") or 0)
except (TypeError, ValueError):
code = 0
return code, msg
class MetaAdsSource(AdSource):
code = "meta"
name = "메타 광고"
docs_url = "https://developers.facebook.com/docs/marketing-api/insights"
note = ("메타 마케팅 API(Insights)로 광고 계정별 날짜별 지출 금액·구매 ROAS·노출수·클릭수·구매를 가져와 계정을 합칩니다. "
"준비: ① ads_read 권한이 있는 액세스 토큰(비즈니스 설정 → 시스템 사용자 토큰 권장 — 만료 없음) "
"② 토큰 주인을 각 광고 계정에 배정. 광고비 = 메타 지출 금액 그대로(이미 부가세 포함)입니다.")
def credential_fields(self) -> list[CredentialField]:
return [
CredentialField("account_ids", "광고 계정 ID", multiline=True, placeholder="act_1234567890\nact_9876543210",
help="광고비를 가져올 광고 계정 번호(광고 관리자 주소의 act= 뒤 숫자). 여러 개면 줄바꿈이나 쉼표로 — "
"날짜별로 합쳐서 메타 한 칸에 들어갑니다."),
CredentialField("access_token", "액세스 토큰", secret=True,
help="ads_read 권한이 있는 토큰. 저장 후에는 화면에 다시 보이지 않습니다."),
CredentialField("app_secret", "앱 시크릿", secret=True, required=False, placeholder="앱에서 '앱 시크릿 필요'를 켰을 때만",
help="메타 앱 설정 → 고급에서 'API 호출에 앱 시크릿 필요'를 켰다면 넣습니다(appsecret_proof). 아니면 비워 둡니다."),
CredentialField("api_version", "API 버전", required=False, placeholder=DEFAULT_VERSION,
help=f"비워 두면 {DEFAULT_VERSION}. 메타가 버전 종료를 알리면 새 버전(예: v27.0)으로 바꿉니다."),
]
def validate_credentials(self, values: dict[str, str]) -> list[str]:
errors = super().validate_credentials(values)
ids = (values.get("account_ids") or "").strip()
if ids and ids != "__stored__":
try:
parse_account_ids(ids)
except ValueError as exc:
errors.append(str(exc))
token = (values.get("access_token") or "").strip()
if token and token != "__stored__" and (len(token) < 20 or re.search(r"\s", token)):
errors.append("액세스 토큰 형식이 아닙니다(공백 없이 통째로 붙여 넣으세요).")
ver = (values.get("api_version") or "").strip()
if ver and ver != "__stored__" and not re.fullmatch(r"v\d{2,3}\.0", ver):
errors.append("API 버전은 v26.0 처럼 입력하세요.")
return errors
# ── 요청 ──────────────────────────────────────────────
def _setup(self, ctx: AdapterContext) -> tuple[list[str], str, dict[str, str]]:
self.require_configured(ctx)
try:
accounts = parse_account_ids(ctx.credentials.get("account_ids"))
except ValueError as exc:
raise NotConfigured(str(exc)) from None
if not accounts:
raise NotConfigured("광고 계정 ID 를 입력하세요.")
token = (ctx.credentials.get("access_token") or "").strip()
auth = {"access_token": token}
secret = (ctx.credentials.get("app_secret") or "").strip()
if secret:
auth["appsecret_proof"] = hmac.new(secret.encode(), token.encode(), hashlib.sha256).hexdigest()
version = (ctx.credentials.get("api_version") or "").strip() or DEFAULT_VERSION
return accounts, version, auth
def _get(self, ctx: AdapterContext, client: httpx.Client, url: str, params: dict[str, Any] | None) -> dict[str, Any]:
ctx.progress.check()
try:
resp = client.get(url, params=params)
except httpx.HTTPError as exc:
raise ApiError(f"메타 API 에 연결하지 못했습니다({type(exc).__name__}).") from None # 주소(토큰 포함)는 넣지 않는다
if resp.status_code != 200:
code, msg = _meta_error(resp)
hint = _HINTS.get(code, "")
text = f"메타 API 오류({code or resp.status_code}): {msg[:200]}" + (f" — {hint}" if hint else "")
if code == 190:
raise TokenExpired(text)
auth_problem = code in _AUTH or (resp.status_code in (401, 403) and code not in _RATE_LIMIT)
raise (AuthFailed if auth_problem else ApiError)(text)
try:
body = resp.json()
except ValueError:
raise ApiError("메타 API 응답을 읽을 수 없습니다.") from None
return body if isinstance(body, dict) else {}
# ── 권한 진단(연결 테스트가 권한 오류를 받았을 때) ─────────
def _diagnose(self, ctx: AdapterContext, client: httpx.Client, version: str, auth: dict[str, str],
accounts: list[str]) -> str:
"""토큰이 받은 권한·권한 대상 계정·볼 수 있는 광고 계정을 메타에 물어 원인을 짚는다(2026-10-16 #200 오류).
조회가 실패해도 예외를 내지 않는다(진단은 덧붙이는 정보). 토큰 값은 문구에 넣지 않는다."""
lines: list[str] = []
scopes: set[str] | None = None
ads_targets: set[str] | None = None # ads_read/ads_management 가 특정 계정에만 걸려 있으면 그 계정들
try: # ① 토큰 점검 — 앱 개발자 토큰·시스템 사용자 토큰이면 같은 토큰으로 된다
d = (self._get(ctx, client, f"{API_BASE}/{version}/debug_token",
{**auth, "input_token": auth["access_token"]}).get("data") or {})
scopes = {str(s) for s in d.get("scopes") or []}
for g in d.get("granular_scopes") or []:
if str((g or {}).get("scope")) in ("ads_read", "ads_management") and (g or {}).get("target_ids"):
ads_targets = (ads_targets or set()) | {str(t) for t in g["target_ids"]}
exp = int(d.get("expires_at") or 0)
expires = "만료 없음" if exp == 0 else date.fromtimestamp(exp).isoformat() + " 만료"
lines.append(f"토큰: 앱 {d.get('application') or d.get('app_id') or '?'}({d.get('app_id') or '?'}) · {expires}"
+ ("" if d.get("is_valid", True) else " · 무효"))
except AdapterError:
try: # ② 토큰 점검을 못 하면 받은 권한 목록만
rows = self._get(ctx, client, f"{API_BASE}/{version}/me/permissions", dict(auth)).get("data") or []
scopes = {str(r.get("permission")) for r in rows if r.get("status") == "granted"}
except AdapterError:
pass
if scopes is not None:
has = sorted(scopes & {"ads_read", "ads_management"})
lines.append("광고 권한: " + (", ".join(has) if has else "없음(ads_read·ads_management 둘 다 없음)"))
visible: set[str] | None = None
try: # ③ 이 토큰으로 볼 수 있는 광고 계정
rows = self._get(ctx, client, f"{API_BASE}/{version}/me/adaccounts",
{**auth, "fields": "account_id,name", "limit": 200}).get("data") or []
visible = {str(r.get("account_id") or "") for r in rows}
lines.append(f"이 토큰으로 보이는 광고 계정 {len(visible)}개")
except AdapterError:
pass
missing = [a for a in accounts if visible is not None and a not in visible]
not_target = [a for a in accounts if ads_targets is not None and a not in ads_targets]
# 결론 — 가장 앞선 원인 하나
if scopes is not None and not scopes & {"ads_read", "ads_management"}:
todo = ("토큰에 ads_read 권한이 없습니다 → 토큰을 새로 만들면서 ads_read 를 체크하세요"
"(비즈니스 설정 → 사용자 → 시스템 사용자 → 새 토큰 생성 → 권한에서 ads_read).")
elif missing:
todo = ("입력한 계정 중 이 토큰 주인에게 배정되지 않은 계정: " + ", ".join("act_" + a for a in missing)
+ " → 비즈니스 설정 → 사용자 → 시스템 사용자(토큰 주인) → [자산 할당] → 광고 계정에서 그 계정을 고르고 "
"'성과 보기'(또는 전체 권한)를 켠 뒤, 토큰을 새로 만들어 넣으세요(배정 전에 만든 토큰은 권한이 안 바뀔 수 있음).")
elif not_target:
todo = ("토큰의 ads_read 권한이 다른 계정에만 걸려 있습니다(대상 아님: " + ", ".join("act_" + a for a in not_target)
+ ") → 토큰을 새로 만들 때 이 광고 계정도 대상에 포함하세요.")
elif visible is not None:
todo = ("토큰 권한·계정 배정은 맞습니다 → 앱 쪽 문제일 가능성이 큽니다: 앱이 이 광고 계정을 가진 비즈니스에 연결돼 있는지"
"(비즈니스 설정 → 계정 → 앱), 앱 대시보드에 Marketing API 제품이 추가돼 있는지, 앱이 '제한 액세스'라면 토큰 주인이 앱의 "
"관리자·개발자 역할인지 확인하세요.")
else:
todo = "토큰 정보를 메타에서 읽지 못해 원인을 좁히지 못했습니다 — 토큰 권한(ads_read)과 광고 계정 배정을 확인하세요."
return "[진단] " + " · ".join(lines + [todo])
# ── 연결 테스트 · 가져오기 ─────────────────────────────
def test_connection(self, ctx: AdapterContext) -> str:
accounts, version, auth = self._setup(ctx)
parts: list[str] = []
not_krw = False
with _http(ctx) as client:
for acc in accounts:
try:
info = self._get(ctx, client, f"{API_BASE}/{version}/act_{acc}",
{**auth, "fields": "name,currency,timezone_name,account_status"})
except AuthFailed as exc: # 권한 오류(#200 등) — 메타에 토큰 정보를 물어 원인을 덧붙인다
# 진단(고칠 곳)을 맨 앞에, 메타 원문은 짧게 뒤에 — 길면 화면·기록에서 뒤가 잘리므로(2026-10-16 "[진…" 잘림)
original = str(exc).split(" — ")[0]
original = re.sub(r",?\s*refer to https?://\S+(?: for details)?", "", original)
raise AuthFailed(self._diagnose(ctx, client, version, auth, accounts)
+ f" (메타 원문: {original})") from None
cur = str(info.get("currency") or "?")
not_krw = not_krw or cur != "KRW"
status = _ACCOUNT_STATUS.get(info.get("account_status"), "")
parts.append(f"{info.get('name') or acc}({cur}·{info.get('timezone_name') or '?'}{'·' + status if status else ''})")
msg = f"연결됨 — 광고 계정 {len(accounts)}개: " + ", ".join(parts)
if not_krw:
msg += f" (원화가 아닌 계정은 날마다 그날 환율로 원화로 바꿔 넣습니다 — {fx.SOURCE_LABEL})"
return msg
def fetch_days(self, ctx: AdapterContext, start: date, end: date) -> list[AdDay]:
if end < start:
start, end = end, start
if (end - start).days + 1 > MAX_DAYS:
raise ApiError(f"한 번에 {MAX_DAYS}일까지 가져올 수 있습니다.")
accounts, version, auth = self._setup(ctx)
params = {**auth, "level": "account", "time_increment": 1, "limit": 100, "fields": INSIGHT_FIELDS,
"time_range": json.dumps({"since": start.isoformat(), "until": end.isoformat()})}
raw: list[tuple[str, date, str, dict[str, Any]]] = [] # (계정, 날짜, 통화, insights 한 줄)
names: dict[str, str] = {}
with _http(ctx) as client:
for acc in accounts:
url: str | None = f"{API_BASE}/{version}/act_{acc}/insights"
page_params: dict[str, Any] | None = params
for _ in range(MAX_PAGES):
body = self._get(ctx, client, url, page_params)
for r in body.get("data") or []:
try:
day = date.fromisoformat(str(r.get("date_start")))
except ValueError:
continue
if r.get("account_name"):
names[acc] = str(r["account_name"])[:100]
raw.append((acc, day, str(r.get("account_currency") or "KRW").upper(), r))
nxt = ((body.get("paging") or {}).get("next") or "").strip()
if not nxt:
break
if not nxt.startswith(API_BASE + "/"):
raise ApiError("메타 API 다음 쪽 주소가 올바르지 않습니다.")
url, page_params = nxt, None # next 주소에 매개변수(토큰 포함)가 다 들어 있다
else:
raise ApiError("메타 API 응답 쪽수가 너무 많습니다. 기간을 줄여 다시 시도하세요.")
# 원화가 아닌 계정(USD 등) — 그날 환율로 원화 환산(2026-10-16). 통화마다 기간 환율을 한 번에.
rates: dict[str, dict[date, Decimal]] = {}
for cur in sorted({c for _a, _d, c, _r in raw if c != "KRW"}):
if not re.fullmatch(r"[A-Z]{3}", cur):
raise ApiError(f"광고 계정 통화({cur[:10]})를 알 수 없습니다.")
try:
rates[cur] = fx.krw_rates(client, cur, start, end)
except fx.FxError as exc:
raise ApiError(f"{cur} 광고 계정을 원화로 바꿀 환율을 가져오지 못했습니다 — {exc}") from None
sums: dict[date, dict[str, Decimal]] = {} # 날짜 → 모든 계정 합(원화)
per_acc: dict[date, dict[str, dict[str, Any]]] = {} # 날짜 → 계정 → 그 계정 값(상세보기 계정별 탭)
for acc, day, cur, r in raw:
rate = Decimal(1) if cur == "KRW" else rates[cur][day]
one = per_acc.setdefault(day, {}).setdefault(acc, {**_zero(), "cur": cur, "rate": rate, "orig": Decimal(0)})
_add(one, r, rate)
one["orig"] += _num(r.get("spend")) # 그 계정 통화 그대로의 지출 금액
_add(sums.setdefault(day, _zero()), r, rate)
out: list[AdDay] = []
for day in sorted(sums):
amount, roas, metrics = _convert(sums[day])
# 계정별 값 — 화면 표 열이 아니라 상세보기 계정별 탭용(ad_spend.detail_tabs, "_" 로 시작하는 키는 표 열에서 빠짐).
# 계정마다 따로 반올림하므로 계정 광고비 합이 합계와 1원 다를 수 있다.
accounts_out: dict[str, Any] = {}
for acc, a in per_acc.get(day, {}).items():
a_amount, a_roas, a_metrics = _convert(a)
if a["cur"] != "KRW": # 외화 계정 — 원래 통화 지출과 적용 환율도 보여 준다(계정 탭)
a_metrics[f"지출 금액({a['cur']})"] = float(a["orig"].quantize(Decimal("0.01"), rounding=ROUND_HALF_UP))
a_metrics[M_FX] = float(a["rate"])
accounts_out[acc] = {"name": names.get(acc) or f"act_{acc}", "amount": a_amount,
"roas": float(a_roas) if a_roas is not None else None, "metrics": a_metrics}
metrics[ACCOUNTS_KEY] = accounts_out
out.append(AdDay(day=day, amount=amount, roas=roas, metrics=metrics))
return out
def _zero() -> dict[str, Decimal]:
return {k: Decimal(0) for k in ("spend", "impr", "clicks", "link", "purchases", "value")}
def _add(acc: dict[str, Any], r: dict[str, Any], rate: Decimal = Decimal(1)) -> None:
"""insights 한 줄(계정 하나·하루)을 더한다 — 금액(지출·구매 전환값)은 × rate(그날 1 계정 통화 = ? 원)로 원화."""
acc["spend"] += _num(r.get("spend")) * rate
acc["impr"] += _num(r.get("impressions"))
acc["clicks"] += _num(r.get("clicks"))
acc["link"] += _num(r.get("inline_link_clicks"))
acc["purchases"] += _purchase(r.get("actions"))
acc["value"] += _purchase(r.get("action_values")) * rate
def _convert(a: dict[str, Decimal]) -> tuple[int, Decimal | None, dict[str, Any]]:
"""더한 값 → (광고비 원, ROAS %, 일자별 표 항목). 광고비 = 지출 금액 그대로(메타 지출은 부가세 포함, 2026-10-16)."""
amount = _won(a["spend"])
roas = (a["value"] / a["spend"] * 100).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) if a["spend"] > 0 else None
ctr = (a["clicks"] / a["impr"] * 100).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP) if a["impr"] > 0 else None
return amount, roas, {
M_SPEND: amount,
M_IMPR: int(a["impr"]),
M_CLICKS: int(a["clicks"]),
M_CTR: float(ctr) if ctr is not None else None,
M_LINK: int(a["link"]),
M_PURCHASES: int(a["purchases"]),
M_VALUE: _won(a["value"]),
M_ROAS: float(roas) if roas is not None else None,
}
@@ -4,8 +4,9 @@ from __future__ import annotations
from .base import AdSource
from .google_ads import GoogleAdsSource
from .meta_ads import MetaAdsSource
_SOURCES: tuple[AdSource, ...] = (GoogleAdsSource(),)
_SOURCES: tuple[AdSource, ...] = (GoogleAdsSource(), MetaAdsSource())
_BY_CODE = {s.code: s for s in _SOURCES}
+115 -13
View File
@@ -27,6 +27,7 @@ from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
from typing import Any, Callable, Mapping, Sequence
from . import calc
from .ad_sources.base import ACCOUNTS_KEY
from .manual_upload import MAX_AMOUNT, MAX_DATA_ROWS, MAX_ERRORS, MAX_FILE_BYTES, UploadError, parse_amount, parse_date
# 채널 — 표 열 순서(2026-10-14 사용자 지정). 쇼핑몰 채널 코드는 실적 쇼핑몰 코드와 같다(쿠팡(윙)만 coupang_wing ↔ 매출 coupang).
@@ -227,11 +228,50 @@ def _json_num(num: Decimal | None) -> Any:
return int(num) if num == num.to_integral_value() else float(round(num, 2))
def _norm(name: Any) -> str:
return str(name or "").replace(" ", "")
# 네이버 보고서 ROAS = "구매완료 광고수익률(%)"(2026-10-20 사용자 확인). 그 칸이 없거나 비면
# 구매완료 전환매출액 ÷ 총비용 × 100 으로 계산한다(같은 정의 — 총 전환매출액은 정의가 달라 쓰지 않음).
NAVER_ROAS_KEY = "구매완료광고수익률"
NAVER_REVENUE_KEY = "구매완료전환매출액"
def roas_from_metrics(metrics: Mapping[str, Any] | None, amount: int | None) -> Decimal | None:
"""보고서 항목(머리글 → 값)에서 ROAS(%) — 광고수익률 칸, 없으면 전환매출액 ÷ 광고비. 못 구하면 None.
저장된 roas 가 빈 예전 업로드(열 위치가 달라 12열이 비었던 파일)도 이것으로 다시 구한다(db.ad_roas)."""
if not isinstance(metrics, Mapping):
return None
for key in (NAVER_ROAS_KEY, NAVER_REVENUE_KEY):
for k, v in metrics.items():
if key not in _norm(k) or isinstance(v, bool) or not isinstance(v, (int, float, Decimal)):
continue
if key == NAVER_ROAS_KEY:
return Decimal(str(v))
if amount and int(amount) > 0:
return (Decimal(str(v)) * 100 / int(amount)).quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
return None
def _naver_cols(header: tuple[str, ...]) -> tuple[int, int | None]:
"""머리글로 (총비용 열, ROAS 열) 찾기 — 네이버 보고서는 열 구성을 바꿀 수 있어 고정 위치(4열·12열)가 어긋난다.
머리글에 없으면 예전 고정 위치. ROAS 는 머리글은 있는데 광고수익률 칸이 없으면 None(전환매출액으로 계산)."""
names = [_norm(h) for h in header]
amount = next((i for i, n in enumerate(names) if n.startswith("총비용")), NAVER_AMOUNT_COL)
roas_col = next((i for i, n in enumerate(names) if NAVER_ROAS_KEY in n), None)
if roas_col is None and not any(names):
roas_col = NAVER_ROAS_COL
return amount, roas_col
def parse_naver(content: bytes, *, today: date, filename: str = "") -> ParseResult:
"""네이버 광고 보고서 → (날짜, 총비용) + 그날 ROAS(12열) + 나머지 항목. 잘못된 줄이 있으면 errors."""
"""네이버 광고 보고서 → (날짜, 총비용) + 그날 ROAS(구매완료 광고수익률) + 나머지 항목. 잘못된 줄이 있으면 errors.
총비용·ROAS 열은 머리글 이름으로 찾는다(없으면 4열·12열)."""
rows = read_rows(content, filename)
res = ParseResult()
header: tuple[Any, ...] = ()
amount_col, roas_col = NAVER_AMOUNT_COL, NAVER_ROAS_COL
seen: dict[date, int] = {}
for r, row in enumerate(rows, start=1):
raw_day = row[NAVER_DATE_COL] if len(row) > NAVER_DATE_COL else None
@@ -244,6 +284,7 @@ def parse_naver(content: bytes, *, today: date, filename: str = "") -> ParseResu
except ValueError:
if not header: # 머리글(1행 "기간")
header = tuple(str(h or "").strip() for h in row)
amount_col, roas_col = _naver_cols(header)
res.columns = [h for i, h in enumerate(header) if i not in NAVER_SKIP_COLS and h]
res.skipped += 1
continue
@@ -253,17 +294,17 @@ def parse_naver(content: bytes, *, today: date, filename: str = "") -> ParseResu
res.skipped += 1
continue
try:
amt = parse_amount(row[NAVER_AMOUNT_COL] if len(row) > NAVER_AMOUNT_COL else None)
amt = parse_amount(row[amount_col] if len(row) > amount_col else None)
except ValueError:
res.errors.append(f"{r}행 4열: 총비용이 숫자가 아닙니다.")
res.errors.append(f"{r}행 {amount_col + 1}열: 총비용이 숫자가 아닙니다.")
continue
try:
ro = _number(row[NAVER_ROAS_COL] if len(row) > NAVER_ROAS_COL else None)
ro = _number(row[roas_col] if roas_col is not None and len(row) > roas_col else None)
except ValueError:
res.errors.append(f"{r}행 12열: 광고수익률(ROAS)이 숫자가 아닙니다.")
res.errors.append(f"{r}행 {(roas_col or 0) + 1}열: 광고수익률(ROAS)이 숫자가 아닙니다.")
continue
if amt is None:
res.errors.append(f"{r}행 4열: {day.isoformat()} 총비용이 비어 있습니다.")
res.errors.append(f"{r}행 {amount_col + 1}열: {day.isoformat()} 총비용이 비어 있습니다.")
elif abs(amt) > MAX_AMOUNT or (ro is not None and abs(ro) > Decimal("10000000")):
res.errors.append(f"{r}행: 금액·ROAS 가 너무 큽니다.")
elif day > today:
@@ -273,8 +314,6 @@ def parse_naver(content: bytes, *, today: date, filename: str = "") -> ParseResu
else:
seen[day] = r
res.entries.append((day, amt))
if ro is not None:
res.roas[day] = ro
m: dict[str, Any] = {}
for i, v in enumerate(row):
name = header[i] if i < len(header) else f"{i + 1}열"
@@ -285,6 +324,10 @@ def parse_naver(content: bytes, *, today: date, filename: str = "") -> ParseResu
except ValueError:
m[name] = str(v)[:100]
res.metrics[day] = m
if ro is None:
ro = roas_from_metrics(m, amt) # 광고수익률 칸이 없거나 빈 파일 — 전환매출액 ÷ 총비용
if ro is not None:
res.roas[day] = ro
if len(res.entries) > MAX_DATA_ROWS:
raise UploadError(f"한 번에 {MAX_DATA_ROWS:,}일까지 올릴 수 있습니다.")
if len(res.errors) > MAX_ERRORS:
@@ -341,8 +384,8 @@ def merge_results(parsed: list[tuple[str, float, ParseResult]]) -> tuple[ParseRe
return merged, sorted(overlap)
# 머리글을 누르면 일자별 상세 표가 열리는 채널(보고서 항목을 보관하는 채널) — 구글은 광고 API 로 가져온 항목(2026-10-15)
DETAIL_CHANNELS = frozenset({"naver", "google"})
# 머리글을 누르면 일자별 상세 표가 열리는 채널(보고서 항목을 보관하는 채널) — 구글(2026-10-15)·메타(2026-10-16)는 광고 API 로 가져온 항목
DETAIL_CHANNELS = frozenset({"naver", "google", "meta"})
def detail_table(rows: list[dict[str, Any]]) -> dict[str, Any]:
@@ -351,11 +394,13 @@ def detail_table(rows: list[dict[str, Any]]) -> dict[str, Any]:
cols: list[str] = []
for r in rows:
for k in (r.get("metrics") or {}):
if k not in cols:
if k not in cols and not k.startswith("_"): # "_" 키 = 표 열이 아닌 내부 값(계정별 등)
cols.append(k)
sums: dict[str, Decimal] = {}
for r in rows:
for k, v in (r.get("metrics") or {}).items():
if k.startswith("_"):
continue
if isinstance(v, (int, float)) and not isinstance(v, bool):
sums[k] = sums.get(k, Decimal(0)) + Decimal(str(v))
total: dict[str, Any] = {k: _json_num(v) for k, v in sums.items()}
@@ -367,10 +412,67 @@ def detail_table(rows: list[dict[str, Any]]) -> dict[str, Any]:
rev = sum(Decimal(str(r["roas"])) * int(r.get("amount") or 0) for r in rows
if r.get("roas") is not None and int(r.get("amount") or 0) > 0)
total[k] = float(round(rev / spend, 2)) if spend else None
elif "환율" in k: # 외화 광고 계정 적용 환율(메타 USD 계정, 2026-10-16) — 더하지 않고 광고비 가중 평균
pairs = [(Decimal(str((r.get("metrics") or {})[k])), int(r.get("amount") or 0)) for r in rows
if isinstance((r.get("metrics") or {}).get(k), (int, float)) and int(r.get("amount") or 0) > 0]
weight = sum(w for _v, w in pairs)
total[k] = float(round(sum(v * w for v, w in pairs) / weight, 2)) if weight else None
out_rows = [{"date": r["date"], "amount": int(r.get("amount") or 0),
"roas": float(r["roas"]) if r.get("roas") is not None else None,
"values": r.get("metrics") or {}} for r in rows]
return {"columns": cols, "rows": out_rows, "total": total}
"values": {k: v for k, v in (r.get("metrics") or {}).items() if not k.startswith("_")}} for r in rows]
cols, labels = _roas_next_to_spend(cols)
return {"columns": cols, "labels": labels, "rows": out_rows, "total": total}
# 상세 표의 광고비 열 — 네이버 "총비용"(4열), 구글 "광고비(부가세 포함)", 메타 "지출 금액(부가세 포함)"
_SPEND_COL_MARKS = ("총비용", "광고비(", "지출 금액(부가세")
def _roas_next_to_spend(cols: list[str]) -> tuple[list[str], dict[str, str]]:
"""ROAS 열을 광고비 열 바로 오른쪽으로 옮긴다(2026-10-20 사용자 요청 — 네이버 파일은 12열이라 멀리 떨어져 있었다).
네이버 "구매완료 광고수익률(%)" 은 머리글을 "ROAS(%)" 로 보여 준다(값·키는 파일 머리글 그대로, labels 로만).
반환: (열 순서, {열: 화면 머리글})."""
roas_col = next((k for k in cols if "수익률" in k or "ROAS" in k.upper()), None)
spend_col = next((k for k in cols if any(m in k for m in _SPEND_COL_MARKS)), None)
labels: dict[str, str] = {}
if roas_col is None:
return cols, labels
if "ROAS" not in roas_col.upper():
labels[roas_col] = "ROAS(%)"
if spend_col is None:
return cols, labels
out = [k for k in cols if k != roas_col]
out.insert(out.index(spend_col) + 1, roas_col)
return out, labels
def detail_tabs(rows: list[dict[str, Any]]) -> dict[str, Any]:
"""상세보기 탭 — 계정별 값(ACCOUNTS_KEY)이 있는 채널(메타, 2026-10-16)은 [합계 | 계정…], 없으면 탭 없음.
계정 탭 = 그 계정이 광고를 낸 날만(그날 행의 계정 값으로 detail_table). 계정 이름은 가장 최근 날의 이름,
순서는 기간 광고비가 큰 계정부터(같으면 이름). accounts_missing = 광고비가 있는데 계정별 값이 없는 날 수
(계정별 저장 전에 가져온 날 — 다시 불러오면 생긴다)."""
per: dict[str, list[dict[str, Any]]] = {}
names: dict[str, str] = {}
missing = 0
for r in rows:
accs = (r.get("metrics") or {}).get(ACCOUNTS_KEY)
if not isinstance(accs, dict):
if int(r.get("amount") or 0):
missing += 1
continue
for acc, a in accs.items():
if not isinstance(a, dict):
continue
names[acc] = str(a.get("name") or f"act_{acc}")
per.setdefault(acc, []).append({"date": r["date"], "amount": int(a.get("amount") or 0),
"roas": a.get("roas"), "metrics": a.get("metrics") or {}})
if not per:
return {"tabs": [], "accounts_missing": 0}
spend = {acc: sum(x["amount"] for x in days) for acc, days in per.items()}
order = sorted(per, key=lambda acc: (-spend[acc], names[acc]))
tabs = [{"key": "total", "label": "합계", **detail_table(rows)}]
tabs += [{"key": acc, "label": names[acc], "account_id": acc, **detail_table(per[acc])} for acc in order]
return {"tabs": tabs, "accounts_missing": missing}
# ════════════════════════════════════════════════════════════
+3 -1
View File
@@ -22,6 +22,7 @@ from .security.redact import redact_text
logger = logging.getLogger("performance.ad_sync")
AD_NS = "ad:" # 광고 인증정보 암호문 이름 공간(credentials.aad_for)
AD_MESSAGE_MAX = 1200 # 광고 연동 오류 문구 길이 한도(비밀값 가린 뒤)
_locks: dict[str, threading.Lock] = {}
_locks_guard = threading.Lock()
@@ -57,7 +58,8 @@ class AdSyncService:
@staticmethod
def _message(exc: Exception, ctx: AdapterContext) -> str:
known = getattr(ctx.credentials, "known_secrets", lambda: [])()
return redact_text(str(getattr(exc, "message", "") or exc), known)
# 광고 연동 오류는 고칠 곳 안내·진단이 붙어 길다 — 기본 300자에서 자르면 안내가 잘린다(2026-10-16 메타 #200 진단)
return redact_text(str(getattr(exc, "message", "") or exc), known, max_len=AD_MESSAGE_MAX)
def test_connection(self, code: str, *, values: dict[str, str] | None = None, user: str = "",
cleared: set[str] | None = None) -> dict[str, Any]:
+10 -5
View File
@@ -488,23 +488,27 @@ class Cafe24Adapter(MarketplaceAdapter):
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,
# 적립금 사용분은 매출에서 뺀다(2026-10-19 사용자 요청) — 결제합계 − 적립금(points_spent_amount)
amount=max(0, order_total(order) - order_amounts(order)["points_spent_amount"]), 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()}},
"items": len(items), **{f"initial_{k}": v for k, v in order_amounts(order).items()},
"points": order_amounts(order)["points_spent_amount"], "points_excluded": True},
)]
def normalize_refund(self, refund: dict[str, Any]) -> list[SaleEvent]:
"""환불 → CANCEL/RETURN(−). 원 주문의 market_id 로 결제와 같은 쇼핑몰 열에 넣는다.
금액 = 실제 환불액 + 적립금·예치금 환불(카페24 일별 매출 환불합계와 같음, 실데이터 확인)."""
금액 = 실제 환불액 + 예치금 환불 — 적립금으로 돌려준 금액은 뺀다(2026-10-19, 결제에서 적립금을 빼므로 앞뒤를 맞춤.
예전 = 카페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)
points = _won(refund.get("used_points"))
amount = refund_total(refund) - points
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",
@@ -515,7 +519,8 @@ class Cafe24Adapter(MarketplaceAdapter):
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")},
"quantity": refund.get("quantity"), "order_item_code": refund.get("order_item_code"),
"points": -points, "points_excluded": True},
)]
def normalize_claim(self, c: dict[str, Any]) -> list[SaleEvent]:
+103 -12
View File
@@ -13,9 +13,12 @@
?from=…&to=…&rangeType=PAYED_DATETIME&pageSize=&page= — 결제일 기준, 한 번에 24시간까지(하루씩 부른다),
from 부터 180일 안의 주문만. 응답에 주문·상품주문 상세가 바로 들어 있다(네이버 안내: 소량·조회용 권장 API).
- SALE = 주문 하나(`naver:{orderId}`), 날짜 = 결제일(order.paymentDate).
금액 = 상품주문들의 결제금액(productOrder.totalPaymentAmount) 합 — 배송비 제외.
금액 = 상품주문들의 결제금액(productOrder.totalPaymentAmount) 합 **+ 배송비**(배송 묶음마다 deliveryFeeAmount 한 번, 할인 안 뺌 =
판매분석 '배송비', 2026-10-19 사용자 요청·10/18 실데이터 87,500 확인 — 예전엔 배송비 제외). raw = {goods: 상품 결제금액, ship: 배송비}.
- 결제 뒤 취소·반품된 상품주문도 결제일 매출에 그대로 둔다(판매금액(총)). 입금대기·미입금 취소만 뺀다.
그래서 지난 날짜 매출이 나중에 줄지 않는다. 환불(판매금액(순))은 아직 따로 만들지 않는다.
- **환불 = 환불된 날(클레임 완료일)에 뺀다**(2026-10-19): 같은 조회를 rangeType=CLAIM_COMPLETED_DATETIME 으로 하루씩 —
그날 취소·반품 완료(CANCELED·RETURNED)된 상품주문마다 CANCEL/RETURN(`naver:{productOrderId}-RF`), 금액 = −totalPaymentAmount.
판매분석의 환불금액처럼 결제일이 아니라 환불일 매출에서 빠진다.
- 구매자 이름·연락처·주소는 저장하지 않는다.
"""
@@ -173,7 +176,9 @@ def field_summary(records: list[dict[str, str]]) -> list[dict[str, Any]]:
def group_orders(items: Iterable[dict[str, Any]], start: date, end: date) -> dict[str, dict[str, Any]]:
"""상품주문 → 주문 하나로 합침(결제일이 [start, end] 이고 결제된 것 — 나중에 취소·반품된 것도 포함).
금액 = totalPaymentAmount 합(할인 뒤 상품 결제금액, 배송비 제외) = 판매분석 "판매금액(총)".
배송비·취소/반품분은 참고용(ship·claimed)으로만 모은다."""
배송비(ship) = **배송 묶음(packageNumber, 없으면 주문)마다 deliveryFeeAmount 한 번**(묶음 안 최댓값), 배송비 할인은 빼지 않음 —
네이버는 배송비·할인을 상품주문마다 반복해 적는다. 10/18 실데이터: 묶음당 한 번 = 87,500 = 판매분석 배송비
(상품주문마다 배송비 − 할인 = 38,500 은 틀림, 2026-10-19 ship_check 로 확인). 취소/반품분은 참고용(claimed)."""
orders: dict[str, dict[str, Any]] = {}
for c in items:
po, od = c.get("productOrder") or {}, c.get("order") or {}
@@ -183,13 +188,15 @@ def group_orders(items: Iterable[dict[str, Any]], start: date, end: date) -> dic
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": [],
"discount": 0, "names": [], "opt": "", "statuses": [], "_ship_pkg": {},
"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"))
pkg = str(po.get("packageNumber") or oid)
o["_ship_pkg"][pkg] = max(o["_ship_pkg"].get(pkg, 0), _won(po.get("deliveryFeeAmount")))
o["ship"] = sum(o["_ship_pkg"].values())
o["qty"] += _won(po.get("quantity"))
o["discount"] += _won(po.get("productDiscountAmount"))
name = str(po.get("productName") or "")
@@ -201,6 +208,61 @@ def group_orders(items: Iterable[dict[str, Any]], start: date, end: date) -> dic
return orders
def ship_check(items: Iterable[dict[str, Any]], start: date, end: date) -> dict[str, Any]:
"""배송비 계산 후보 비교(진단, 2026-10-19) — 네이버는 배송비·배송비 할인을 상품주문마다 적어 같은 주문·배송 묶음 안에서
반복될 수 있다. 판매분석 '배송비'와 맞는 셈을 실데이터로 고르려고 후보 합계 + 주문별 상품주문 값(개인정보 없음)을 돌려준다."""
rows = []
for c in items:
po, od = c.get("productOrder") or {}, c.get("order") or {}
day = _day(od.get("paymentDate") or po.get("paymentDate"))
status = str(po.get("productOrderStatus") or "")
if day is None or not (start <= day <= end) or status in EXCLUDED_STATUS:
continue
rows.append({"order": str(od.get("orderId") or po.get("orderId") or ""), "package": str(po.get("packageNumber") or ""),
"status": status, "fee": _won(po.get("deliveryFeeAmount")), "discount": _won(po.get("deliveryDiscountAmount")),
"section": _won(po.get("sectionDeliveryFee")), "policy": str(po.get("deliveryPolicyType") or ""),
"pay": _won(po.get("totalPaymentAmount")), "qty": _won(po.get("quantity"))})
def per(key: str) -> dict[str, int]:
groups: dict[str, list[dict[str, Any]]] = {}
for r in rows:
groups.setdefault(r[key] or r["order"], []).append(r)
return {"groups": len(groups),
"max_fee": sum(max(x["fee"] for x in g) for g in groups.values()),
"max_fee_minus_max_discount": sum(max(0, max(x["fee"] for x in g) - max(x["discount"] for x in g)) for g in groups.values()),
"sum_fee_minus_sum_discount": sum(max(0, sum(x["fee"] - x["discount"] for x in g)) for g in groups.values()),
"with_fee": sum(1 for g in groups.values() if max(x["fee"] for x in g) > 0)}
orders: dict[str, list[dict[str, Any]]] = {}
for r in rows:
orders.setdefault(r["order"], []).append({k: r[k] for k in ("package", "status", "fee", "discount", "section", "policy", "pay", "qty")})
return {
"product_orders": len(rows),
"per_product_order": {"fee": sum(r["fee"] for r in rows), "discount": sum(r["discount"] for r in rows),
"fee_minus_discount": sum(r["fee"] - r["discount"] for r in rows),
"section": sum(r["section"] for r in rows)},
"per_order": per("order"), "per_package": per("package"),
"orders": [{"order": k, "lines": v} for k, v in sorted(orders.items())],
"note": "판매분석 '배송비'와 같은 값의 후보 — 지금 매출 규칙은 per_package.max_fee(묶음마다 배송비 한 번, 할인 안 뺌)",
}
def refund_items(items: Iterable[dict[str, Any]], day: date) -> list[dict[str, Any]]:
"""클레임 완료일 조회 결과 → 환불 줄(상품주문 하나 = 한 줄). 취소·반품 완료만, 금액 = 그 상품주문 결제금액."""
out = []
for c in items:
po, od = c.get("productOrder") or {}, c.get("order") or {}
status = str(po.get("productOrderStatus") or "")
if status not in CLAIMED_STATUS:
continue
out.append({"product_order_id": str(po.get("productOrderId") or c.get("productOrderId") or ""),
"order_id": str(od.get("orderId") or po.get("orderId") or ""), "day": day, "status": status,
"amount": _won(po.get("totalPaymentAmount")), "qty": _won(po.get("quantity")),
"name": str(po.get("productName") or ""), "opt": str(po.get("productOption") or ""),
"order_day": _day(od.get("orderDate")), "pay_day": _day(od.get("paymentDate") or po.get("paymentDate"))})
return out
# 토큰을 발급한 인증정보 — 이 값들이 바뀌면 저장된 토큰을 쓰지 않고 새로 받는다(credential_fingerprint)
TOKEN_KEYS = ("client_id", "client_secret", "account_id")
@@ -335,11 +397,12 @@ class NaverAdapter(MarketplaceAdapter):
return body
raise ApiError("네이버 API 호출 제한(429)이 계속됩니다. 잠시 뒤 다시 시도하세요.")
def _day_items(self, ctx: AdapterContext, d: date) -> list[dict[str, Any]]:
"""결제일이 d(한국 시간 0시~23:59:59.999)인 상품주문 전체 — 모든 상태."""
def _day_items(self, ctx: AdapterContext, d: date, range_type: str = "PAYED_DATETIME") -> list[dict[str, Any]]:
"""기준일(range_type — 결제일 PAYED_DATETIME · 클레임 완료일 CLAIM_COMPLETED_DATETIME)이 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,
"rangeType": range_type, "pageSize": PAGE_SIZE,
}
out: list[dict[str, Any]] = []
for page in range(1, MAX_PAGES + 1):
@@ -352,8 +415,9 @@ class NaverAdapter(MarketplaceAdapter):
raise ApiError(f"네이버 {d.isoformat()} 주문이 {MAX_PAGES}쪽을 넘어 끝까지 받지 못했습니다 — 저장하지 않았습니다.")
return out
def _items(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
ctx.progress.plan((end - start).days + 1, "일") # 진행 막대: 하루 = 한 단계
def _items(self, ctx: AdapterContext, start: date, end: date, *, plan: tuple[int, str] | None = None) -> Iterable[dict[str, Any]]:
days = (end - start).days + 1
ctx.progress.plan(*(plan or (days, "일"))) # 진행 막대: 하루 = 한 단계(매출 업데이트는 결제 + 환불 조회 = 하루 두 단계)
d = start
while d <= end:
rows = self._day_items(ctx, d)
@@ -363,7 +427,30 @@ class NaverAdapter(MarketplaceAdapter):
# ── 수집 ──────────────────────────────────────────────
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()
days = (end - start).days + 1
yield from group_orders(self._items(ctx, start, end, plan=(days * 2, "일 조회")), start, end).values()
def fetch_refunds(self, ctx: AdapterContext, start: date, end: date) -> Iterable[dict[str, Any]]:
"""환불 — 클레임 완료일이 그날인 상품주문 중 취소·반품 완료(CANCELED·RETURNED)된 것(2026-10-19). 교환·미입금 취소는 아님."""
d = start
while d <= end:
rows = self._day_items(ctx, d, "CLAIM_COMPLETED_DATETIME")
ctx.progress.step(items=len(rows))
yield from refund_items(rows, d)
d += timedelta(days=1)
def normalize_refund(self, r: dict[str, Any]) -> list[SaleEvent]:
if not r.get("amount") or not r.get("product_order_id"):
return []
is_return = r.get("status") == "RETURNED"
return [SaleEvent(
event_type="RETURN" if is_return else "CANCEL", external_event_id=f"{EVENT_PREFIX}{r['product_order_id']}-RF",
external_order_id=str(r.get("order_id") or r["product_order_id"]), external_line_id=str(r["product_order_id"]),
order_date=r.get("order_day"), payment_date=r.get("pay_day"), event_date=r["day"], amount=-int(r["amount"]),
product_name=str(r.get("name") or "")[:200], option_name=str(r.get("opt") or "")[:200],
quantity=-int(r.get("qty") or 0), order_status="반품완료" if is_return else "취소완료",
raw={"product_order_id": r["product_order_id"], "status": r.get("status"), "refund": int(r["amount"])},
)]
def normalize_order(self, o: dict[str, Any]) -> list[SaleEvent]:
oid, day = str(o.get("orderId") or ""), o.get("_day")
@@ -372,9 +459,12 @@ class NaverAdapter(MarketplaceAdapter):
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 []]
goods, ship = max(0, int(o.get("amount") or 0)), max(0, int(o.get("ship") or 0))
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)),
# 판매금액(총) + 배송비(2026-10-19) — 환불은 환불일에 따로(fetch_refunds)
order_date=o.get("order_day"), payment_date=day, event_date=day, amount=goods + ship,
raw={"goods": goods, "ship": ship},
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],
)]
@@ -420,5 +510,6 @@ class NaverAdapter(MarketplaceAdapter):
"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,
"ship_check": ship_check(items, day, to),
"rule": "결제일 기준 상품주문 totalPaymentAmount 합(할인 뒤, 배송비 제외, 결제 뒤 취소·반품분 포함, "
"미입금 제외) = 판매분석 '판매금액(총)'. 취소·반품분·배송비는 참고"}
+7
View File
@@ -122,6 +122,13 @@ def start_auto_sync_thread(app_state: Any) -> bool:
"""웹 프로세스 시작 시 1번. 저장소가 없거나 꺼져 있거나 이미 돌고 있으면 False."""
global _started # noqa: PLW0603
store = getattr(app_state, "performance_store", None)
if store is not None and not _started:
try: # 지난 프로세스가 업데이트 도중 끝나 남은 '진행 중' 기록 정리(자동 업데이트를 꺼 둬도)
n = store.abandon_running_runs()
if n:
logger.warning("매출 업데이트 '진행 중' 기록 %d건 정리(서버 재시작으로 중단)", n)
except Exception: # noqa: BLE001 — DB 가 아직 안 붙었어도 앱은 뜬다
logger.exception("매출 업데이트 진행 기록 정리 실패")
if store is None or not enabled():
return False
with _start_lock:
+93 -16
View File
@@ -6,7 +6,7 @@ HTTP 와 무관하다(store 만 주입). 라우터는 파라미터 파싱·권
from __future__ import annotations
from datetime import date, timedelta
from decimal import Decimal
from decimal import ROUND_HALF_UP, Decimal
from typing import Any, Mapping, Sequence
from . import calc
@@ -32,6 +32,93 @@ def display_status(marketplace: Mapping[str, Any], status_row: Mapping[str, Any]
return (status_row or {}).get("status") or "unknown"
# 매출 단위(2026-10-19, 실적 설정 "보기 설정" — 이 브라우저 쿠키 perf_unit) — (나누는 수, 소수 자리, 단위 이름)
UNITS: dict[str, tuple[int, int, str]] = {"won": (1, 0, "원"), "thousand": (1000, 0, "천원"), "million": (1_000_000, 1, "백만원")}
UNIT_COOKIE = "perf_unit"
def normalize_unit(value: Any) -> str:
return value if value in UNITS else "won"
def amount_text(value: Any, unit: str = "won") -> str:
"""금액 → 화면 글자(쉼표). 천원은 정수, 백만원은 소수 한 자리(반올림)."""
div, places, _ = UNITS[normalize_unit(unit)]
if div == 1:
return f"{int(value):,}"
q = (Decimal(int(value)) / div).quantize(Decimal(1).scaleb(-places), rounding=ROUND_HALF_UP)
return f"{q:,.{places}f}"
def _ad_lines(store: Any, table: list[dict[str, Any]], codes: Sequence[str], cells: Mapping[Any, Any],
period: Any, q_start: date, q_end: date) -> None:
"""매출 칸 아래 광고비(ROAS%) — 광고비 화면과 같은 값(ROAS = 그 쇼핑몰 매출 ÷ 광고비, 구글·메타·네이버는 보고서 ROAS).
카페24 = 구글·메타 두 줄. 행마다 r["ads"][쇼핑몰] = [{label, amount, roas}], r["ads_total"] = 보이는 쇼핑몰 광고비 합.
일 합계 ROAS 는 단순하게 일 합계 금액 ÷ 일 합계 광고비(2026-10-19) — roas = 총매출 기준, roas_net = 수수료 차감 매출 기준
(화면 표시 기준에 따라 하나만 보인다). 예전엔 광고비가 있는 쇼핑몰 매출만 더해 일 합계 금액과 맞지 않았다.
광고비 표(005)가 없거나 읽기 실패면 줄 없음."""
from . import ad_spend # noqa: WPS433
by_code = sales_ad_channels()
want = {ch for c in codes for ch, _ in by_code.get(c, ())}
for r in table:
r["ads"], r["ads_total"] = {}, None
if not want:
return
try:
amounts, _ = store.ad_amounts(q_start, q_end)
reader = getattr(store, "ad_roas", None)
roas_map = reader(q_start, q_end) if reader else {}
except Exception: # noqa: BLE001 — 광고비 표가 없어도 매출 화면은 그대로
return
spend_by: dict[str, list[tuple[date, int]]] = {}
for (d, ch), v in amounts.items():
if ch in want and v:
spend_by.setdefault(ch, []).append((d, int(v)))
sales_by: dict[str, list[tuple[date, int]]] = {}
for (d, c), m in cells.items():
sales_by.setdefault(c, []).append((d, int(m.gross)))
def spend(ch: str, s: date, e: date) -> int:
return sum(v for d, v in spend_by.get(ch, ()) if s <= d <= e)
def sales(c: str, s: date, e: date) -> int:
return sum(v for d, v in sales_by.get(c, ()) if s <= d <= e)
for r in table:
s = date.fromisoformat(r["from"]) if r.get("from") else period.start
e = date.fromisoformat(r["to"]) if r.get("to") else period.end
tot_spend = 0
for c in codes:
lines = []
for ch, label in by_code.get(c, ()):
amt = spend(ch, s, e)
if not amt:
continue
rs = ad_spend.channel_roas(ch, lambda m: sales(m, s, e), amt,
lambda f: ad_spend.file_roas(f, roas_map, amounts, s, e))
lines.append({"label": label, "amount": amt, "roas": rs})
tot_spend += amt
if lines:
r["ads"][c] = lines
if tot_spend:
tot = r.get("total") or {}
r["ads_total"] = {"amount": tot_spend, "roas": ad_spend.roas(tot.get("gross") or 0, tot_spend),
"roas_net": ad_spend.roas(tot.get("net") or 0, tot_spend)}
def sales_ad_channels() -> dict[str, tuple[tuple[str, str], ...]]:
"""쇼핑몰(매출 코드) → 그 아래 보일 광고 채널 [(채널, 줄 이름)]. 카페24 = 구글·메타(자사몰 광고), 네이버 = 네이버 광고,
나머지는 광고비 화면의 ROAS 매출 쇼핑몰(쿠팡(윙) 광고 → 쿠팡 매출)."""
from . import ad_spend # noqa: WPS433
out: dict[str, tuple[tuple[str, str], ...]] = {"cafe24": (("google", "구글"), ("meta", "메타")), "naver": (("naver", ""),)}
for ch, c in ad_spend.ROAS_SALES_CODE.items():
out[c] = out.get(c, ()) + ((ch, ""),)
return out
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,
@@ -68,28 +155,16 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
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]
# KPI 는 수수료 차감 매출 하나만(2026-10-19) — 화면 왼쪽 한 줄(금액 + 비교 기간 대비 %).
# 총매출·수수료·월 누적·연 누적 카드는 뺐다(아래 표·월/연 누적 카드에 같은 값이 있다).
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)
@@ -105,6 +180,8 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
"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)
table = calc.main_table(period, codes, cells, today=today, holidays=holidays)
_ad_lines(store, table, codes, cells, period, q_start, q_end)
def url(kind: str, anchor_d: date | None = None, start: date | None = None, end: date | None = None) -> str:
if kind == "custom":
@@ -144,7 +221,7 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
"short_names": short,
"selected_all": len(codes) == len(all_codes),
"kpis": kpis,
"table": calc.main_table(period, codes, cells, today=today, holidays=holidays),
"table": table,
"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),
+36 -6
View File
@@ -440,16 +440,25 @@ class PerformanceDBStore:
return len(entries)
def ad_roas(self, start: date, end: date) -> dict[tuple[date, str], Decimal]:
"""(날짜, 채널) → 보고서 ROAS(%) — 값이 있는 칸만. 005·006 미적용이면 빈 값(화면은 ROAS 없이)."""
"""(날짜, 채널) → 보고서 ROAS(%) — 값이 있는 칸만. 005·006 미적용이면 빈 값(화면은 ROAS 없이).
roas 가 비었어도 보관된 보고서 항목(metrics)에 광고수익률·전환매출액이 있으면 그것으로 구한다
(네이버 파일 열 위치가 달라 고정 12열이 비어 저장됐던 예전 업로드 — 다시 올리지 않아도 보이게, 2026-10-20)."""
from .ad_spend import roas_from_metrics # noqa: WPS433
try:
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT spend_date, channel_code, roas FROM perf_ad_spend "
"WHERE spend_date BETWEEN %s AND %s AND roas IS NOT NULL", (start, end),
"SELECT spend_date, channel_code, amount, roas, metrics FROM perf_ad_spend "
"WHERE spend_date BETWEEN %s AND %s AND (roas IS NOT NULL OR metrics IS NOT NULL)", (start, end),
).fetchall()
except (pg_errors.UndefinedTable, pg_errors.UndefinedColumn):
return {}
return {(r["spend_date"], r["channel_code"]): r["roas"] for r in rows}
out: dict[tuple[date, str], Decimal] = {}
for r in rows:
value = r["roas"] if r["roas"] is not None else roas_from_metrics(r["metrics"], r["amount"])
if value is not None:
out[(r["spend_date"], r["channel_code"])] = value
return out
def ad_details(self, code: str, start: date, end: date) -> list[dict[str, Any]]:
"""한 채널의 일자별 광고비·ROAS·보고서 항목(날짜 순). 006 미적용이면 AdMigrationNeeded."""
@@ -494,12 +503,24 @@ class PerformanceDBStore:
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 "
" discount_amount, order_status, is_sample, "
# 주문 내역 칸(2026-10-19) — 카페24 적립금(결제 +, 환불 −) · 네이버 배송비 · 네이버 환불금액(raw_data 의 숫자만)
" raw_data ->> 'points' AS points, raw_data ->> 'ship' AS ship, raw_data ->> 'refund' AS refund, "
" raw_data ->> 'goods' AS goods " # 네이버 판매금액(배송비 뺀 값) — 주문 내역 '판매금액' 칸
"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]
out = []
for r in rows:
row = {k: _iso(v) for k, v in r.items()}
for k in ("points", "ship", "refund", "goods"):
try:
row[k] = int(round(float(row[k]))) if row.get(k) not in (None, "") else None
except (TypeError, ValueError):
row[k] = None
out.append(row)
return out
def sample_count(self) -> int:
with self._pool.connection() as conn:
@@ -552,6 +573,15 @@ class PerformanceDBStore:
).fetchone()
return _iso(row["t"]) if row and row["t"] else None
def abandon_running_runs(self) -> int:
"""서버 시작 때 1번(2026-10-19) — 남아 있는 running 행은 지난 프로세스가 업데이트 도중 끝난 것(앱은 프로세스 하나,
진행 작업은 메모리에만)이라 '중단됨'으로 정리한다. 안 하면 30분(STALE_RUN_AFTER) 동안 [매출 업데이트]가 '업데이트 중'으로
보이고 그 쇼핑몰 업데이트가 '이미 진행 중'으로 건너뛰어진다. 정리한 행 수."""
with self._pool.connection() as conn:
cur = conn.execute("UPDATE perf_sync_runs SET status = 'failed', finished_at = now(), "
"error = '중단됨(서버 재시작)' WHERE status = 'running'")
return cur.rowcount
def running_codes(self) -> list[str]:
with self._pool.connection() as conn:
rows = conn.execute(
+90
View File
@@ -0,0 +1,90 @@
"""외화 → 원화 날짜별 환율(2026-10-16 사용자 요청: 메타 USD 광고 계정 — "그날 환율로 원화 환산").
출처: Frankfurter(https://frankfurter.dev, API 키 없음) v2 `GET /v2/rates?base=USD&quotes=KRW&from=&to=`
— 여러 나라 중앙은행 고시 환율을 합친 값(blended)이고 주말·공휴일 포함 매일 있다. 서울외국환중개 매매기준율과는
조금(보통 0.5% 안쪽) 다를 수 있다. 응답: [{"date": "2026-10-01", "base": "USD", "quote": "KRW", "rate": 1357.92}, …]
그날 값이 없으면(오늘처럼 아직 안 나온 날 등) 그 앞 가장 가까운 날 값을 쓴다(LOOKBACK_DAYS 안).
지난 날(2일 이상 지난) 환율은 프로세스 안에 기억해 30분마다 도는 자동 업데이트가 같은 날을 다시 묻지 않게 한다.
"""
from __future__ import annotations
import threading
from datetime import date, timedelta
from decimal import Decimal, InvalidOperation
import httpx
from app.timezone import today_kst
FX_API = "https://api.frankfurter.dev/v2/rates"
SOURCE_LABEL = "Frankfurter(중앙은행 고시 환율 종합)"
LOOKBACK_DAYS = 10 # 그날 환율이 없으면 이만큼 앞까지 찾는다
_SETTLED_AFTER = 2 # 오늘에서 이만큼 지난 날 환율만 기억(최근 값은 나중에 고시될 수 있음)
_cache_lock = threading.Lock()
_cache: dict[tuple[str, date], Decimal] = {}
class FxError(Exception):
"""환율을 가져오지 못함 — 문구는 화면에 그대로 보인다."""
def krw_rates(client: httpx.Client, currency: str, start: date, end: date, *, today: date | None = None) -> dict[date, Decimal]:
"""start~end(양 끝 포함) 날마다 1 {currency} = ? 원. 하루라도 못 정하면 FxError(일부만 환산해 저장하지 않게)."""
cur = (currency or "").upper()
if cur == "KRW":
return {start + timedelta(days=i): Decimal(1) for i in range((end - start).days + 1)}
days = [start + timedelta(days=i) for i in range((end - start).days + 1)]
with _cache_lock:
known = {d: _cache[(cur, d)] for d in days if (cur, d) in _cache}
if len(known) == len(days):
return known
fetched = _fetch(client, cur, start - timedelta(days=LOOKBACK_DAYS), end)
today = today or today_kst()
out: dict[date, Decimal] = {}
for d in days:
rate = next((fetched[d - timedelta(days=k)] for k in range(LOOKBACK_DAYS + 1) if d - timedelta(days=k) in fetched), None)
if rate is None:
raise FxError(f"{d.isoformat()} 의 {cur}→KRW 환율을 찾지 못했습니다({SOURCE_LABEL}).")
out[d] = rate
with _cache_lock:
for d, rate in out.items():
if d in fetched and (today - d).days >= _SETTLED_AFTER:
_cache[(cur, d)] = rate
return out
def _fetch(client: httpx.Client, cur: str, start: date, end: date) -> dict[date, Decimal]:
try:
resp = client.get(FX_API, params={"base": cur, "quotes": "KRW", "from": start.isoformat(), "to": end.isoformat()})
except httpx.HTTPError as exc:
raise FxError(f"환율 서버({SOURCE_LABEL})에 연결하지 못했습니다({type(exc).__name__}).") from None
if resp.status_code != 200:
try:
msg = str((resp.json() or {}).get("message") or "")
except ValueError:
msg = ""
raise FxError(f"환율을 가져오지 못했습니다(HTTP {resp.status_code}{': ' + msg[:120] if msg else ''}).")
try:
rows = resp.json()
except ValueError:
raise FxError("환율 서버 응답을 읽을 수 없습니다.") from None
out: dict[date, Decimal] = {}
for r in rows if isinstance(rows, list) else []:
if not isinstance(r, dict) or str(r.get("quote") or "").upper() != "KRW":
continue
try:
d = date.fromisoformat(str(r.get("date")))
rate = Decimal(str(r.get("rate")))
except (ValueError, InvalidOperation):
continue
if rate > 0:
out[d] = rate
return out
def clear_cache() -> None:
"""테스트용."""
with _cache_lock:
_cache.clear()
+33 -5
View File
@@ -17,8 +17,8 @@ JSON API — 모듈 권한
PUT /performance/api/ad-spend/{channel}/{day} 광고비 한 칸 저장/지움(오늘까지)
POST /performance/api/ad-spend/upload?channel= 광고비 파일 업로드(쿠팡 윙·로켓 광고 보고서 1열 날짜·19열 청구금액,
네이버 광고 보고서 3열 기간·4열 총비용·12열 ROAS + 나머지 항목)
GET /performance/api/ad-spend/{channel}/details?from=&to= 일자별 보고서 항목(네이버·구글 머리글 클릭)
POST /performance/api/ad-sources/{code}/sync 광고 API(구글 광고) 가져오기 — 보는 기간(오늘까지), 92일 넘으면 관리자
GET /performance/api/ad-spend/{channel}/details?from=&to= 일자별 보고서 항목(네이버·구글·메타 머리글 클릭)
POST /performance/api/ad-sources/{code}/sync 광고 API(구글·메타 광고) 가져오기 — 보는 기간(오늘까지), 92일 넘으면 관리자
JSON API — 관리자
GET|PUT /performance/api/ad-sources/{code}/credentials 광고 API 인증정보(마이그레이션 007, 암호화 저장·비밀 원문 없음)
POST /performance/api/ad-sources/{code}/test 광고 API 연결 테스트(저장값 또는 새 입력값)
@@ -116,7 +116,7 @@ def dashboard_page(
from_: str | None = Query(None, alias="from"),
to: str | None = None,
m: list[str] = Query(default=[]),
metric: str = "gross",
metric: str = "net",
):
from app.main import render_template # noqa: WPS433
@@ -134,10 +134,37 @@ def dashboard_page(
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"
ctx["metric"] = metric if metric in ("gross", "commission", "net") else "net"
ctx["auto_sync"] = _auto_sync_ctx()
_unit_ctx(request, ctx)
return render_template(request, "performance/index.html", {**common.base_ctx(user, active_tab="dashboard"), **ctx})
def _auto_sync_ctx() -> dict[str, Any] | None:
"""다음 자동 업데이트까지 남은 시간(2026-10-19) — 화면이 초 단위로 센다. 회차가 지나면 화면이 같은 규칙
(hours·slot, KST)으로 다음 회차를 계산한다. 서버 시각(now)으로 PC 시계 차이를 보정. 자동 업데이트가 꺼져 있으면 None."""
from app.timezone import now_kst # noqa: WPS433
from . import auto_sync # noqa: WPS433
if not auto_sync.enabled():
return None
hours = auto_sync.hour_window()
now = now_kst()
return {"next_at": auto_sync.next_slot(now, hours).isoformat(), "now": now.isoformat(timespec="milliseconds"),
"hours": list(hours), "slot": auto_sync.SLOT_MINUTES}
def _unit_ctx(request: Request, ctx: dict[str, Any]) -> None:
"""매출 단위(원·천원·백만원) — 실적 설정 "보기 설정"이 이 브라우저 쿠키(perf_unit)에 둔다. 템플릿은 amt(v) 로 그린다."""
from .dashboard import UNIT_COOKIE, UNITS, amount_text, normalize_unit # noqa: WPS433
unit = normalize_unit(request.cookies.get(UNIT_COOKIE))
ctx["unit"] = unit
ctx["unit_label"] = UNITS[unit][2]
ctx["amt"] = lambda v: amount_text(v, unit)
@router.get("/ads", response_class=HTMLResponse)
def ads_page(
request: Request,
@@ -192,6 +219,7 @@ def settings_page(request: Request):
)
ctx["ad_sources"] = _ad_source_rows(store, ad_sync.configured())
ctx["ad_api_ready"] = store.ad_api_ready()
_unit_ctx(request, ctx)
return render_template(request, "performance/settings.html",
{**common.base_ctx(user, active_tab="settings", page_title="실적 설정"), **ctx})
@@ -490,7 +518,7 @@ def api_ad_spend_details(request: Request, channel: str, from_: str = Query(...,
except ad_spend.AdMigrationNeeded as exc:
raise HTTPException(status_code=503, detail=_ad_migration_help(exc)) from None
return JSONResponse({"channel": channel, "name": ad_spend.CHANNEL_NAMES[channel], "from": start.isoformat(),
"to": end.isoformat(), **ad_spend.detail_table(rows)})
"to": end.isoformat(), **ad_spend.detail_table(rows), **ad_spend.detail_tabs(rows)})
@router.post("/api/ad-spend/upload")
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261015a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261019f" />{% endblock %}
{#- ROAS 덧붙임 — "광고비(ROAS%)". 광고비가 없으면 아무것도 안 붙는다. -#}
{%- macro roas(p) -%}{%- if p is not none -%}<span class="perf-roas">({{ "{:,}".format(p) }}%)</span>{%- endif -%}{%- endmacro -%}
@@ -89,7 +89,7 @@
<thead>
<tr>
<th class="perf-th-label">{% if period_kind == 'year' %}월{% else %}날짜{% endif %}</th>
{% for c in codes %}{% if c in detail_channels %}<th class="perf-th-detail" title="{{ names[c] }} — 눌러 일자별 광고 보고서 항목 보기. 괄호 = {% if c == 'google' %}구글 광고 ROAS(전환 가치 ÷ 비용){% else %}보고서 ROAS(구매완료 광고수익률){% endif %}"><button type="button" class="perf-detail-btn" data-detail-channel="{{ c }}">{{ names[c] }} <span class="material-symbols-outlined" aria-hidden="true">table_view</span></button></th>{% else %}<th title="{{ names[c] }} — 날짜 칸을 눌러 광고비 입력.{% if roas_basis[c] %} 괄호 = ROAS({{ roas_basis[c] }} 매출 ÷ 광고비){% else %} ROAS 는 계산하지 않음(따로 입력){% endif %}">{{ names[c] }} <span class="perf-manual-mark" aria-hidden="true">✎</span></th>{% endif %}{% endfor %}
{% for c in codes %}{% if c in detail_channels %}<th class="perf-th-detail" title="{{ names[c] }} — 눌러 일자별 광고 보고서 항목 보기. 괄호 = {% if c == 'google' %}구글 광고 ROAS(전환 가치 ÷ 비용){% elif c == 'meta' %}메타 광고 구매 ROAS(구매 전환값 ÷ 지출 금액){% else %}보고서 ROAS(구매완료 광고수익률){% endif %}"><button type="button" class="perf-detail-btn" data-detail-channel="{{ c }}">{{ names[c] }} <span class="material-symbols-outlined" aria-hidden="true">table_view</span></button></th>{% else %}<th title="{{ names[c] }} — 날짜 칸을 눌러 광고비 입력.{% if roas_basis[c] %} 괄호 = ROAS({{ roas_basis[c] }} 매출 ÷ 광고비){% else %} ROAS 는 계산하지 않음(따로 입력){% endif %}">{{ names[c] }} <span class="perf-manual-mark" aria-hidden="true">✎</span></th>{% endif %}{% endfor %}
<th class="perf-th-total">{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}</th>
</tr>
</thead>
@@ -119,10 +119,10 @@
</div>
{% if period_kind != 'year' %}
<p class="perf-muted perf-manual-help">날짜 칸을 눌러 그날 <b>광고비</b>를 직접 입력합니다 — Enter 저장 후 아래 칸, Esc 취소, 비우고 저장하면 지움.
칸은 <b>광고비(ROAS%)</b> — ROAS = 그 쇼핑몰 매출 실적 총매출 ÷ 광고비(합계 열은 전체 매출). 메타는 ROAS 를 계산하지 않고,
네이버는 광고 보고서의 ROAS(구매완료 광고수익률), 구글은 구글 광고 API 의 ROAS(전환 가치 ÷ 비용)를 씁니다 — 네이버·구글 머리글을 누르면 일자별 보고서 항목.
칸은 <b>광고비(ROAS%)</b> — ROAS = 그 쇼핑몰 매출 실적 총매출 ÷ 광고비(합계 열은 전체 매출). 메타는 메타 광고 API 의 구매 ROAS(구매 전환값 ÷ 지출 금액),
네이버는 광고 보고서의 ROAS(구매완료 광고수익률), 구글은 구글 광고 API 의 ROAS(전환 가치 ÷ 비용)를 씁니다 — 네이버·구글·메타 머리글을 누르면 일자별 보고서 항목.
파란 숫자 = 직접 입력, 주황 숫자 = 파일 업로드 값, 초록 숫자 = 광고 API 값. 쿠팡(윙)·쿠팡(로켓)·네이버는 [파일 업로드]로 광고 보고서를 올리면 날짜별로 한 번에 들어갑니다.
구글은 [구글 광고 불러오기](관리자가 실적 설정 → 광고 API 연동을 마친 뒤) 또는 매출 자동 업데이트 때 들어옵니다.</p>
구글·메타는 [구글 광고 불러오기]·[메타 광고 불러오기](관리자가 실적 설정 → 광고 API 연동을 마친 뒤) 또는 매출 자동 업데이트 때 들어옵니다.</p>
{% endif %}
</div>
@@ -200,8 +200,8 @@
</div>
<p class="perf-foot perf-muted">
광고비 기준: 쿠팡(윙)·쿠팡(로켓)은 광고 보고서의 청구금액(+부가가치세), 구글은 구글 광고 비용 + 부가세 10%(부가세 포함).
ROAS = 그 쇼핑몰 매출 ÷ 광고비 × 100(메타는 계산 안 함, 네이버·구글은 광고 쪽 값).
광고비 기준: 쿠팡(윙)·쿠팡(로켓)은 광고 보고서의 청구금액(+부가가치세), 구글은 구글 광고 비용 + 부가세 10%(부가세 포함), 메타는 지출 금액 그대로(이미 부가세 포함).
ROAS = 그 쇼핑몰 매출 ÷ 광고비 × 100(네이버·구글·메타는 광고 쪽 값).
매출 대비 광고비 = 같은 기간 광고비 ÷ 매출 실적 총매출.
메타는 지금은 직접 입력합니다.
</p>
@@ -224,4 +224,4 @@
} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261015b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261020a" defer></script>{% endblock %}
@@ -1,11 +1,27 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261015a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261019f" />{% 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 -%}
{%- else -%}{{ amt(v) }}{%- endif -%}
{%- endmacro -%}
{#- 큰 금액(KPI·연 누적) — 원 단위면 ₩1,234, 천원·백만원이면 1,234천원 -#}
{%- macro money(v) -%}
{%- if unit == 'won' -%}₩{{ amt(v) }}{%- else -%}{{ amt(v) }}<small class="perf-unit-suffix">{{ unit_label }}</small>{%- endif -%}
{%- endmacro -%}
{#- 매출 칸 아래 광고비(ROAS%) — 광고비 화면과 같은 값·색. 카페24 = 구글·메타 두 줄(이름 붙임) -#}
{%- macro adl(lines) -%}
{%- for a in lines or [] -%}<span class="perf-adl" title="{{ (a.label ~ ' ') if a.label }}광고비 {{ '{:,}'.format(a.amount) }}원{% if a.roas is not none %} · ROAS {{ '{:,}'.format(a.roas) }}%{% endif %}">{% if a.label %}<i>{{ a.label }}</i>{% endif %}{{ amt(a.amount) }}{% if a.roas is not none %}<em>({{ "{:,}".format(a.roas) }}%)</em>{% endif %}</span>{%- endfor -%}
{%- endmacro -%}
{#- 일 합계 광고비(ROAS%) — ROAS = 일 합계 금액 ÷ 일 합계 광고비. 수수료 차감 매출 보기면 차감 매출 기준, 그 밖엔 총매출 기준 -#}
{%- macro adl_total(a) -%}
{%- for key, cls in (("roas", "for-gross"), ("roas_net", "for-net")) -%}
{%- set rs = a[key] -%}
<span class="perf-adl perf-adl-tot {{ cls }}" title="광고비 합계 {{ '{:,}'.format(a.amount) }}원{% if rs is not none %} · ROAS {{ '{:,}'.format(rs) }}% (일 합계 {{ '수수료 차감 매출' if key == 'roas_net' else '총매출' }} ÷ 광고비){% endif %}">{{ amt(a.amount) }}{% if rs is not none %}<em>({{ "{:,}".format(rs) }}%)</em>{% endif %}</span>
{%- endfor -%}
{%- endmacro -%}
{#- 한 칸에 총매출/수수료/차감매출 세 값을 넣고, 보기 전환은 CSS(data-metric)로. -#}
@@ -64,9 +80,14 @@
<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 %}
{% if auto_sync %}
{# 다음 자동 업데이트까지 남은 시간 — 초 단위로 실시간(performance.js initNextUpdate, 2026-10-19) #}
<span class="perf-muted perf-next-update" id="perf-next-update" title="자동 업데이트: 매일 {{ auto_sync.hours[0] }}~{{ auto_sync.hours[1] }}시 {{ auto_sync.slot }}분마다">다음 업데이트까지 <b>—</b></span>
{% endif %}
{# 업데이트 중에도 누를 수 있다 — 진행 중인 업데이트(수동·자동)의 진행 창을 다시 연다(2026-10-19) #}
<button type="button" class="erp-btn erp-btn-primary{% if running %} is-running{% endif %}" id="perf-sync-btn"
title="{% if running %}업데이트 진행 상황 보기{% else %}지금 보고 있는 기간({{ period.label }}, 오늘까지)의 매출을 쇼핑몰에서 다시 가져옵니다{% endif %}">
{% if running %}업데이트 중 · 진행 보기{% else %}매출 업데이트{% endif %}
</button>
</div>
</div>
@@ -84,29 +105,25 @@
{% 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 %}
<!-- ── KPI — 수수료 차감 매출 한 줄(금액 + 비교 기간 대비 %, 2026-10-19) ── -->
{% for k in kpis %}
<div class="perf-kpi-line" title="{{ k.label }}">
<b class="perf-kpi-line-value">{{ money(k.value) }}</b>
{% if k.delta is none %}<span class="perf-muted">{{ k.cmp }} 비교 없음</span>
{% else %}
<span class="perf-delta {% if k.delta == 0 %}is-flat{% elif k.delta > 0 %}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>
{% endfor %}
<!-- ── 일자 × 쇼핑몰 ── -->
<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-head-notes">{% if unit != 'won' %}<span class="perf-muted">단위: {{ unit_label }}</span>{% endif %}
<span class="perf-adl-note" title="매출 아래 주황 숫자 = 그 쇼핑몰 광고비(ROAS%) — 광고비 탭과 같은 값. 카페24 는 구글·메타"><span class="perf-adl-key"></span>광고비(ROAS%)</span></span>
{% if manual_upload_names %}
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm perf-manual-upload-btn" id="perf-manual-upload"
title="수동 입력 쇼핑몰 매출을 엑셀 파일로 한 번에 입력">엑셀 업로드</button>
@@ -138,13 +155,13 @@
{% set is_manual = (r.date ~ '|' ~ c) in manual_cells %}
<td class="perf-num is-manual-cell{% if is_manual %} is-manual{% endif %}" data-manual-code="{{ c }}" data-date="{{ r.date }}"
data-manual-value="{{ m.gross if is_manual else '' }}" tabindex="0"
title="{% if is_manual %}수동 입력값 — 눌러 고치기(비우고 저장하면 API 값){% else %}눌러 총매출 직접 입력{% endif %}">{{ m3(m) }}</td>
title="{% if is_manual %}수동 입력값 — 눌러 고치기(비우고 저장하면 API 값){% else %}눌러 총매출 직접 입력{% endif %}">{{ m3(m) }}{{ adl(r.ads[c]) }}</td>
{% else %}
<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>
{% if r['from'] %}data-code="{{ c }}" data-from="{{ r['from'] }}" data-to="{{ r['to'] }}"{% endif %}>{{ m3(m) }}{{ adl(r.ads[c]) }}</td>
{% endif %}
{% endfor %}
<td class="perf-num perf-td-total">{{ m3(r.total) }}</td>
<td class="perf-num perf-td-total">{{ m3(r.total) }}{% if r.ads_total %}{{ adl_total(r.ads_total) }}{% endif %}</td>
</tr>
{% endfor %}
</tbody>
@@ -173,7 +190,7 @@
<!-- ── 월 누적 · 연간 누적 ── -->
<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="perf-card-head"><h2 class="perf-h">{{ month.label }} 쇼핑몰별 누적 실적</h2>{% if unit != 'won' %}<span class="perf-muted perf-unit-note">단위: {{ unit_label }}</span>{% endif %}</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>
@@ -204,11 +221,11 @@
</div>
<div class="erp-card perf-card">
<div class="perf-card-head"><h2 class="perf-h">{{ year.year }}년 누적</h2></div>
<div class="perf-card-head"><h2 class="perf-h">{{ year.year }}년 누적</h2>{% if unit != 'won' %}<span class="perf-muted perf-unit-note">단위: {{ unit_label }}</span>{% endif %}</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><span>총매출</span><b>{{ money(year.total.gross) }}</b></div>
<div><span>수수료</span><b>{{ money(year.total.commission) }}</b></div>
<div><span>수수료 차감 매출</span><b>{{ money(year.total.net) }}</b></div>
</div>
<div class="erp-table-wrap">
<table class="perf-table perf-year">
@@ -251,8 +268,10 @@
"period_start": period.start.isoformat(),
"period_end": period.end.isoformat(),
"today": today,
"manual_upload_names": manual_upload_names
"unit": unit,
"manual_upload_names": manual_upload_names,
"auto_sync": auto_sync
} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261015b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261020a" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261015a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261019f" />{% endblock %}
{%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%}
@@ -102,14 +102,33 @@
</p>
</div>
{# 보기 설정(2026-10-19) — 모듈 권한자 누구나, 이 브라우저에만(쿠키 perf_unit). 매출 실적 화면 금액·광고비 줄에 적용 #}
<div class="erp-card perf-card" id="perf-view-opts">
<div class="perf-card-head">
<h2 class="perf-h">보기 설정</h2>
<span class="perf-muted">매출 실적 화면의 금액 단위입니다. 이 브라우저에만 적용되며 고르면 바로 저장됩니다.</span>
</div>
<div class="perf-opt-row">
<span class="perf-opt-label">매출 단위</span>
<div class="perf-quick" role="radiogroup" aria-label="매출 단위">
{% for k, label in [('won', '원'), ('thousand', '천원'), ('million', '백만원')] %}
<button type="button" class="perf-seg{% if unit == k %} is-active{% endif %}" role="radio"
aria-checked="{{ 'true' if unit == k else 'false' }}" data-unit="{{ k }}">{{ label }}</button>
{% endfor %}
</div>
<span class="perf-muted" id="perf-unit-example">예: 2,475,300원 →
{% if unit == 'thousand' %}2,475{% elif unit == 'million' %}2.5{% else %}2,475,300{% endif %}</span>
</div>
</div>
{% if is_admin %}
{# 광고 API 연동(2026-10-15, 마이그레이션 007) — 구글 광고 등. 인증정보는 쇼핑몰과 같은 마스터 키로 암호화 저장.
{# 광고 API 연동(2026-10-15, 마이그레이션 007) — 구글 광고·메타 광고(2026-10-16). 인증정보는 쇼핑몰과 같은 마스터 키로 암호화 저장.
가져온 광고비·ROAS 는 광고비 탭(초록 숫자). [설정]·[연결 테스트]는 쇼핑몰 표와 같은 창(/api/ad-sources/…). #}
<div class="erp-card perf-card" id="perf-ad-sources">
<div class="perf-card-head">
<h2 class="perf-h">광고 API 연동</h2>
<span class="perf-muted">광고비 탭의 광고비·ROAS 를 광고 API 로 가져옵니다. 인증정보는 [설정]에서 입력하면 암호화해 저장합니다.
설정이 끝나면 광고비 탭 [구글 광고 불러오기]와 매출 자동 업데이트(30분마다 최근 며칠) 때 함께 가져옵니다.</span>
설정이 끝나면 광고비 탭 [구글 광고 불러오기]·[메타 광고 불러오기]와 매출 자동 업데이트(30분마다 최근 며칠) 때 함께 가져옵니다.</span>
</div>
{% if not ad_api_ready %}
<div class="perf-notice is-warn">광고 API 인증정보 저장 표가 아직 없습니다. performance_db 마이그레이션 007
@@ -142,7 +161,8 @@
</table>
</div>
<p class="perf-foot perf-muted">
구글 광고: 광고비 = 구글 광고 화면의 "비용" + 부가세 10%(부가세 포함), ROAS = 전환 가치 ÷ 비용(구글 화면 값 그대로). 날짜는 광고 계정 시간대 기준이며 원화(KRW) 계정만 가져옵니다.
구글 광고: 광고비 = 구글 광고 화면의 "비용" + 부가세 10%(부가세 포함), ROAS = 전환 가치 ÷ 비용(구글 화면 값 그대로). 날짜는 광고 계정 시간대 기준이며 원화(KRW) 계정만 가져옵니다.<br>
메타 광고: 광고비 = 광고 관리자의 "지출 금액" 그대로(메타 금액은 이미 부가세 포함), ROAS = 구매 전환값 ÷ 지출 금액(광고 관리자 "구매 ROAS"). 광고 계정이 여러 개면 날짜별로 합칩니다. 날짜는 광고 계정 시간대 기준이며, 달러 등 외화 계정은 그날 환율로 원화로 바꿔 넣습니다(중앙은행 고시 환율 종합, 그날 값이 없으면 직전 값).
가져온 날은 직접 입력·업로드 값보다 우선해 덮어씁니다.
</p>
</div>
@@ -182,55 +202,6 @@
<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>: 매출 내역·배송비 내역(매출인식일 기준)의 항목별 합계 — 협력사 포털 매출 화면의 같은 기간 숫자와 비교해 주세요.<br>
· <b>토스쇼핑</b>: 날짜별 매출·환불·순 거래액(= 저장되는 매출)과 주문 상태별·정산 항목 합계 — 토스쇼핑 파트너스의 같은 날 숫자와 비교해 주세요.<br>
· <b>쿠팡(윙)</b>: 판매자배송 발주서 + 로켓그로스 주문을 결제일로 모아 날짜별 매출 후보(할인 전·후, 취소분 뺀 값, 로켓그로스 따로)와 판매량 — WING 비즈니스 인사이트 → 판매분석에서 같은 날짜의 "매출(원)"·"판매량"과 비교해 주세요.</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>
<option value="toss">토스쇼핑</option>
<option value="coupang">쿠팡(윙)</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>
@@ -248,4 +219,4 @@
</section>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261015b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261020a" defer></script>{% endblock %}
+30 -2
View File
@@ -126,7 +126,7 @@ def test_ad_dashboard_month():
assert k["ytd"]["value"] == 370000 and k["mtd"]["value"] == 270000
assert ctx["upload_cells"] == ["2026-10-01|coupang_rocket"]
assert [c["code"] for c in ctx["upload_channels"]] == ["naver", "coupang_wing", "coupang_rocket"]
assert ctx["detail_channels"] == ["google", "naver"] # 구글 = 광고 API 로 가져온 항목(2026-10-15)
assert ctx["detail_channels"] == ["google", "meta", "naver"] # 구글(2026-10-15)·메타(2026-10-16) = 광고 API 로 가져온 항목
assert ctx["api_cells"] == []
day1 = next(r for r in ctx["table"] if r.get("date") == "2026-10-01")
assert day1["cells"]["coupang_rocket"]["gross"] == 220000 and day1["total"]["gross"] == 220000
@@ -240,6 +240,32 @@ def test_naver_report_reads_date_cost_roas_and_metrics():
assert "겹칩니다" in errs and "총비용이 숫자가 아닙니다" in errs and "ROAS" in errs and "앞으로의 날짜" in errs
def test_naver_report_finds_columns_by_header():
"""열 구성을 바꾼 보고서 — 총비용·광고수익률이 4열·12열이 아니어도 머리글로 찾는다(2026-10-20: 12열이 비어 ROAS 누락)."""
csv_text = ("광고 계정 이름,광고 계정 ID,기간,노출수,클릭수,총비용,구매완료 광고수익률(%),구매완료 전환매출액\n"
"0_미라네주방,38461,2026.09.23.,30043,461,300672,67.58,203194\n")
res = ads.parse_naver(csv_text.encode("utf-8"), today=TODAY, filename="n.csv")
assert not res.errors, res.errors
assert res.entries == [(date(2026, 9, 23), 300672)] and str(res.roas[date(2026, 9, 23)]) == "67.58"
def test_naver_report_without_roas_column_computes_from_purchase_revenue():
csv_text = ("광고 계정 이름,광고 계정 ID,기간,총비용,노출수,구매완료 전환매출액,총 전환매출액\n"
"0_미라네주방,38461,2026.09.22.,299817,31061,596016,15040200\n"
"0_미라네주방,38461,2026.09.24.,0,0,0,6331500\n")
res = ads.parse_naver(csv_text.encode("utf-8"), today=TODAY, filename="n.csv")
assert not res.errors, res.errors
assert str(res.roas[date(2026, 9, 22)]) == "198.79" # 596,016 ÷ 299,817 × 100 (총 전환매출액은 안 씀)
assert date(2026, 9, 24) not in res.roas # 광고비 0 — 계산 안 함
def test_roas_from_metrics_for_stored_rows():
assert ads.roas_from_metrics({"구매완료 광고수익률(%)": 501.11}, 299199) == Decimal("501.11")
assert ads.roas_from_metrics({"구매완료 광고수익률(%)": None, "구매완료 전환매출액": 600000}, 300000) == Decimal("200.00")
assert ads.roas_from_metrics({"총 전환매출액": 600000}, 300000) is None
assert ads.roas_from_metrics(None, 1) is None and ads.roas_from_metrics({"구매완료 전환매출액": 5}, 0) is None
def test_naver_roas_from_report_weighted():
"""네이버 칸 ROAS = 보고서 값(계산 안 함), 여러 날 = Σ(ROAS×광고비)÷Σ광고비, 광고비 0 인 날은 빼고."""
class S(_Store):
@@ -276,7 +302,9 @@ def test_naver_detail_table_totals():
{"date": "2026-09-24", "amount": 0, "roas": Decimal("0"), "metrics": {"총비용": 0, "노출수": 0, "클릭수": 0,
"클릭률(%)": 0.0, "구매완료 광고수익률(%)": 0}}]
t = ads.detail_table(rows)
assert t["columns"] == ["총비용", "노출수", "클릭수", "클릭률(%)", "구매완료 광고수익률(%)"]
# ROAS(12열)는 광고비(총비용) 바로 오른쪽, 머리글은 "ROAS(%)"(값 키는 파일 머리글 그대로)
assert t["columns"] == ["총비용", "구매완료 광고수익률(%)", "노출수", "클릭수", "클릭률(%)"]
assert t["labels"] == {"구매완료 광고수익률(%)": "ROAS(%)"}
assert t["total"]["총비용"] == 600489 and t["total"]["노출수"] == 61104 and t["total"]["클릭수"] == 902
assert t["total"]["클릭률(%)"] == round(902 * 100 / 61104, 2) # 가중: 클릭수 ÷ 노출수
assert t["total"]["구매완료 광고수익률(%)"] == 133.09 # 광고비 가중 평균 (198.79×299,817 + 67.58×300,672) ÷ 600,489
@@ -67,3 +67,28 @@ def test_run_once_uses_job_and_skips_when_busy(monkeypatch):
monkeypatch.setattr(jobs, "running_job", lambda: object())
assert au.run_once(Store(), None, today=date(2026, 10, 13), days=10)["skipped"]
assert len(calls) == 1
def test_startup_clears_orphan_running_runs(monkeypatch):
"""서버 시작 때 지난 프로세스가 남긴 '진행 중' 기록을 정리(2026-10-19) — 자동 업데이트를 꺼 둬도, DB 오류여도 앱은 뜬다."""
from types import SimpleNamespace
from app.modules.performance import auto_sync as a
calls = []
class Store:
def abandon_running_runs(self):
calls.append(1)
return 2
monkeypatch.setattr(a, "_started", False)
monkeypatch.setenv("PERFORMANCE_AUTO_SYNC", "false")
assert a.start_auto_sync_thread(SimpleNamespace(performance_store=Store())) is False
assert calls == [1]
class Broken:
def abandon_running_runs(self):
raise RuntimeError("db down")
assert a.start_auto_sync_thread(SimpleNamespace(performance_store=Broken())) is False # 예외가 새지 않음
@@ -0,0 +1,153 @@
"""매출 실적 화면 — 매출 칸 아래 광고비(ROAS%)·매출 단위(원·천원·백만원) (2026-10-19)."""
from __future__ import annotations
from datetime import date
from app.modules.performance import dashboard
TODAY = date(2026, 10, 7)
class _Store:
"""build_dashboard 가 읽는 것만 — 카페24·네이버·쿠팡 매출 + 구글·메타·네이버·쿠팡(윙) 광고비."""
def __init__(self, ads_missing=False):
self.ads_missing = ads_missing
def list_marketplaces(self):
return [{"code": c, "name": n, "enabled": True, "include_in_sales": True}
for c, n in (("cafe24", "카페24"), ("naver", "네이버 스마트스토어"), ("coupang", "쿠팡"))]
def daily_amounts(self, start, end, codes):
rows = {(date(2026, 10, 5), "cafe24"): 2_000_000, (date(2026, 10, 5), "coupang"): 600_000,
(date(2026, 10, 6), "naver"): 1_234_567}
return {k: v for k, v in rows.items() if start <= k[0] <= end and k[1] in codes}
def rate_table(self):
return {}
def statuses(self):
return {}
def last_update_at(self):
return None
def running_codes(self):
return []
def ad_amounts(self, start, end):
if self.ads_missing:
raise RuntimeError("perf_ad_spend 없음")
rows = {(date(2026, 10, 5), "google"): 100_000, (date(2026, 10, 5), "meta"): 50_000,
(date(2026, 10, 5), "coupang_wing"): 200_000, (date(2026, 10, 6), "naver"): 300_000}
rows = {k: v for k, v in rows.items() if start <= k[0] <= end}
return rows, {k: "manual" for k in rows}
def ad_roas(self, start, end):
rows = {(date(2026, 10, 5), "google"): 412.5, (date(2026, 10, 6), "naver"): 150}
return {k: v for k, v in rows.items() if start <= k[0] <= end}
def test_sales_ad_channels_mapping():
m = dashboard.sales_ad_channels()
assert m["cafe24"] == (("google", "구글"), ("meta", "메타"))
assert m["naver"] == (("naver", ""),) and m["coupang"] == (("coupang_wing", ""),)
assert m["coupang_rocket"] == (("coupang_rocket", ""),) and "google" not in m
def test_ad_lines_under_sales_cells():
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY)
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
# 카페24 = 구글·메타 두 줄, ROAS 는 광고 보고서 값(구글 412.5 → 413), 메타는 보고서 ROAS 없음
assert day5["ads"]["cafe24"] == [{"label": "구글", "amount": 100_000, "roas": 413},
{"label": "메타", "amount": 50_000, "roas": None}]
# 쿠팡 = 쿠팡(윙) 광고비, ROAS = 쿠팡 매출 ÷ 광고비 = 600,000 ÷ 200,000
assert day5["ads"]["coupang"] == [{"label": "", "amount": 200_000, "roas": 300}]
assert "naver" not in day5["ads"] # 그날 네이버 광고비 없음 → 줄 없음
# 일 합계 = 보이는 쇼핑몰 광고비 합, ROAS = 일 합계 금액 ÷ 일 합계 광고비(총매출·수수료 차감 매출 두 기준, 2026-10-19)
assert day5["ads_total"] == {"amount": 350_000, "roas": 743, "roas_net": 743} # 2,600,000 ÷ 350,000(수수료율 없음)
day6 = next(r for r in ctx["table"] if r.get("date") == "2026-10-06")
assert day6["ads"]["naver"] == [{"label": "", "amount": 300_000, "roas": 150}]
week = next(r for r in ctx["table"] if r["kind"] == "week")
assert [a["amount"] for a in week["ads"]["cafe24"]] == [100_000, 50_000] and week["ads_total"]["amount"] == 650_000
day1 = next(r for r in ctx["table"] if r.get("date") == "2026-10-07")
assert day1["ads"] == {} and day1["ads_total"] is None
def test_ad_lines_follow_shop_filter_and_missing_table():
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY, selected=["coupang"])
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert list(day5["ads"]) == ["coupang"] and day5["ads_total"] == {"amount": 200_000, "roas": 300, "roas_net": 300}
ctx = dashboard.build_dashboard(_Store(ads_missing=True), kind="week", anchor=TODAY, today=TODAY)
assert all(r["ads"] == {} and r["ads_total"] is None for r in ctx["table"]) # 광고비 표 없어도 매출 화면은 그대로
def test_amount_text_units():
assert dashboard.amount_text(2_475_300) == "2,475,300"
assert dashboard.amount_text(2_475_300, "thousand") == "2,475"
assert dashboard.amount_text(2_475_500, "thousand") == "2,476"
assert dashboard.amount_text(2_475_300, "million") == "2.5"
assert dashboard.amount_text(158_000, "million") == "0.2"
assert dashboard.amount_text(-158_000, "thousand") == "-158"
assert dashboard.amount_text(1_234_567_890, "million") == "1,234.6"
assert dashboard.amount_text(5, "nope") == "5" and dashboard.normalize_unit("x") == "won"
def test_dashboard_page_renders_unit_and_ad_lines(monkeypatch):
import importlib
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.modules.performance import common
perf_router = importlib.import_module("app.modules.performance.router")
class _Creds:
def configured_codes(self, adapters):
return {}
store = _Store()
monkeypatch.setattr(common, "guard", lambda request, admin=False: (store, {"email": "king@x", "name": "King", "is_admin": True}))
monkeypatch.setattr(common, "services", lambda request, st: (_Creds(), None))
monkeypatch.setattr(perf_router, "today_kst", lambda: TODAY)
app = FastAPI()
app.include_router(perf_router.router)
client = TestClient(app)
html = client.get("/performance/?period=week&d=2026-10-07").text
assert "2,000,000" in html
assert 'class="perf-adl"' in html and "<i>구글</i>100,000<em>(413%)</em>" in html and "<i>메타</i>50,000" in html
assert "200,000<em>(300%)</em>" in html and "단위:" not in html
client.cookies.set("perf_unit", "thousand")
html = client.get("/performance/?period=week&d=2026-10-07").text
assert "단위: 천원" in html and "2,000<" in html and "<i>구글</i>100<em>(413%)</em>" in html
assert "2,000,000<" not in html.split("perf-main", 1)[1].split("</table>", 1)[0]
client.cookies.set("perf_unit", "million")
html = client.get("/performance/?period=week&d=2026-10-07").text
assert "단위: 백만원" in html and ">2.0<" in html and '"unit": "million"' in html
def test_total_roas_uses_whole_day_total():
"""일 합계 ROAS = 그날 일 합계 금액(광고비 없는 쇼핑몰 매출 포함) ÷ 일 합계 광고비 — 예전엔 광고비 있는 쇼핑몰 매출만 더했다."""
class _S(_Store):
def ad_amounts(self, start, end):
rows = {(date(2026, 10, 5), "google"): 100_000}
rows = {k: v for k, v in rows.items() if start <= k[0] <= end}
return rows, {k: "manual" for k in rows}
def ad_roas(self, start, end):
return {}
ctx = dashboard.build_dashboard(_S(), kind="week", anchor=TODAY, today=TODAY)
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert day5["total"]["gross"] == 2_600_000 # 카페24 2,000,000 + 쿠팡 600,000(광고비 없음)
assert day5["ads_total"] == {"amount": 100_000, "roas": 2600, "roas_net": 2600}
def test_kpi_is_net_only():
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY)
assert [k["key"] for k in ctx["kpis"]] == ["net"]
assert ctx["kpis"][0]["value"] == 2_600_000 + 1_234_567
@@ -306,7 +306,9 @@ def test_sync_endpoint(monkeypatch):
assert r.status_code == 403 # 92일 넘으면 관리자만
admin["v"] = True
assert client.post("/performance/api/ad-sources/google/sync", json={"from": "2026-01-01", "to": "2026-10-15"}).status_code == 200
assert client.post("/performance/api/ad-sources/meta/sync", json={}).status_code == 404
assert client.post("/performance/api/ad-sources/kakao/sync", json={}).status_code == 404 # 광고 API 연동이 없는 채널
r = client.post("/performance/api/ad-sources/meta/sync", json={}) # 메타(2026-10-16) — 연동은 있으나 미설정
assert r.status_code == 400 and "설정되지 않았습니다" in r.json()["detail"]
svc.result = {"ok": False, "code": "google", "name": "구글 광고", "status": "auth_failed", "message": "권한 없음"}
r = client.post("/performance/api/ad-sources/google/sync", json={})
assert r.status_code == 502 and "권한 없음" in r.json()["detail"]
@@ -0,0 +1,501 @@
"""메타 광고 API 연동(2026-10-16) — 입력 검사·요청 매개변수·여러 계정 합산·쪽 넘김·구매 값·부가세·ROAS·오류 안내·저장 서비스.
메타 서버는 가짜(httpx MockTransport)."""
from __future__ import annotations
import hashlib
import hmac
import json
from datetime import date
from decimal import Decimal
import httpx
import pytest
from app.modules.performance import ad_spend, ad_sync
from app.modules.performance.ad_sources import meta_ads as ma
from app.modules.performance.ad_sources.registry import get_source
from app.modules.performance.adapters.base import AdapterContext, ApiError, AuthFailed, NotConfigured, TokenExpired
from app.modules.performance.credentials import CredentialService
TOKEN = "EAAGtesttoken0123456789abcdefSECRET"
class Creds:
def __init__(self, values):
self.values = values
def get(self, key):
return self.values.get(key, "")
def has(self, key):
return bool(self.values.get(key))
def set(self, key, value):
self.values[key] = value
def known_secrets(self):
return [v for k, v in self.values.items() if v and k in ("access_token", "app_secret")]
def _ctx(**over):
values = {"account_ids": "act_1111111111\n2222222222", "access_token": TOKEN}
values.update(over)
return AdapterContext(code="meta", credentials=Creds(values))
def _install(monkeypatch, handler):
"""가짜 메타 서버 — handler(request) 가 응답을 만든다. 보낸 요청을 돌려준다."""
seen = []
def route(request: httpx.Request) -> httpx.Response:
seen.append(request)
return handler(request)
monkeypatch.setattr(ma, "_http", lambda ctx: httpx.Client(transport=httpx.MockTransport(route)))
return seen
def _row(day, spend, **extra):
r = {"date_start": day, "date_stop": day, "account_currency": "KRW", "spend": spend}
r.update(extra)
return r
# 계정 1: 두 쪽(paging.next), 계정 2: 한 쪽. 10-01 은 두 계정 모두 있음 → 날짜별 합산.
PAGE1 = {"data": [_row("2026-10-01", "100000", account_name="본계정", impressions="20000", clicks="400", inline_link_clicks="300",
actions=[{"action_type": "omni_purchase", "value": "10"}, {"action_type": "purchase", "value": "10"},
{"action_type": "offsite_conversion.fb_pixel_purchase", "value": "10"},
{"action_type": "link_click", "value": "300"}],
action_values=[{"action_type": "omni_purchase", "value": "450000"},
{"action_type": "purchase", "value": "450000"},
{"action_type": "offsite_conversion.fb_pixel_purchase", "value": "450000"}])],
"paging": {"next": "https://graph.facebook.com/v26.0/act_1111111111/insights?after=CUR&access_token=" + TOKEN}}
PAGE2 = {"data": [_row("2026-10-02", "0", impressions="10")], "paging": {}}
ACC2 = {"data": [_row("2026-10-01", "50000.5", account_name="서브계정", impressions="5000", clicks="100", inline_link_clicks="80",
actions=[{"action_type": "offsite_conversion.fb_pixel_purchase", "value": "2"}],
action_values=[{"action_type": "offsite_conversion.fb_pixel_purchase", "value": "150000"}])]}
def _insights_server(request: httpx.Request) -> httpx.Response:
path, q = request.url.path, request.url.params
if path == "/v26.0/act_1111111111/insights":
return httpx.Response(200, json=PAGE2 if q.get("after") == "CUR" else PAGE1)
if path == "/v26.0/act_2222222222/insights":
return httpx.Response(200, json=ACC2)
return httpx.Response(404, json={"error": {"message": "unknown path", "code": 100}})
def test_registered_and_detail_channel():
assert get_source("meta").name == "메타 광고"
assert "meta" in ad_spend.DETAIL_CHANNELS and "meta" in ad_spend.FILE_ROAS # 머리글 → 일자별 표, ROAS 는 광고 쪽 값
def test_parse_account_ids():
assert ma.parse_account_ids("act_123456, 654321\n\nACT_123456;777777") == ["123456", "654321", "777777"]
assert ma.parse_account_ids("") == []
for bad in ("act_abc", "12-34", "act_"):
with pytest.raises(ValueError):
ma.parse_account_ids(bad)
with pytest.raises(ValueError):
ma.parse_account_ids(",".join(str(100000 + i) for i in range(ma.MAX_ACCOUNTS + 1)))
def test_validate_credentials():
src = ma.MetaAdsSource()
ok = {"account_ids": "act_1111111111", "access_token": TOKEN}
assert src.validate_credentials(ok) == []
assert src.validate_credentials({**ok, "access_token": "__stored__"}) == []
assert {f.key for f in src.visible_fields()} == {"account_ids", "access_token", "app_secret", "api_version"}
assert {f.key for f in src.visible_fields() if f.secret} == {"access_token", "app_secret"}
errs = src.validate_credentials({"account_ids": "act_x", "access_token": "short token", "api_version": "26"})
assert len(errs) == 3 and not any("short token" in e for e in errs) # 토큰 값은 문구에 없음
assert "입력하세요" in " ".join(src.validate_credentials({}))
def test_fetch_days_sums_accounts_pages_and_converts(monkeypatch):
seen = _install(monkeypatch, _insights_server)
days = ma.MetaAdsSource().fetch_days(_ctx(), date(2026, 10, 1), date(2026, 10, 2))
first = seen[0]
assert first.url.path == "/v26.0/act_1111111111/insights"
q = first.url.params
assert q["access_token"] == TOKEN and "appsecret_proof" not in q
assert (q["level"], q["time_increment"]) == ("account", "1")
assert json.loads(q["time_range"]) == {"since": "2026-10-01", "until": "2026-10-02"}
assert {"spend", "action_values", "actions", "account_currency", "date_start"} <= set(q["fields"].split(","))
assert [r.url.params.get("after") for r in seen] == [None, "CUR", None] # 계정 1 두 쪽 → 계정 2
d1, d2 = days
# 10-01: 지출 100,000 + 50,000.5 = 150,000.5 → 광고비 = 지출 그대로(메타는 부가세 포함, 2026-10-16) → 150,001
# 구매 전환값 = 계정1 omni_purchase 450,000(겹친 purchase·픽셀 값은 더하지 않음) + 계정2 픽셀 150,000 = 600,000
# ROAS = 600,000 ÷ 150,000.5 × 100 = 399.998... → 400.00
assert (d1.day, d1.amount, d1.roas) == (date(2026, 10, 1), 150001, Decimal("400.00"))
total_metrics = {k: v for k, v in d1.metrics.items() if k != "_accounts"}
assert total_metrics == {"지출 금액(부가세 포함)": 150001, "노출수": 25000, "클릭수": 500,
"클릭률(%)": 2.0, "링크 클릭": 380, "구매수": 12, "구매 전환값": 600000, "ROAS(%)": 400.0}
assert list(d1.metrics)[0] == "지출 금액(부가세 포함)" # 일자별 표 첫 열(× 1.1 없음 — 부가세 별도 열도 없음)
assert (d2.day, d2.amount, d2.roas, d2.metrics["클릭률(%)"]) == (date(2026, 10, 2), 0, None, 0.0) # 지출 0 → ROAS 없음
# 계정별(상세보기 탭, 2026-10-16) — 계정마다 따로 변환. 이름은 insights 의 account_name(없는 쪽은 같은 계정 앞 줄 이름)
a1, a2 = d1.metrics["_accounts"]["1111111111"], d1.metrics["_accounts"]["2222222222"]
assert (a1["name"], a1["amount"], a1["roas"]) == ("본계정", 100000, 450.0) # 지출 그대로, 450,000 ÷ 100,000
assert (a2["name"], a2["amount"], a2["roas"]) == ("서브계정", 50001, 300.0) # 50,000.5 → 50,001, 150,000 ÷ 50,000.5 = 299.997 → 300.00
assert a1["metrics"]["구매수"] == 10 and a2["metrics"]["구매 전환값"] == 150000 and a2["metrics"]["링크 클릭"] == 80
assert list(d2.metrics["_accounts"]) == ["1111111111"] and d2.metrics["_accounts"]["1111111111"]["name"] == "본계정"
assert "account_name" in seen[0].url.params["fields"].split(",")
def test_app_secret_proof_and_version(monkeypatch):
seen = _install(monkeypatch, lambda req: httpx.Response(200, json={"data": []}))
out = ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333", app_secret="appsecret", api_version="v27.0"),
date(2026, 10, 1), date(2026, 10, 1))
assert out == []
assert seen[0].url.path == "/v27.0/act_333333/insights"
expected = hmac.new(b"appsecret", TOKEN.encode(), hashlib.sha256).hexdigest()
assert seen[0].url.params["appsecret_proof"] == expected
def test_limits(monkeypatch):
_install(monkeypatch, lambda req: httpx.Response(200, json={"data": []}))
with pytest.raises(ApiError, match="366"):
ma.MetaAdsSource().fetch_days(_ctx(), date(2025, 1, 1), date(2026, 10, 1))
with pytest.raises(NotConfigured):
ma.MetaAdsSource().fetch_days(_ctx(access_token=""), date(2026, 10, 1), date(2026, 10, 1))
# 다음 쪽 주소가 메타가 아니면 따라가지 않는다(토큰을 다른 곳에 보내지 않게)
_install(monkeypatch, lambda req: httpx.Response(200, json={"data": [], "paging": {"next": "https://evil.example/x"}}))
with pytest.raises(ApiError, match="다음 쪽"):
ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333"), date(2026, 10, 1), date(2026, 10, 1))
@pytest.mark.parametrize("code,status,exc,hint", [
(190, 400, TokenExpired, "시스템 사용자"),
(200, 403, AuthFailed, "ads_read"),
(100, 400, ApiError, "광고 계정 ID"),
(17, 400, ApiError, "호출 한도"),
(80004, 403, ApiError, "호출 한도"), # 403 이어도 호출 한도는 인증 실패가 아님
])
def test_errors_are_explained(monkeypatch, code, status, exc, hint):
_install(monkeypatch, lambda req: httpx.Response(status, json={"error": {"message": "meta says no", "code": code}}))
with pytest.raises(exc) as info:
ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333"), date(2026, 10, 1), date(2026, 10, 1))
assert hint in str(info.value) and f"({code})" in str(info.value) and TOKEN not in str(info.value)
def test_network_error_has_no_token(monkeypatch):
def boom(req):
raise httpx.ConnectError("connect failed for " + str(req.url))
_install(monkeypatch, boom)
with pytest.raises(ApiError) as info:
ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333"), date(2026, 10, 1), date(2026, 10, 1))
assert "ConnectError" in str(info.value) and TOKEN not in str(info.value)
def test_connection_message(monkeypatch):
accounts = {"/v26.0/act_1111111111": {"name": "본계정", "currency": "KRW", "timezone_name": "Asia/Seoul", "account_status": 1},
"/v26.0/act_2222222222": {"name": "해외", "currency": "USD", "timezone_name": "America/Los_Angeles", "account_status": 2}}
seen = _install(monkeypatch, lambda req: httpx.Response(200, json=accounts[req.url.path]))
msg = ma.MetaAdsSource().test_connection(_ctx())
assert "광고 계정 2개" in msg and "본계정(KRW·Asia/Seoul·운영 중)" in msg and "해외(USD" in msg and "사용 중지" in msg
assert "원화가 아닌 계정" in msg
assert seen[0].url.params["fields"] == "name,currency,timezone_name,account_status"
class FakeStore:
def __init__(self):
self.replaced, self.status = [], []
def replace_ad_api_range(self, code, start, end, days, *, user=""):
self.replaced.append((code, start, end, days, user))
return len(days)
def record_ad_status(self, code, *, status, ok, error="", kind="test"):
self.status.append((code, status, ok, error, kind))
def test_sync_service_end_to_end(monkeypatch):
"""실제 MetaAdsSource.fetch_days → AdSyncService 저장·상태. 실패 문구에서 토큰은 가린다."""
_install(monkeypatch, _insights_server)
store = FakeStore()
svc = ad_sync.AdSyncService(store, CredentialService(None, lambda: None))
svc._ctx = lambda code, values=None, user="", cleared=None: _ctx()
res = svc.sync("meta", date(2026, 10, 1), date(2026, 10, 2), user="king@x")
assert res["ok"] and res["days"] == 2 and res["total"] == 150001 and res["name"] == "메타 광고"
code, start, end, days, user = store.replaced[0]
assert (code, start, end, user) == ("meta", date(2026, 10, 1), date(2026, 10, 2), "king@x")
assert [(d, amt, roas) for d, amt, roas, _m in days] == [(date(2026, 10, 1), 150001, Decimal("400.00")),
(date(2026, 10, 2), 0, None)]
assert store.status[-1] == ("meta", "ok", True, "", "sync")
# 메타가 오류 문구에 토큰을 되돌려 줘도 저장·화면 문구에서는 가린다
_install(monkeypatch, lambda req: httpx.Response(400, json={"error": {"message": "bad token " + TOKEN, "code": 190}}))
res = svc.sync("meta", date(2026, 10, 1), date(2026, 10, 1))
assert not res["ok"] and res["status"] == "token_expired" and TOKEN not in res["message"]
assert len(store.replaced) == 1 and store.status[-1][1:3] == ("token_expired", False) and TOKEN not in store.status[-1][3]
# ── 권한 오류(#200) 진단 — 연결 테스트가 메타에 토큰 정보를 물어 원인 하나를 짚는다(2026-10-16) ──
DENIED = {"error": {"message": "(#200) Ad account owner has NOT grant ads_management or ads_read permission", "code": 200}}
def _diag_server(debug=None, perms=None, adaccounts=None):
"""debug/perms/adaccounts = 응답 dict, None 이면 그 조회도 실패(권한 오류)."""
def handler(req: httpx.Request) -> httpx.Response:
path = req.url.path
if path.endswith("/debug_token"):
assert req.url.params["input_token"] == TOKEN
return httpx.Response(200, json=debug) if debug is not None else httpx.Response(400, json=DENIED)
if path.endswith("/me/permissions"):
return httpx.Response(200, json=perms) if perms is not None else httpx.Response(400, json=DENIED)
if path.endswith("/me/adaccounts"):
return httpx.Response(200, json=adaccounts) if adaccounts is not None else httpx.Response(400, json=DENIED)
return httpx.Response(400, json=DENIED) # 광고 계정 조회 = 권한 오류
return handler
def _diag(monkeypatch, **server):
_install(monkeypatch, _diag_server(**server))
with pytest.raises(AuthFailed) as info:
ma.MetaAdsSource().test_connection(_ctx(account_ids="1111111111,2222222222"))
msg = str(info.value)
assert "(#200)" in msg and "[진단]" in msg and TOKEN not in msg
return msg
def _debug(scopes, granular=None, exp=0):
return {"data": {"app_id": "777", "application": "DBX ERP", "is_valid": True, "expires_at": exp,
"scopes": scopes, "granular_scopes": granular or []}}
ALL_VISIBLE = {"data": [{"account_id": "1111111111"}, {"account_id": "2222222222"}]}
def test_diagnose_missing_ads_read(monkeypatch):
msg = _diag(monkeypatch, debug=_debug(["public_profile", "business_management"]), adaccounts=ALL_VISIBLE)
assert "광고 권한: 없음" in msg and "ads_read 권한이 없습니다" in msg and "DBX ERP(777)" in msg and "만료 없음" in msg
def test_diagnose_account_not_assigned(monkeypatch):
msg = _diag(monkeypatch, debug=_debug(["ads_read"]), adaccounts={"data": [{"account_id": "1111111111"}]})
assert "광고 권한: ads_read" in msg and "보이는 광고 계정 1개" in msg
assert "배정되지 않은 계정: act_2222222222" in msg and "act_1111111111" not in msg.split("배정되지 않은 계정")[1].split("→")[0]
assert "자산 할당" in msg
def test_diagnose_scope_targets_other_accounts(monkeypatch):
granular = [{"scope": "ads_read", "target_ids": ["1111111111"]}]
msg = _diag(monkeypatch, debug=_debug(["ads_read"], granular), adaccounts=ALL_VISIBLE)
assert "다른 계정에만" in msg and "act_2222222222" in msg
def test_diagnose_points_to_app_when_token_and_accounts_ok(monkeypatch):
msg = _diag(monkeypatch, debug=_debug(["ads_read", "ads_management"]), adaccounts=ALL_VISIBLE)
assert "광고 권한: ads_management, ads_read" in msg and "앱 쪽 문제" in msg
def test_diagnose_falls_back_to_permissions(monkeypatch):
perms = {"data": [{"permission": "ads_read", "status": "declined"}, {"permission": "public_profile", "status": "granted"}]}
msg = _diag(monkeypatch, debug=None, perms=perms, adaccounts=None)
assert "광고 권한: 없음" in msg and "ads_read 권한이 없습니다" in msg # 거절(declined)은 받은 권한이 아님
def test_diagnose_unknown_when_meta_says_nothing(monkeypatch):
msg = _diag(monkeypatch, debug=None, perms=None, adaccounts=None)
assert "원인을 좁히지 못했습니다" in msg
def test_diag_hint_only_outside_connection_test(monkeypatch):
"""불러오기(fetch_days) 권한 오류엔 '연결 테스트가 진단' 안내, 연결 테스트 자체엔 그 안내 대신 진단 결과."""
_install(monkeypatch, _diag_server(debug=_debug(["ads_read"]), adaccounts=ALL_VISIBLE))
with pytest.raises(AuthFailed) as info:
ma.MetaAdsSource().fetch_days(_ctx(account_ids="1111111111"), date(2026, 10, 1), date(2026, 10, 1))
assert ma._DIAG_HINT in str(info.value) and "[진단]" not in str(info.value)
msg = _diag(monkeypatch, debug=_debug(["ads_read"]), adaccounts=ALL_VISIBLE)
assert ma._DIAG_HINT not in msg
def test_connection_test_shows_full_diagnosis_first(monkeypatch):
"""설정 [연결 테스트](AdSyncService) 문구 — 진단이 맨 앞, 잘리지 않음, 메타 원문의 긴 주소는 뺌(2026-10-16 "[진…" 잘림)."""
long_denied = {"error": {"code": 200, "message": "(#200) Ad account owner has NOT grant ads_management or ads_read permission, "
"refer to https://developers.facebook.com/docs/marketing-api/get-started/authorization/"
"#permissions-and-features for details"}}
def handler(req):
if req.url.path.endswith("/debug_token"):
return httpx.Response(200, json=_debug(["ads_read"]))
if req.url.path.endswith("/me/adaccounts"):
return httpx.Response(200, json={"data": []})
return httpx.Response(400, json=long_denied)
_install(monkeypatch, handler)
store = FakeStore()
svc = ad_sync.AdSyncService(store, CredentialService(None, lambda: None))
svc._ctx = lambda code, values=None, user="", cleared=None: _ctx(account_ids="1111111111,2222222222")
res = svc.test_connection("meta")
msg = res["message"]
assert not res["ok"] and res["status"] == "auth_failed"
assert msg.startswith("[진단]") and not msg.endswith("…") and len(msg) > 300 # 예전 300자 한도면 잘렸을 길이
assert "배정되지 않은 계정: act_1111111111, act_2222222222" in msg and "자산 할당" in msg
assert "(메타 원문: 메타 API 오류(200): (#200) Ad account owner has NOT grant" in msg
assert "https://" not in msg and ma._DIAG_HINT not in msg and TOKEN not in msg
# ── 상세보기 [합계 | 계정…] 탭(2026-10-16) ──
def _stored(day, amount, roas, metrics):
"""저장소 ad_details 행 모양."""
return {"date": day, "amount": amount, "roas": roas, "metrics": metrics, "source": "api"}
def test_detail_tabs_total_and_accounts():
def acc(name, amount, roas, spend_metric):
return {"name": name, "amount": amount, "roas": roas,
"metrics": {"지출 금액(부가세 포함)": amount, "노출수": spend_metric, "클릭수": spend_metric // 100, "클릭률(%)": 1.0,
"ROAS(%)": roas}}
rows = [
_stored("2026-10-01", 300, 200.0, {"지출 금액(부가세 포함)": 300, "노출수": 3000, "클릭수": 30, "클릭률(%)": 1.0, "ROAS(%)": 200.0,
"_accounts": {"1": acc("작은계정", 100, 100.0, 1000), "2": acc("큰계정", 200, 250.0, 2000)}}),
_stored("2026-10-02", 500, 300.0, {"지출 금액(부가세 포함)": 500, "노출수": 5000, "클릭수": 50, "클릭률(%)": 1.0, "ROAS(%)": 300.0,
"_accounts": {"2": acc("큰계정(새 이름)", 500, 300.0, 5000)}}),
_stored("2026-10-03", 70, None, {"지출 금액(부가세 포함)": 70}), # 계정별 저장 전에 가져온 날
]
t = ad_spend.detail_table(rows)
assert "_accounts" not in t["columns"] and "_accounts" not in t["total"] # "_" 키는 표 열·합계에 없음
assert all("_accounts" not in r["values"] for r in t["rows"]) # 화면으로도 보내지 않음
out = ad_spend.detail_tabs(rows)
tabs = out["tabs"]
assert [x["key"] for x in tabs] == ["total", "2", "1"] # 합계 → 광고비 큰 계정부터
assert [x["label"] for x in tabs] == ["합계", "큰계정(새 이름)", "작은계정"] # 이름 = 최근 날 이름
assert tabs[0]["total"] == t["total"] and len(tabs[0]["rows"]) == 3
big = tabs[1]
assert big["account_id"] == "2" and [r["date"] for r in big["rows"]] == ["2026-10-01", "2026-10-02"]
assert big["total"]["지출 금액(부가세 포함)"] == 700 and big["total"]["노출수"] == 7000
assert big["total"]["ROAS(%)"] == round((200 * 250 + 500 * 300) / 700, 2) # 광고비 가중 평균
assert [r["date"] for r in tabs[2]["rows"]] == ["2026-10-01"] # 광고를 낸 날만
assert out["accounts_missing"] == 1
def test_detail_tabs_absent_without_accounts():
rows = [_stored("2026-10-01", 100, 150.0, {"지출 금액(부가세 포함)": 100, "ROAS(%)": 150.0})]
assert ad_spend.detail_tabs(rows) == {"tabs": [], "accounts_missing": 0} # 네이버·구글·옛 메타 자료 = 탭 없음
def test_details_endpoint_returns_tabs(monkeypatch):
import importlib
from fastapi import FastAPI
from fastapi.testclient import TestClient
from app.modules.performance import common
perf_router = importlib.import_module("app.modules.performance.router")
rows = [_stored("2026-10-01", 110, 450.0, {"지출 금액(부가세 포함)": 110, "_accounts": {
"1": {"name": "본계정", "amount": 110, "roas": 450.0, "metrics": {"지출 금액(부가세 포함)": 110}}}})]
class Store:
def ad_details(self, code, start, end):
assert code == "meta"
return rows
monkeypatch.setattr(common, "require_store", lambda request: (Store(), {"email": "a@x"}))
app = FastAPI()
app.include_router(perf_router.router)
d = TestClient(app).get("/performance/api/ad-spend/meta/details?from=2026-10-01&to=2026-10-31").json()
assert d["columns"] == ["지출 금액(부가세 포함)"] and [t["label"] for t in d["tabs"]] == ["합계", "본계정"]
assert d["accounts_missing"] == 0
# ── 외화(USD) 광고 계정 — 그날 환율로 원화 환산(2026-10-16) ──
from app.modules.performance import fx # noqa: E402
FX_ROWS = [{"date": "2026-10-01", "base": "USD", "quote": "KRW", "rate": 1350.0},
{"date": "2026-10-02", "base": "USD", "quote": "KRW", "rate": 1360.5}] # 10-03 은 없음 → 10-02 값
def _fx_and_meta(insights_by_account, fx_rows=FX_ROWS, fx_status=200):
calls = {"fx": []}
def handler(req: httpx.Request) -> httpx.Response:
if req.url.host == "api.frankfurter.dev":
calls["fx"].append(req)
return httpx.Response(fx_status, json=fx_rows if fx_status == 200 else {"status": fx_status, "message": "down"})
acc = req.url.path.split("/act_")[1].split("/")[0]
return httpx.Response(200, json={"data": insights_by_account.get(acc, [])})
return handler, calls
def _usd(day, spend, value, **extra):
return {**_row(day, spend, account_currency="USD", account_name="US 계정",
action_values=[{"action_type": "omni_purchase", "value": value}]), **extra}
def test_usd_account_converted_with_daily_rate(monkeypatch):
fx.clear_cache()
handler, calls = _fx_and_meta({
"333333": [_usd("2026-10-01", "100", "400"), _usd("2026-10-03", "10.5", "0")],
"444444": [_row("2026-10-01", "50000", account_name="원화 계정")],
})
_install(monkeypatch, handler)
d1, d3 = ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333,444444"), date(2026, 10, 1), date(2026, 10, 3))
q = calls["fx"][0].url.params
assert (q["base"], q["quotes"], q["to"]) == ("USD", "KRW", "2026-10-03") and q["from"] <= "2026-10-01"
assert len(calls["fx"]) == 1 # 통화마다 기간 한 번
# 10-01: USD 100 × 1,350 = 135,000원 + 원화 50,000 = 185,000 = 광고비(메타 지출은 부가세 포함 — × 1.1 없음)
# 구매 전환값 USD 400 × 1,350 = 540,000 → ROAS = 540,000 ÷ 185,000 = 291.89%
assert (d1.amount, d1.roas) == (185000, Decimal("291.89"))
assert d1.metrics["지출 금액(부가세 포함)"] == 185000 and d1.metrics["구매 전환값"] == 540000
us = d1.metrics["_accounts"]["333333"]
assert (us["amount"], us["roas"]) == (135000, 400.0) # 100 × 1,350, ROAS 는 환율과 무관(400 ÷ 100)
assert us["metrics"]["지출 금액(USD)"] == 100.0 and us["metrics"]["적용 환율(원)"] == 1350.0
assert "적용 환율(원)" not in d1.metrics["_accounts"]["444444"]["metrics"] # 원화 계정엔 없음
assert "적용 환율(원)" not in d1.metrics # 합계 표에도 없음
# 10-03: 그날 환율 없음 → 10-02 값(1,360.5). 10.5 × 1,360.5 = 14,285.25 → 14,285
assert d3.day == date(2026, 10, 3) and d3.amount == 14285
assert d3.metrics["_accounts"]["333333"]["metrics"]["적용 환율(원)"] == 1360.5
def test_usd_rate_unavailable_saves_nothing(monkeypatch):
fx.clear_cache()
handler, _calls = _fx_and_meta({"333333": [_usd("2026-10-01", "100", "0")]}, fx_status=503)
_install(monkeypatch, handler)
with pytest.raises(ApiError) as info:
ma.MetaAdsSource().fetch_days(_ctx(account_ids="333333"), date(2026, 10, 1), date(2026, 10, 1))
assert "USD 광고 계정을 원화로 바꿀 환율" in str(info.value) and "503" in str(info.value) and TOKEN not in str(info.value)
def test_krw_rates_fill_cache_and_errors():
fx.clear_cache()
seen = []
def route(req):
seen.append(req)
return httpx.Response(200, json=FX_ROWS + [{"date": "x", "quote": "KRW", "rate": 1}, {"date": "2026-10-02", "quote": "JPY", "rate": 9}])
client = httpx.Client(transport=httpx.MockTransport(route))
rates = fx.krw_rates(client, "usd", date(2026, 10, 1), date(2026, 10, 4), today=date(2026, 10, 10))
assert rates == {date(2026, 10, 1): Decimal("1350.0"), date(2026, 10, 2): Decimal("1360.5"),
date(2026, 10, 3): Decimal("1360.5"), date(2026, 10, 4): Decimal("1360.5")} # 빈 날 = 앞 날 값
# 실제로 고시된 지난 날(10-01·10-02)만 기억 — 그 두 날만 다시 물으면 서버에 묻지 않는다
assert fx.krw_rates(client, "USD", date(2026, 10, 1), date(2026, 10, 2), today=date(2026, 10, 10))[date(2026, 10, 2)] == Decimal("1360.5")
assert len(seen) == 1
fx.krw_rates(client, "USD", date(2026, 10, 1), date(2026, 10, 3), today=date(2026, 10, 10)) # 10-03 은 앞 날 값이라 기억 안 함
assert len(seen) == 2
assert fx.krw_rates(client, "KRW", date(2026, 10, 1), date(2026, 10, 2)) == {date(2026, 10, 1): 1, date(2026, 10, 2): 1}
with pytest.raises(fx.FxError, match="찾지 못했습니다"): # 앞 열흘에도 없음
fx.krw_rates(client, "USD", date(2026, 11, 1), date(2026, 11, 1), today=date(2026, 11, 5))
def down(req):
raise httpx.ConnectError("boom")
with pytest.raises(fx.FxError, match="ConnectError"):
fx.krw_rates(httpx.Client(transport=httpx.MockTransport(down)), "EUR", date(2026, 10, 1), date(2026, 10, 1))
def test_detail_table_rate_total_is_weighted_average():
rows = [_stored("2026-10-01", 1000, None, {"적용 환율(원)": 1300.0}),
_stored("2026-10-02", 3000, None, {"적용 환율(원)": 1400.0}),
_stored("2026-10-03", 0, None, {"적용 환율(원)": 9999.0})] # 광고비 0 인 날은 빼고
assert ad_spend.detail_table(rows)["total"]["적용 환율(원)"] == 1375.0 # (1300×1000 + 1400×3000) ÷ 4000
def test_connection_mentions_conversion(monkeypatch):
_install(monkeypatch, lambda req: httpx.Response(200, json={"name": "US", "currency": "USD", "timezone_name": "America/Los_Angeles",
"account_status": 1}))
msg = ma.MetaAdsSource().test_connection(_ctx(account_ids="333333"))
assert "그날 환율로 원화로 바꿔 넣습니다" in msg and "가져올 수 없습니다" not in msg
@@ -909,7 +909,7 @@ def test_cafe24_refund_total_includes_points_and_naverpay_cancels():
finally:
_tz.today_kst = orig
by = {e.external_event_id: e for e in events if e.event_type != "SALE"}
assert by["c24:C20260926-01"].amount == -(63_720 + 1_080) # 적립금 환불 포함
assert by["c24:C20260926-01"].amount == -63_720 # 적립금 환불(1,080)은 뺀다(2026-10-19 — 매출도 적립금 제외)
assert by["c24:NP1-01-CL"].amount == -55_800 and by["c24:NP1-01-CL"].event_type == "CANCEL"
assert by["c24:NP1-01-CL"].event_date == date(2026, 9, 26) and by["c24:NP1-01-CL"].marketplace_code == "cafe24"
assert by["c24:NP2-01-CL"].amount == -(40_000 - 1_000 + 3_000) # 판매가×수량 − 품목 쿠폰 + 전체취소 배송비
@@ -975,7 +975,8 @@ def test_cafe24_paid_total_matches_daily_report():
o["initial_order_amount"].update(payment_amount="42938.00", points_spent_amount="1000.00")
assert order_total(o) == 42_938 + 1_000 + 3_000 == 46_938
ev = _FakeCafe24([]).normalize_order(o)[0]
assert ev.amount == 46_938 and ev.discount_amount == 1_000 + 5_000
assert ev.amount == 46_938 - 1_000 and ev.discount_amount == 1_000 + 5_000 # 매출 = 결제합계 − 적립금(2026-10-19)
assert ev.raw["points"] == 1_000 and ev.raw["points_excluded"]
o["actual_order_amount"] = {**o["initial_order_amount"], "payment_amount": "20000.00"}
assert order_total_now(o) == 20_000 + 1_000 + 3_000
z = _c24_order("Z")
@@ -1509,7 +1510,16 @@ def test_naver_collect_sales():
}
calls = []
refunds = { # 클레임 완료일 기준 조회 — 9/10 에 B1(9/9 결제) 취소 완료·C2 반품 완료, 교환은 환불 아님
"2026-09-10": [_naver_item("B", "B1", "2026-09-09", 9900, status="CANCELED"),
_naver_item("C", "C2", "2026-09-10", 7000, status="RETURNED"),
_naver_item("E", "E1", "2026-08-30", 3000, status="EXCHANGED")]}
def get(url, params=None, headers=None, timeout=None):
if params["rangeType"] == "CLAIM_COMPLETED_DATETIME":
calls.append(("claim", params["from"][:10]))
return httpx.Response(200, json={"data": {"contents": refunds.get(params["from"][:10], []),
"pagination": {"page": params["page"], "hasNext": False}}})
key = (params["from"][:10], params["page"])
calls.append(key)
rows, more = pages.get(key, ([], False))
@@ -1530,12 +1540,18 @@ def test_naver_collect_sales():
httpx.post, httpx.get, nv.CALL_INTERVAL_SEC = orig
assert r["ok"], r
ev_ = {k[2]: v for k, v in st.events.items() if k[0] == "naver"}
assert set(ev_) == {"naver:A", "naver:B", "naver:C"} # D 미입금취소만 제외
assert ev_["naver:A"]["amount"] == 20000 + 5000 # 배송비 제외
assert set(ev_) == {"naver:A", "naver:B", "naver:C", "naver:B1-RF", "naver:C2-RF"} # D 미입금취소만 제외, 교환은 환불 아님
# 판매금액 + 배송비(2026-10-19) — 배송비는 배송 묶음(여기선 주문)마다 한 번(상품주문마다 반복돼 와도), 할인은 빼지 않음
assert ev_["naver:A"]["amount"] == 20000 + 5000 + 3000
assert ev_["naver:A"]["raw"] == {"goods": 25000, "ship": 3000}
assert ev_["naver:B"]["amount"] == 9900 # 결제 뒤 취소도 결제일 매출(판매금액(총))
# 환불은 환불된 날(클레임 완료일)에 뺀다 — 결제일(9/9)이 아니라 9/10
assert (ev_["naver:B1-RF"]["amount"], ev_["naver:B1-RF"]["sales_date"], ev_["naver:B1-RF"]["event_type"]) == (-9900, date(2026, 9, 10), "CANCEL")
assert (ev_["naver:C2-RF"]["amount"], ev_["naver:C2-RF"]["event_type"], ev_["naver:C2-RF"]["raw"]["refund"]) == (-7000, "RETURN", 7000)
assert ("claim", "2026-09-09") in calls and ("claim", "2026-09-10") in calls
assert ev_["naver:A"]["quantity"] == 3 and ev_["naver:A"]["discount_amount"] == 1000
assert ev_["naver:A"]["sales_date"] == date(2026, 9, 9) and ev_["naver:A"]["product_name"] == "밀폐용기 외 1건"
assert ev_["naver:C"]["amount"] == 15000 + 7000 # 반품 줄도 포함
assert ev_["naver:C"]["amount"] == 15000 + 7000 + 3000 # 반품 줄도 포함, 배송비 할인(조건부 무료)도 판매분석처럼 배송비에 넣음
assert ev_["naver:C"]["order_status"] == "구매확정/반품"
assert ("2026-09-09", 2) in calls and ("2026-09-10", 2) not in calls # hasNext 일 때만 다음 쪽
assert "홍길동" not in repr(st.events) and "010-1234-5678" not in repr(st.events)
@@ -1598,6 +1614,8 @@ def test_sync_job_progress():
def get(url, params=None, headers=None, timeout=None):
day = params["from"][:10]
if params["rangeType"] != "PAYED_DATETIME": # 환불(클레임 완료일) 조회 — 이 테스트엔 없음
return httpx.Response(200, json={"data": {"contents": [], "pagination": {"hasNext": False}}})
if day == "2026-09-10": # 둘째 날을 받는 중 — 진행 상황 중간 모습
mid.update(job.snapshot())
rows = [_naver_item("A" + day, "P" + day, day, 10000), _naver_item("B" + day, "Q" + day, day, 5000)]
@@ -1618,14 +1636,15 @@ def test_sync_job_progress():
job.finish(last_update_at="2026-09-30T10:00:00")
m = {s["code"]: s for s in mid["shops"]}
assert m["naver"]["state"] == "running" and (m["naver"]["done"], m["naver"]["total"], m["naver"]["unit"]) == (1, 2, "일")
assert m["naver"]["items"] == 2 and m["naver"]["fraction"] == 0.5
assert mid["overall"]["shops"] == 1 and mid["overall"]["fraction"] == 0.5 and not mid["finished"]
# 네이버 = 하루에 결제·환불 두 번 조회(2026-10-19) — 2일 = 4단계
assert m["naver"]["state"] == "running" and (m["naver"]["done"], m["naver"]["total"], m["naver"]["unit"]) == (1, 4, "일 조회")
assert m["naver"]["items"] == 2 and m["naver"]["fraction"] == 0.25
assert mid["overall"]["shops"] == 1 and mid["overall"]["fraction"] == 0.25 and not mid["finished"]
snap = job.snapshot()
s = {x["code"]: x for x in snap["shops"]}
assert s["naver"]["state"] == "done" and s["naver"]["upserted"] == 4 and s["naver"]["items"] == 4
assert s["naver"]["done"] == s["naver"]["total"] == 2 and s["naver"]["fraction"] == 1.0
assert s["naver"]["done"] == s["naver"]["total"] == 4 and s["naver"]["fraction"] == 1.0
assert s["ohouse"]["state"] == "error" and s["ohouse"]["status"] in ("not_implemented", "not_configured")
assert not s["ohouse"]["active"]
assert s["elevenst"]["state"] == "error" and s["elevenst"]["status"] == "not_configured" and not s["elevenst"]["active"]
@@ -2168,3 +2187,46 @@ def test_dashboard_manual_cells_and_order():
assert ctx["manual_codes"] == ["coupang"] and ctx["manual_cells"] == ["2026-10-05|coupang"]
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert day5["cells"]["coupang"]["gross"] == 87000 and day5["cells"]["coupang"]["commission"] == 8700
def test_naver_ship_check_candidates():
"""배송비 진단(2026-10-19) — 같은 주문·배송 묶음에 반복되는 배송비·할인을 주문/묶음 단위로 센 후보를 함께 돌려준다."""
from app.modules.performance.adapters import naver as nv
def it(order, po, fee, dc, pkg, status="DELIVERING", pay=10000):
x = _naver_item(order, po, "2026-10-18", pay, status=status, ship=fee, ship_dc=dc)
x["content"]["productOrder"]["packageNumber"] = pkg
return x
items = [it("A", "A1", 3500, 0, "P1"), it("A", "A2", 3500, 3500, "P1"), # 묶음 2개 — 두 번째는 묶음 할인
it("B", "B1", 3500, 3500, "P2"), # 조건부 무료
it("C", "C1", 0, 0, "P3"), # 무료배송 상품
it("D", "D1", 3500, 0, "P4", status="CANCELED"),
it("E", "E1", 3500, 0, "P5", status="CANCELED_BY_NOPAYMENT")] # 미입금 — 제외
got = nv.ship_check([{"content": i["content"]} | {"productOrder": i["content"]["productOrder"], "order": i["content"]["order"]}
for i in items], date(2026, 10, 18), date(2026, 10, 18))
assert got["product_orders"] == 5
assert got["per_product_order"] == {"fee": 14000, "discount": 7000, "fee_minus_discount": 7000, "section": 0}
assert got["per_order"] == {"groups": 4, "max_fee": 10500, "max_fee_minus_max_discount": 3500,
"sum_fee_minus_sum_discount": 7000, "with_fee": 3}
assert got["per_package"]["groups"] == 4 and got["per_package"]["max_fee"] == 10500
assert [o["order"] for o in got["orders"]] == ["A", "B", "C", "D"] and len(got["orders"][0]["lines"]) == 2
assert "홍길동" not in repr(got) and "010-1234-5678" not in repr(got)
def test_naver_ship_once_per_package_like_sales_analysis():
"""10/18 실데이터 모양(2026-10-19): 상품주문마다 배송비 3,500·할인이 반복 — 묶음마다 배송비 한 번(할인 안 뺌) = 판매분석 배송비."""
from app.modules.performance.adapters import naver as nv
def it(order, po, fee, dc, pkg):
x = _naver_item(order, po, "2026-10-18", 10000, status="DELIVERING", ship=fee, ship_dc=dc)
x["content"]["productOrder"]["packageNumber"] = pkg
return x["content"]
items = [it("A", "A1", 3500, 3500, "P1"), it("A", "A2", 3500, 3500, "P1"), # 조건부 무료 묶음 — 그래도 3,500
it("B", "B1", 3500, 0, "P2"), it("B", "B2", 3500, 0, "P2"), it("B", "B3", 3500, 0, "P2"),
it("C", "C1", 0, 0, "P3"), # 무료배송 상품
it("D", "D1", 3500, 0, "P4"), it("D", "D2", 3500, 0, "P5")] # 한 주문 두 묶음 = 두 번
o = nv.group_orders(items, date(2026, 10, 18), date(2026, 10, 18))
assert {k: v["ship"] for k, v in o.items()} == {"A": 3500, "B": 3500, "C": 0, "D": 7000}
assert sum(v["ship"] for v in o.values()) == nv.ship_check(items, date(2026, 10, 18), date(2026, 10, 18))["per_package"]["max_fee"]
+131
View File
@@ -0,0 +1,131 @@
# [프로젝트] 프로젝트 관리 모듈(아사나식) — `app/modules/project/`, `project_db`
> 이 모듈만 고칠 때 읽는 요약. 상세는 `docs/PROJECT_MODULE.md` — **178KB 큰 문서, 통째로 읽지 말 것.**
> `grep -n '^#' docs/PROJECT_MODULE.md` 로 목차를 보고 해당 절(아래 괄호의 6-x 번호)만 offset/limit 으로 읽는다.
> 정적 파일: `app/static/project*.js|css`(`project.js`·`project.css`·`project-goal-*`·`project-meeting-*`·`project-options.js`·`project-help.*`·`project-fonts.css`), `erp-overdue.js|css`.
> 템플릿: `templates/project/`. PC 알림 프로그램: `desktop/notifier/`.
> 다른 모듈과 연결: 긴급 공지(`notice`)가 `ProjectStore.pool` 공유 · 회의록 머리 카드가 실적 `performance_store` 매출 읽기 · 회의록 보드는 `app/integrations/google_slides.py`.
## 꼭 지킬 코드 규칙
- 라우터 핸들러는 동기 DB 라 `def` 로 둔다(`async def` 금지).
- 말풍선은 전부 아사나식 공용 말풍선(`.pj-hovertip`) — 새 기능도 `title=`/`data-tip=` 만 달고 별도 툴팁 구현 금지. 모달 대화창 안 말풍선은 popover(top layer).
- 담당자 배정 UI = 아이콘+이름(`assigneeMenuItems` / `enhanceAssigneeSelect`), 글자만 메뉴·기본 select 금지.
- 상단 바 화면 배율 토글(`html.pj-ui-scale` → `.erp-app` zoom .75, 2880×1620·200%용) — **팝업은 반드시 `document.body` 에 붙인다**(배율 안의 fixed 좌표는 어긋남).
- 권한 판단은 **지금 기준 공통 모듈 `access.py`** 하나로(목록·배지·알림·멘션·메일 수신자·삭제·댓글 수정까지 — 멤버에서 빠지면 기록이 있어도 안 보이고 알림도 없음).
- URL 의 섹션·부모 작업이 그 프로젝트 것인지 서버가 검증.
- 용어는 **"업무"**(2026-10-13 "작업"에서 다시 통일 — 화면·메시지·알림 제목, 코드·DB 는 그대로)·"세부 업무"·"메인 업무 추가". ERP 메뉴 이름은 "Project"(`app/main.py` 모듈 목록 title).
- 화면 기능을 바꾸면 도움말(`/project/help`)도 같이 고친다.
- UI 버그는 로컬 헤드리스 크롬/엣지로 렌더·좌표 덤프해 재현 후 고칠 것.
## 권한 — 관리자 등급 4단계 (2026-10-12, 6-14)
- **수퍼관리자(`SUPER_ADMIN_EMAIL` 한 명 고정, 추가 불가) > Admin(`role=admin`) > Pro user(`role=pro`) > User**.
- 판단: `access.is_pro`(Pro user 이상)·`access.is_project_admin`(Admin 이상), 라우터 `_require_pro`, 화면 `pj_pro`·`pj_admin`(`_role_ctx`). `is_admin` 은 ERP 상단 관리자 메뉴용 그대로. pro 는 프로젝트 모듈 밖에서는 user 와 같다.
- Pro user 이상: 새 프로젝트·프로젝트 이름/색/아이콘/소유자 수정·멤버 배정(자기가 멤버인 프로젝트)·사이드바 순서·남의 댓글 수정/삭제·휴지통·전체 보기·담당자별 합계·전체 멤버·소유자 변경.
- Admin 이상 또는 만든 사람: 프로젝트·섹션 삭제. 멤버 누구나: 작업 삭제·서브프로젝트(표는 6-14).
- 진입 권한키 `project`(관리자 페이지 토글로 직원별 부여, admin 자동).
- 배정 멤버(또는 owner)만 그 프로젝트를 조회 — **관리자도 멤버가 아니면 안 보임, 예외는 슈퍼관리자뿐**(2026-10-07, `access.sees_all_projects`; 사이드바 목록·검색·휴지통·알림도 같은 기준, 화면·API 모두 비멤버 403).
- 연결(멀티호밍)된 작업은 연결된 프로젝트 멤버에게 읽기 전용(6-10).
- 멤버 배정 후보는 `project` 권한 보유 등록 사용자에서 자동 목록(`GET /project/api/assignable-users`).
## 구조 / 데이터
- 프로젝트/서브프로젝트(self-FK `parent_id`, CASCADE) → 진행단계(`project_stages`, 칸반 섹션) → 작업(`tasks`: 담당자·우선순위·시작/마감).
- 멤버 배정(`project_members`)·활동이력(`project_activity`).
- 프로젝트 색상 32색(아사나 16색 + 진한 16색, 수정 창 12열).
- 아이콘(`projects.icon`, Material Symbols 42종, 마이그레이션 011 + [아사나 아이콘] 탭 33종 `"asana:"+이름`, 채워진 모양 전용 부분 글꼴 `material-symbols-asana.woff2`).
- 섹션: 새 프로젝트는 섹션 없이 시작 — `create_project(seed_stages=True)` 일 때만 기본 4단계. 섹션 머리는 모두 `#f3f3f3`(섹션별 색 지정 없음), 섹션 이름 굵게.
- 섹션 기본 담당자 `default_assignee_email`(마이그레이션 009) — 담당자 빈 작업을 그 섹션에 만들거나 옮기면 자동 배정. 섹션 제목 오른쪽 담당자 아이콘 = 그 자리에서 지정(6-16).
- 실시간 반영은 `project_live_version` 카운터(마이그레이션 007, 미적용 시 MAX 폴백).
## 화면
- 첫 화면(`/project/`)은 **내 작업 목록**(프로젝트 홈 카드 화면은 폐지). 내 업무 화면 줄 클릭 = 오른쪽 업무 창(iframe).
- 프로젝트 화면은 캘린더(FullCalendar)/타임라인(vis-timeline)/보드/목록/대시보드 뷰 토글.
- 좌측 사이드바는 수신함·내 작업·휴지통·프로젝트 화면 공용(`templates/project/_side.html` + 프로젝트 목록 동작 `initSideTree`, 새 프로젝트/수정 모달 `_side_modals.html`) — 프로젝트 목록(순서 변경·✎·×)은 어느 화면에서나 같다.
- 사이드바 메뉴: 수신함·전체 보기(Pro user 이상 — 예전 오른쪽 위 "전체 프로젝트" 토글, `?scope=all`, 기본 대시보드)·내 작업(접이식)·목표.
- 보드는 아사나처럼 섹션이 가로로 계속 늘어나고(넘치면 가로 스크롤) 카드의 담당자·마감일을 클릭해 그 자리에서 바꾼다.
- 보드 카드 끌기 = 실시간 미리보기(2026-10-19, `startCardDrag`·`placeCardPh`): 원래 카드는 숨기고 점선 자리 표시(`.pj-card-ph`)가 카드 사이로 FLIP 애니메이션, 끄는 모양은 기울어진 복제(`setDragImage`). 놓은 자리 그대로 — 다른 섹션도 PUT stage 뒤 `stages/{id}/tasks/order`(정렬 "기본"일 때만, 전체 보기는 섹션 맨 끝).
**필터를 켜도 순서 변경 가능**(2026-10-19 버그 수정 — 필터는 브라우저별 localStorage `pj_filter_<id>` 라 필터를 켜 둔 컴퓨터에서만 섹션 안 카드가 늘 제자리로 돌아갔다). 숨은 업무는 제자리(`orderWithHidden`). 카드 속 이미지 끌기가 "Files" 로 오인돼 카드 놓기를 가로채지 않게 `dragHasFiles` 는 카드·세부 업무 끌기 중 false, 카드 img 는 `-webkit-user-drag: none`. 끄는 중엔 실시간 동기화 쉼(`html.pj-card-dragging`). 컬럼 body 는 dragenter 도 preventDefault(안 하면 자리 표시가 들어온 직후 놓을 때 drop 거부).
- 사이드바 전체 검색(`/api/search`, 제목·설명·댓글, pg_trgm) + 프로젝트/내 작업 필터 바(찾기·상태·담당자·마감·우선순위·정렬, 클라이언트 필터).
- 대시보드: "업무 합계(프로젝트별)" 카드, 섹션별 카드 삭제, 대시보드 업무 목록 패널에서 연 업무 창은 패널 왼쪽에(6-16·6-17·6-19).
- 담당자별 패널 날짜 mm/dd(요일)·지난 마감 빨강(6-20).
- 패널(`/project/p/{pid}?task=&embed=1`, `html.pj-embed`).
- **업무를 다른 프로젝트로 이동** — 보드 카드를 왼쪽 프로젝트 목록에 끌어 놓으면 섹션 선택 창 → `POST /project/api/tasks/{id}/move-project`(세부 업무 함께, 원 소속 권한 + 대상 프로젝트 멤버)(6-18).
## 업무 창 / 댓글 / 협업자
- 작업 창은 **저장 버튼 없이 실시간 저장**(칸별 PUT, `saveField`/`saveChain`, 새 작업은 제목이 생기는 순간 생성).
- **파일 끌어 놓기**(2026-10-19): 종류 "Files" 로 카드·세부 업무 끌기와 구분, 받는 곳 밖에 놓친 파일은 document 가 막아 화면이 파일로 넘어가지 않음.
- **설명란·세부 업무 목록·보드 카드(펼친 세부 업무 줄) → 구글 드라이브**: `POST /project/api/tasks/{id}/drive-files`(`app/integrations/google_drive.py`, 최상위 `PROJECT_DRIVE_FOLDER_ID` 기본 `1Zdak2FtACRJ6peOnA9zD22hsbbsTixJG` 아래 `프로젝트/섹션/업무/세부 업무` 폴더 자동, 세부 업무 섹션 = 맨 위 업무 섹션). 링크 제목 = 파일 이름.확장자(새 탭). 설명란 = 놓은 자리(`descEditor.insertDriveFiles`, 올리는 중 표시·저장 미룸), 세부 업무 줄·카드 = `append=true` 로 서버가 설명 끝에 붙임 — 단 지금 업무 창에 열린 업무면 편집기 끝에(옛 설명 저장이 링크를 덮지 않게, `dropDriveFilesOnTask`).
- **링크를 지우면 드라이브 휴지통**: `api_update_task` 가 설명 저장 전후 드라이브 링크 id 를 비교 → 백그라운드 `_sync_drive_links` — 우리가 올린 파일(appProperties `dbxTaskId`)만, 다른 업무 설명에 같은 링크가 있으면 그대로(`db.description_mentions`), 링크가 다시 생기면 휴지통에서 꺼냄. DB 변경 없음.
- 그 밖의 업무 창 자리 → 예전처럼 첨부(`POST …/attachments`, `uploadTaskFiles`).
- 설명란 서식 도구에 글자 색·크기(서버는 span style 의 color·font-size 만 허용, `desc_inline_style`). 주소 붙여넣기 시 자동 링크. 설명란 링크 = 굵게·기울임·밑줄 + 한 글자처럼(2026-10-19 — `normalizeEditorLinks` 가 `contenteditable=false`, 링크 바로 뒤 Backspace·앞 Delete = 링크 통째로 `execCommand delete`(Ctrl+Z 가능), 저장 HTML 에선 `getHtml` 이 잠금 표시를 뺀다). 설명란 이미지 더블클릭 = 별도 창 이미지 보기(확대·축소·끌어 이동).
- 설명란·댓글에서 @로 멤버 태그(`task_mentions`, 마이그레이션 006) → 수신함에 그 작업이 쌓임. 댓글 `@아이디` 는 아이콘+이름 칩.
- 댓글·답글 입력칸은 Enter 등록·Shift+Enter 줄바꿈(textarea).
- 댓글 답글·이모티콘 반응(마이그레이션 012 `task_comments.parent_id`·`task_comment_reactions`, 미적용 시 버튼 숨김·API 503). 반응 = 댓글 쓴 사람에게 알림(`type=reaction`).
- 완료 이력 줄은 `project_activity` completed 를 댓글 사이에 표시(댓글 수 제외).
- 협업자(`task_followers`, 자동 팔로우: 만든 사람·담당자·댓글·@태그) — 완료·댓글 알림은 담당자+협업자에게만.
- **담당자는 협업자가 아니다**(협업자 = 담당자 외의 멤버, `db.add_followers` 가 거르고 담당자 지정 시 협업자에서 뺌, 기존 겹친 행은 마이그레이션 028).
- 세부 업무: 업무 창 세부 업무 줄 담당자 오른쪽 = 협업자 지정. 만들 때(업무 창 추가 칸·보드 카드 새 줄) 협업자도 같이(`POST …/tasks` 의 `followers`, 비멤버 400). 만든 사람을 자동 협업자로 넣지 않음(고른 사람만). 보드 카드 세부 업무 줄에도 협업자 아이콘. 추가 칸은 동그라미 아이콘 버튼. 빈 마감일 아이콘 늘 옅게(6-17·6-19·6-20).
- 작업 삭제는 휴지통(`project_trash`, 마이그레이션 010) — 삭제 직전 스냅샷 3개월 보관, Pro user 이상만 보기·복구(`/project/trash`).
## 알림
- 수신함은 확인 안 한 태그·읽지 않은 알림만(2026-10-08) — [확인] 버튼 없이 줄을 누르면 읽음·확인 처리(같은 작업 줄 함께) + 페이지 이동 없이 오른쪽 iframe 패널, 다른 줄을 고르거나 패널을 닫으면 그 줄은 목록에서 빠짐.
- 나를 태그하거나 작업이 배정되면 프로젝트 화면 가운데 아래에 깜박이는 큰 팝업(닫기 전까지, `initTaskAlerts` + `GET /api/notifications/alerts`).
- **마감 지난 내 업무 위쪽 알림**(`static/erp-overdue.js`, ERP 모든 화면, `GET /project/api/my-overdue`, 닫으면 1시간 뒤 다시 — 새로 지난 업무는 바로)(6-17).
- 마감 알림(`reminders.py` 데몬 스레드, 영업일 09시, D-1/당일/지연, `task_reminders` 로 중복 방지, `PROJECT_REMINDER_*` env) — 마이그레이션 008.
- 작업 배정·완료 시 관리자에게 메일(`app/mail.py` stdlib smtplib, `SMTP_*` + `PROJECT_NOTIFY_EMAIL` env, 미설정 시 조용히 skip, `BackgroundTasks` 비동기).
- **PC 알림 프로그램**(`desktop/notifier/`, C# .NET Framework 4.8 WinForms exe 하나·트레이 상주, 마이그레이션 023 `notifier_links`·`notifier_tokens`, 6-11)
- 브라우저가 뒤에 있어도 태그·배정 알림을 웹 팝업과 같은 모양으로 화면 위에.
- 브라우저 `/project/notifier?code=` 승인으로 PC별 토큰(서버는 SHA-256 만, PC 는 DPAPI). `GET /project/api/notifier/alerts`(Bearer)는 웹 알림과 같은 `_alerts_payload`, 토큰마다 지금 사용자·권한 재확인.
- 프로그램이 돌고 있으면(최근 3분 확인, `notifier_active`) 웹 큰 팝업은 쉰다(`desktop: true`).
- 압축·난독화 금지(백신 오탐), 빌드 `desktop/notifier/build.ps1`.
## Project 옵션 (상단 톱니, 2026-10-16)
- 왼쪽 분류 | 오른쪽 설정. 새 옵션도 이 창에.
- 폰트 = 누구나·이 브라우저(localStorage `pj_font`).
- 처음 여는 탭·보드 카드 표지 = **수퍼관리자·Admin 만 수정·모든 사용자에게 적용**(서버 `project_options` 마이그레이션 029, `GET/PUT /project/api/options`, `store.normalize_project_options`).
- 긴급 공지 = 수퍼관리자만.
## 연간 목표 (마이그레이션 013, `goal_*` 테이블, 6-9)
- 사이드바 "목표" → 연도 펼침 → `/project/goals/{연도}`. 매출(목표·실적·달성)·로아스 월별 숫자 + 업무 영역(상품·마케팅·컨텐츠·유통 등)별 연간·월별 글.
- 조회는 전원·입력(주차별 목표·연도 추가/삭제 포함)은 Pro user 이상.
- 3·6·9·12월 오른쪽 1~4분기 칸(글 칸 13=1분기·15=2분기·14=3분기·16=4분기 — 예전 반기 칸 번호 재사용, 15·16 은 마이그레이션 017) + 분기 월 칸 접기 애니메이션(localStorage `pj_goal_fold_q`, 표는 `width:1px` + `table-layout:fixed`)(6-9-0).
- 영역·줄 이름 클릭 바로 수정. 로아스는 % 표기.
- **엑셀식 칸 병합** — 마우스로 끌어 사각형 선택 → 우클릭 셀 병합/병합 해제, 같은 영역 안 세로 `row_span` + 같은 분기 월 칸 가로, 글은 왼쪽 위 칸(`goal_cell_merges`, 마이그레이션 014·015·017).
- 3열 줄 추가는 같은 항목 칸(2열) 안에(`goal_rows.label_cont`, 마이그레이션 016).
- 구조 변경은 새로고침 없이 제자리 다시 그리기(`refreshTable`) + 애니메이션.
- 모든 열 너비 끌어서 조절(localStorage `pj_goal_col_w`), 세로 스크롤 틀 고정은 머리 줄 + 매출·로아스 줄까지, 항목 칸 +·우클릭으로 줄 위/아래 추가·삭제.
- 목표 표 매출 목표 월 칸을 누르면 **주차별 매출 목표**(`goal_week_targets`) 입력 창 — 월 전체 목표는 직접 입력(주차 합계와 별개), 맨 아래 차이 = 월 목표 − 주차 합계.
주차마다 두 칸(마이그레이션 030 `value_dist` 유통·인플 · `value_mall` 카페24·네이버, `value` = 합계 그대로 — 회의록 누적 목표는 합계), 머리글은 전체 목표 아래 구분선 밑. 030 전 한 칸 값은 유통·인플 칸에 미리 들어감, 030 미적용이면 한 칸 그대로.
- 목표 표·회의록 칸 저장은 공용 `createFieldSaver`(같은 칸 요청 직렬화·보낸 값만 저장됨·실패 시 초안 유지·localStorage 초안 백업, 저장 실패면 구조 변경 중단 — 6-9-3).
- 구역·항목 메뉴는 우클릭 + ⋮ 버튼(키보드·터치).
## 주간 회의록 (`/project/goals/{연도}/meetings/{월}`, 6-9-2·6-9-3·6-9-4·6-22)
- 진입: 목표 표 월 머리. `goal_meetings`·`goal_meeting_items` 마이그레이션 015.
- 수정: 프로젝트 권한자 **누구나**. Pro user 이상 [회의 완료](`completed_at`, 마이그레이션 022)면 잠금(지난주 결과는 다음 주 회의록이 열려 있는 동안 허용). 삭제·완료·완료 해제는 Pro user 이상.
- 표 첫 열 머리 글자 "구분".
- 주차 탭 — **주차는 그 달 안**(`store.month_weeks`): 1일이 월~금이면 1일~일요일이 1주차, 토·일이면 1일~다음 주 일요일, 그 뒤 월~일, 말일이 월·화면 앞 주차에 붙음. 회의록 `week_start` = 주차 시작일(마이그레이션 020).
- 지난주 = **바로 앞 주차**(`store.prev_week_period`) 회의록의 같은 연결키 줄(`line_key`, 마이그레이션 018 — 생성 순서·이름 변경과 무관, **이름 추정 연결 금지**)로 리뷰.
- 열: 주요 업무·정량 목표 ‖ 전주 업무·결과(글, `result_note` 020)·전주 목표·결과. 정량 목표·결과는 숫자면 원 정수 칸, 아니면 글 칸 `target_text`·`result_text`(예: 20개, 021).
- 실적 조회 장애는 0원이 아니라 "미확인".
- 위에 목표 표 그 달 열 글을 영역별 "N월 계획" 카드로.
- 참석자 옆 [회의록 보드] = 그 주차의 빈 Google 슬라이드를 독립 창으로(오른쪽 🔗 아이콘 = 그 보드 링크 복사). 공유 드라이브 `MEETING_BOARD_FOLDER_ID`(없으면 만듦), `app/integrations/google_slides.py`, Drive appProperties 로 주차 연결 — Drive·Slides 권한 토큰 필요.
- 표를 스크롤해도 보이는 머리 영역 3칸:
1·2. (2026-10-19) 제목 줄(`.pj-meet-title`) 둘째 줄, **주차 탭과 같은 줄 왼쪽** `.pj-meet-kpitop`(앞에 줄바꿈 `.pj-meet-title-break`) = N월 계획 + 숫자 4개(월 목표 매출·월 누적 목표 매출(`goal_week_targets` 1주차~이 주차 합)·월 누적 실적(1일~오늘)·누적 목표 대비 차액·%, 잘리지 않음 — 좁으면 줄바꿈), 아래 카드 `.pj-meet-pn` = 결정사항 제목(왼쪽) + 결정 사항(크게). 월 계획 상세(목표 표 그 달 글)는 뺐다. (`.pj-meet-kpibar` 는 예전 숫자 상자 이름이라 쓰지 말 것)
3. "N주차 작업 등록" 표(제목·담당자·프로젝트·섹션 → [적용] = 서버가 그 프로젝트에 작업 생성, `initMeetQuickTasks`).
주차별 서버 표 `goal_meeting_tasks`(마이그레이션 025)라 모두가 같이 보고, 남의 프로젝트 이름은 가림, 완료 프로젝트·섹션은 목록에서 뺌.
작업 칸(마이그레이션 026 `parent_task_id`) = 이미 있는 작업을 고르면 그 작업의 세부 작업으로 등록.
등록된 줄 제목 = 오른쪽 작업 창(편집, 저장 대기), [크게 열기] = 같은 표를 넓은 창으로.
- 실적 모듈 `performance_store` 매출은 머리 카드에만 읽기 전용 — 줄(쇼핑몰)별 자동 결과·이번주 실적·연결 배지·쇼핑몰 연결 메뉴는 폐지, 지난주 결과는 늘 직접 입력.
- "주요 업무" 칸 우클릭 위/아래 줄 추가 = 항목 칸은 그대로 그 항목 안에(마이그레이션 027 `label_cont`, 항목 칸 나누기).
- 회의록 줄 작업은 새로고침 없이 제자리 다시 그리기(`refreshMeeting`) + 애니메이션.
- 구분(구역) 칸 우클릭·⋯ = 구역 통째로 위/아래(`move-section`).
- 항목 칸 끌어 옮기기(2026-10-19) — 마우스로 항목 칸을 5px 이상 끌면 묶음(label_cont 줄 + 걸친 세로 병합)이 같은 구역 안에서 실시간 이동(칸 단위 FLIP, 구분 칸은 늘 첫 줄), 놓으면 `POST meeting-items/{id}/move-to {before_item_id|null}`(`db.move_meeting_group`, 묶음 사이·다른 구역은 거절) → `refreshMeeting`. Esc 취소, 짧게 누르기는 이름 수정.
- 회의록 표(`.pj-meet-table`) 테두리 = **구역(구분) 처음·끝 가로선만 굵은 검정 2px, 나머지 선(세로·항목 사이·하위 줄 사이·바깥 위·좌우)은 모두 회색 `#bfc3c9`**(2026-10-19 마지막 요청 — 앞선 '전부 검정'·'항목 사이 검정'을 바꿈, 표 머리 아래 회색선은 없앰). 구역 끝에 닿는 칸(병합 포함)은 `.is-sec-end`(아래선 없음 — 다음 구역 굵은 선이 대신). 둘 다 JS `markMeetSecEnds` 가 달고 표 다시 그리기·끌기 뒤에도 다시 계산.
+116 -3
View File
@@ -661,6 +661,16 @@ class ProjectStore:
).fetchone()
return self._serialize(row) if row else None
def description_mentions(self, *, text: str, exclude_task_id: int) -> bool:
"""다른 업무 설명에 text(드라이브 파일 id 등)가 들어 있나 — 링크를 지운 파일을 휴지통에 넣기 전 확인."""
like = "%" + text.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
with self._pool.connection() as conn:
row = conn.execute(
"SELECT 1 FROM tasks WHERE id <> %s AND description LIKE %s LIMIT 1",
(int(exclude_task_id), like),
).fetchone()
return row is not None
def create_task(
self,
*,
@@ -1842,6 +1852,30 @@ class ProjectStore:
return False
return row is not None
# ── Project 옵션(시스템 전체, 마이그레이션 029) — 키 하나 = 행 하나, 값 검사는 store 한 곳 ──
def get_project_options(self) -> dict[str, Any]:
"""저장된 시스템 옵션 원본 {key: value}. 029 미적용이면 {}(화면은 기본값)."""
try:
with self._pool.connection() as conn:
rows = conn.execute("SELECT key, value FROM project_options").fetchall()
except psycopg_errors.UndefinedTable:
return {}
return {r["key"]: r["value"] for r in rows}
def set_project_options(self, *, values: dict[str, Any], updated_by: str) -> None:
"""검사를 마친 값만 넣는다(store.validate_project_options). 한 트랜잭션 — 전부 아니면 전무.
029 미적용이면 psycopg_errors.UndefinedTable(라우터가 503)."""
by = store.norm_str(updated_by, lower=True)
with self._pool.connection() as conn:
with conn.transaction():
for key, value in values.items():
conn.execute(
"INSERT INTO project_options (key, value, updated_by, updated_at) VALUES (%s, %s, %s, now()) "
"ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_by = EXCLUDED.updated_by, "
"updated_at = now()",
(key, Jsonb(value), by),
)
def notifier_revoke_token(self, *, token: str) -> None:
with self._pool.connection() as conn:
conn.execute("UPDATE notifier_tokens SET revoked_at = now() WHERE token_hash = %s AND revoked_at IS NULL",
@@ -3525,6 +3559,47 @@ class ProjectStore:
for n, x in enumerate(ids):
conn.execute("UPDATE goal_meeting_items SET sort_order = %s WHERE id = %s", (n, x))
def move_meeting_group(self, *, item_id: int, before_item_id: int | None) -> bool:
"""항목 칸 끌어 옮기기(2026-10-19) — item_id 가 든 묶음(같은 항목 칸으로 이어 붙은 줄 + 걸친 세로 병합)을 통째로
같은 구역의 before_item_id 묶음 앞에(None = 구역 맨 끝). 묶음 안 줄 순서·병합은 그대로 따라간다. 바뀌면 True."""
with self._pool.connection() as conn:
with conn.transaction():
self._require_meetings(conn)
rows = self._locked_meeting_items(conn, item_id)
ids = [int(r["id"]) for r in rows]
conts = self._meeting_conts(rows)
merges = self._meeting_merge_ranges(rows)
# 묶음 경계 = 이어 붙은 줄이 아니고 병합 범위 안쪽도 아닌 줄(구역이 바뀌는 줄은 늘 경계)
starts = [k for k in range(len(rows))
if k == 0 or rows[k]["section"] != rows[k - 1]["section"]
or (not conts[k] and not any(a < k <= b for a, b in merges))]
i = ids.index(item_id)
s = max(k for k in starts if k <= i)
e = next((k for k in starts if k > s), len(rows))
section = rows[s]["section"]
block = ids[s:e]
rest = ids[:s] + ids[e:]
if before_item_id is None:
sec_idx = [n for n, x in enumerate(rest) if rows[ids.index(x)]["section"] == section]
pos = (sec_idx[-1] + 1) if sec_idx else s
else:
if before_item_id not in ids:
raise KeyError(before_item_id)
b = ids.index(before_item_id)
if rows[b]["section"] != section:
raise ValueError("같은 구역 안에서만 옮길 수 있습니다.")
if b not in starts:
raise store.GoalCellConflict("묶인 줄 사이에는 넣을 수 없습니다. 새로고침해 주세요.")
if s <= b < e:
return False
pos = rest.index(before_item_id)
order = rest[:pos] + block + rest[pos:]
if order == ids:
return False
for n, x in enumerate(order):
conn.execute("UPDATE goal_meeting_items SET sort_order = %s WHERE id = %s", (n, x))
return True
def move_meeting_section(self, *, item_id: int, direction: int) -> None:
"""구역(표 첫 열 "구분") 통째로 한 칸 위/아래 — item_id 가 든 구역 묶음(이어진 같은 구역 줄)과 옆 구역 묶음의
자리를 바꾼다. 묶음 안 줄 순서·세로 병합(content_row_span)은 그대로 따라간다. 맨 위/맨 아래면 그대로."""
@@ -3813,6 +3888,24 @@ class ProjectStore:
with self._pool.connection() as conn:
return self._table_exists(conn, "goal_week_targets")
def week_split_enabled(self) -> bool:
"""마이그레이션 030 — 주차 목표 두 칸(유통·인플 value_dist / 카페24·네이버 value_mall)."""
with self._pool.connection() as conn:
return self._table_exists(conn, "goal_week_targets") and self._column_exists(conn, "goal_week_targets", "value_dist")
def goal_week_target_parts(self, *, start: date, end: date) -> dict[str, dict[str, float | None]]:
"""주차 시작일 → {total, dist, mall}. 030 미적용이면 dist·mall 은 None(합계만)."""
with self._pool.connection() as conn:
if not self._table_exists(conn, "goal_week_targets"):
return {}
split = self._column_exists(conn, "goal_week_targets", "value_dist")
cols = "week_start, value" + (", value_dist, value_mall" if split else "")
rows = conn.execute(f"SELECT {cols} FROM goal_week_targets WHERE week_start BETWEEN %s AND %s ORDER BY week_start",
(start, end)).fetchall()
f = lambda v: None if v is None else float(v) # noqa: E731
return {r["week_start"].isoformat(): {"total": f(r["value"]), "dist": f(r.get("value_dist")), "mall": f(r.get("value_mall"))}
for r in rows}
def goal_week_targets(self, *, start: date, end: date) -> dict[str, float]:
"""기간 안 주차 시작일 → 목표(매출 단위). 020 미적용이면 빈 값."""
with self._pool.connection() as conn:
@@ -3825,7 +3918,7 @@ class ProjectStore:
return {r["week_start"].isoformat(): float(r["value"]) for r in rows}
def set_goal_week_targets(
self, *, year: int, month: int, values: dict[date, float | None], month_value: float | None,
self, *, year: int, month: int, values: dict[date, Any], month_value: float | None,
updated_by: str = ""
) -> float | None:
"""그 달 주차별 목표 저장(None = 지움) + 월 매출 목표(goal_metrics sales/target)는 month_value 그대로
@@ -3843,12 +3936,32 @@ class ProjectStore:
raise store.MeetingMigration020Needed()
if not conn.execute("SELECT 1 FROM goal_years WHERE year = %s FOR UPDATE", (year,)).fetchone():
raise KeyError(year)
split = self._column_exists(conn, "goal_week_targets", "value_dist")
for d, v in values.items():
# v = 합계 하나(예전 화면) 또는 (유통·인플, 카페24·네이버) — 030 이 있으면 두 칸 + 합계, 둘 다 비면 지움
dist = mall = None
if isinstance(v, tuple):
dist, mall = v
if split and dist is None and mall is None:
v = None
elif not split:
raise store.MeetingMigration030Needed()
else:
v = (dist or 0) + (mall or 0)
if v is None:
conn.execute("DELETE FROM goal_week_targets WHERE week_start = %s", (d,))
continue
if v < 0 or (dist is not None and dist < 0) or (mall is not None and mall < 0):
raise ValueError("주차 목표는 0 이상이어야 합니다.")
if split:
conn.execute(
"INSERT INTO goal_week_targets (week_start, year, month, value, value_dist, value_mall, updated_by) "
"VALUES (%s,%s,%s,%s,%s,%s,%s) ON CONFLICT (week_start) DO UPDATE "
"SET value = EXCLUDED.value, value_dist = EXCLUDED.value_dist, value_mall = EXCLUDED.value_mall, "
"updated_by = EXCLUDED.updated_by, updated_at = now()",
(d, year, m, v, dist, mall, who),
)
else:
if v < 0:
raise ValueError("주차 목표는 0 이상이어야 합니다.")
conn.execute(
"INSERT INTO goal_week_targets (week_start, year, month, value, updated_by) "
"VALUES (%s,%s,%s,%s,%s) ON CONFLICT (week_start) DO UPDATE "
+195 -6
View File
@@ -899,6 +899,7 @@ def project_page(request: Request, project_id: int) -> HTMLResponse:
{
"user": user,
**_role_ctx(user),
"pj_options": _project_options(st),
"can_manage": can_manage,
"nav_items": build_erp_nav(user, active="project"),
"page_title": project["name"],
@@ -967,6 +968,43 @@ def _db_or_503(request: Request) -> Any:
return st
def _project_options(st: Any) -> dict[str, Any]:
"""시스템 Project 옵션(처음 여는 탭·보드 카드 표지) — 읽기 실패해도 화면은 기본값으로 연다."""
if st is None:
return store.normalize_project_options(None)
try:
return store.normalize_project_options(st.get_project_options())
except Exception: # noqa: BLE001 — 옵션 때문에 프로젝트 화면이 안 열리면 안 된다
logger.warning("Project 옵션 읽기 실패 — 기본값 사용", exc_info=True)
return store.normalize_project_options(None)
@router.get("/api/options")
def api_get_options(request: Request) -> JSONResponse:
"""Project 옵션 창 — 시스템 전체 설정(모든 사용자에게 적용)과 내가 바꿀 수 있는지(Admin 이상)."""
user = _require_user(request)
st = _db_or_503(request)
return JSONResponse({"options": _project_options(st), "can_edit": access.is_project_admin(user)})
@router.put("/api/options")
def api_put_options(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""시스템 Project 옵션 저장 — 수퍼관리자·Admin 만. 보낸 키만 바꾼다. 029 미적용이면 503."""
user = _require_user(request)
if not access.is_project_admin(user):
raise HTTPException(status_code=403, detail="수퍼관리자·Admin 만 바꿀 수 있습니다.")
st = _db_or_503(request)
try:
values = store.validate_project_options(payload)
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e))
try:
st.set_project_options(values=values, updated_by=user.get("email", ""))
except UndefinedTable:
raise HTTPException(status_code=503, detail="DB 마이그레이션 029(Project 옵션)가 아직 적용되지 않았습니다.")
return JSONResponse({"options": _project_options(st)})
@router.get("/api/projects")
def api_list_projects(request: Request) -> JSONResponse:
user = _require_user(request)
@@ -1667,6 +1705,12 @@ def api_update_task(
_notify_completed(bg, request, st, project=project, task=task, actor=user["email"])
skipped: list[str] = []
if "description" in payload:
# 드라이브 파일 링크를 지우면 그 파일을 휴지통으로 / 되살리면 꺼낸다(2026-10-19, 백그라운드)
from app.integrations.google_drive import file_ids_in # noqa: WPS433
before, after = file_ids_in(existing.get("description") or ""), file_ids_in(payload["description"])
if before != after:
bg.add_task(_sync_drive_links, st, task_id, before - after, after - before)
skipped = _record_mentions(
st, task=task,
emails=store.extract_mentions_from_html(payload["description"]),
@@ -2454,6 +2498,108 @@ def api_delete_attachment(request: Request, attachment_id: int) -> JSONResponse:
return JSONResponse({"ok": True})
# ────────────────────────────────────────────────────────────
# 업무 파일 → 구글 드라이브(2026-10-19) — 설명란·보드 카드·세부 업무 줄에 파일을 끌어 놓으면
# 드라이브 `프로젝트/섹션/업무/세부 업무` 폴더에 올리고 설명란에 "파일 이름.확장자" 링크.
# 설명에서 링크를 지우면 그 파일을 드라이브 휴지통으로(api_update_task → _sync_drive_links).
# ────────────────────────────────────────────────────────────
_MAX_DRIVE_BYTES = 200 * 1024 * 1024 # 200MB
def _drive_folder_names(st: Any, task: dict[str, Any]) -> list[str]:
"""[프로젝트, 섹션, 업무, (세부 업무…)] — 섹션은 맨 위 업무의 섹션(세부 업무는 섹션이 없을 수 있다)."""
chain = [task]
seen = {int(task["id"])}
while chain[-1].get("parent_task_id") and len(chain) < 10:
parent = st.get_task(task_id=chain[-1]["parent_task_id"])
if parent is None or int(parent["id"]) in seen:
break
seen.add(int(parent["id"]))
chain.append(parent)
chain.reverse()
top = chain[0]
return [top.get("project_name") or "", top.get("stage_name") or "섹션 없음"] + [t.get("title") or "" for t in chain]
def drive_link_html(url: str, name: str) -> str:
"""설명란 링크 — 제목 = 파일 이름.확장자, 새 탭에서 열기."""
import html as _html # noqa: WPS433
return (f'<a href="{_html.escape(url, quote=True)}" target="_blank" rel="noopener noreferrer">'
f"{_html.escape(name)}</a>")
@router.post("/api/tasks/{task_id}/drive-files")
def api_upload_drive_file(
request: Request, task_id: int, file: UploadFile = File(...), append: bool = Form(False),
) -> JSONResponse:
"""파일 하나를 구글 드라이브 업무 폴더에 올린다 → {file: {id, name, url}, link_html}.
append=true 면 서버가 그 업무 설명 끝에 링크 줄을 붙이고 바뀐 업무를 같이 돌려준다(보드 카드·세부 업무 줄에 놓을 때 —
설명란을 열어 둔 업무는 화면이 커서 자리에 직접 넣고 평소처럼 저장)."""
from app.integrations import google_drive # noqa: WPS433
user = _require_user(request)
st = _db_or_503(request)
task = _task_or_404(st, task_id)
_require_task(st, user, task, write=True)
client = google_drive.get_client()
if not client.enabled:
raise HTTPException(status_code=503, detail=f"구글 드라이브 연동이 꺼져 있습니다({client.reason}).")
stream = file.file
stream.seek(0, 2)
size = stream.tell()
stream.seek(0)
if size > _MAX_DRIVE_BYTES:
raise HTTPException(status_code=413, detail="파일이 너무 큽니다(최대 200MB).")
if size <= 0:
raise HTTPException(status_code=400, detail="빈 파일입니다.")
name = (file.filename or "file").replace("\\", "_").replace("/", "_").strip() or "file"
try:
folder = client.ensure_folder_path(_drive_folder_names(st, task))
up = client.upload(folder_id=folder, name=name, stream=stream,
mimetype=file.content_type or "application/octet-stream", task_id=task_id)
except google_drive.GoogleDriveError as exc:
raise HTTPException(status_code=502, detail=str(exc))
link = drive_link_html(up["url"], up["name"])
out: dict[str, Any] = {"file": up, "link_html": link}
if append:
cur = st.get_task(task_id=task_id) or task
desc = store.sanitize_description_html((cur.get("description") or "") + f"<p>{link}</p>")
try:
out["task"] = st.update_task(task_id=task_id, fields={"description": desc}, actor=user["email"],
assignee_allowed=_registered_project_user)
except (ValueError, KeyError):
# 파일은 올라갔다 — 링크만 못 붙임(화면이 링크를 알려 준다)
out["append_failed"] = True
return JSONResponse(out, status_code=201)
def _sync_drive_links(st: Any, task_id: int, removed: set[str], added: set[str]) -> None:
"""설명란 드라이브 링크가 빠지면 그 파일을 휴지통으로, 다시 생기면 휴지통에서 꺼낸다(백그라운드).
우리가 올린 파일(appProperties dbxTaskId)만, 그리고 다른 업무 설명에 같은 링크가 남아 있으면 휴지통에 넣지 않는다."""
from app.integrations import google_drive # noqa: WPS433
client = google_drive.get_client()
if not client.enabled:
return
for fid in removed:
try:
if st.description_mentions(text=fid, exclude_task_id=task_id):
continue
info = client.ours(fid)
if info and not info["trashed"]:
client.set_trashed(fid, True)
except Exception: # noqa: BLE001 — 저장은 이미 끝났다(파일만 남음)
logger.warning("드라이브 파일 휴지통 이동 실패: task=%s file=%s", task_id, fid)
for fid in added:
try:
info = client.ours(fid)
if info and info["trashed"]:
client.set_trashed(fid, False)
except Exception: # noqa: BLE001
logger.warning("드라이브 파일 복구 실패: task=%s file=%s", task_id, fid)
# ────────────────────────────────────────────────────────────
# JSON API — 단계 이름/순서 편집
# ────────────────────────────────────────────────────────────
@@ -3141,6 +3287,8 @@ def _goal_call(fn: Any, *args: Any, **kwargs: Any) -> Any:
raise HTTPException(status_code=503, detail="업무 칸(이미 있는 업무의 세부 업무로 등록)은 project_db 마이그레이션 026 적용 후 사용할 수 있습니다.")
except store.MeetingTaskMigrationNeeded:
raise HTTPException(status_code=503, detail="업무 등록 표(모두가 같이 보는 주차별 표)는 project_db 마이그레이션 025 적용 후 사용할 수 있습니다.")
except store.MeetingMigration030Needed:
raise HTTPException(status_code=503, detail="주차 목표 두 칸(유통·인플 / 카페24·네이버)은 project_db 마이그레이션 030 적용 후 사용할 수 있습니다.")
except store.MeetingMigration020Needed:
raise HTTPException(status_code=503, detail="새 주차·결과 글·주차별 목표는 project_db 마이그레이션 020 적용 후 사용할 수 있습니다.")
except store.GoalCellConflict as exc:
@@ -3193,12 +3341,23 @@ def goals_page(request: Request, year: int) -> HTMLResponse:
_goal_label_spans(area["rows"])
# 주차별 매출 목표(020) — 월 매출 목표 칸을 누르면 그 달 월 목표·주차별 입력 창(월 목표는 직접 입력)
week_targets = None
week_split = False
if board and st.week_targets_enabled():
saved = st.goal_week_targets(start=date(year, 1, 1), end=date(year, 12, 31))
# 기간 표기 — 11/1(일)~11/8(일), days = 그 주차 날 수
week_split = st.week_split_enabled()
parts = st.goal_week_target_parts(start=date(year, 1, 1), end=date(year, 12, 31))
def part(a: date, key: str) -> str:
p_ = parts.get(a.isoformat()) or {}
v = p_.get(key)
# 030 전에 한 칸으로 넣은 주차(두 칸 비고 합계만) — 합계를 유통·인플 칸에 미리 넣어 보여 준다
if key == "dist" and v is None and p_.get("mall") is None:
v = p_.get("total")
return _goal_label("sales", v)
# 기간 표기 — 11/1(일)~11/8(일), days = 그 주차 날 수. 두 칸(030) = dist 유통·인플 · mall 카페24·네이버
week_targets = {mo: [{"start": a.isoformat(), "n": i + 1, "days": (b - a).days + 1,
"label": f"{a.month}/{a.day}({_WEEKDAYS_KR[a.weekday()]})~{b.month}/{b.day}({_WEEKDAYS_KR[b.weekday()]})",
"value": _goal_label("sales", saved.get(a.isoformat()))}
"value": _goal_label("sales", (parts.get(a.isoformat()) or {}).get("total")),
"dist": part(a, "dist"), "mall": part(a, "mall")}
for i, (a, b) in enumerate(store.month_weeks(year, mo))] for mo in range(1, 13)}
return render_template(
request,
@@ -3228,6 +3387,7 @@ def goals_page(request: Request, year: int) -> HTMLResponse:
"this_month": this_month,
"goal_area_colors": list(store.GOAL_AREA_COLORS),
"week_targets": week_targets,
"week_split": week_split,
},
)
@@ -3241,17 +3401,31 @@ def api_set_goal_week_targets(request: Request, year: int, month: int, payload:
raw = payload.get("weeks")
if not isinstance(raw, dict) or len(raw) > 6:
raise HTTPException(status_code=400, detail="weeks 가 올바르지 않습니다.")
values = {_goal_call(store.validate_period_start, k): _goal_call(store.validate_goal_value, v) for k, v in raw.items()}
# 주차 값 = 숫자 하나(예전) 또는 {dist: 유통·인플, mall: 카페24·네이버}(030, 2026-10-19)
values: dict[date, Any] = {}
for k, v in raw.items():
d = _goal_call(store.validate_period_start, k)
if isinstance(v, dict):
values[d] = (_goal_call(store.validate_goal_value, v.get("dist")), _goal_call(store.validate_goal_value, v.get("mall")))
else:
values[d] = _goal_call(store.validate_goal_value, v)
def tot(v: Any) -> float | None:
if isinstance(v, tuple):
return None if v[0] is None and v[1] is None else (v[0] or 0) + (v[1] or 0)
return v
if "month" in payload:
month_value = _goal_call(store.validate_goal_value, payload.get("month"))
else:
filled = [v for v in values.values() if v is not None]
filled = [tot(v) for v in values.values() if tot(v) is not None]
month_value = sum(filled) if filled else None
week_total = _goal_call(st.set_goal_week_targets, year=year, month=month, values=values,
month_value=month_value, updated_by=user["email"])
return JSONResponse({"ok": True, "value": month_value, "label": _goal_label("sales", month_value),
"week_total": week_total,
"weeks": {k.isoformat(): _goal_label("sales", v) for k, v in values.items()}})
"weeks": {k.isoformat(): _goal_label("sales", tot(v)) for k, v in values.items()},
"parts": {k.isoformat(): {"dist": _goal_label("sales", v[0]), "mall": _goal_label("sales", v[1])}
for k, v in values.items() if isinstance(v, tuple)}})
@router.post("/api/goals/years")
@@ -3943,6 +4117,21 @@ def api_move_meeting_item(request: Request, item_id: int, payload: dict[str, Any
return JSONResponse({"ok": True})
@router.post("/api/goals/meeting-items/{item_id}/move-to")
def api_move_meeting_group(request: Request, item_id: int, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""항목 칸 끌어 옮기기 {before_item_id: 그 묶음 앞 | null = 구역 맨 끝} — 묶인 줄·병합은 통째로, 같은 구역 안만.
줄 순서와 같은 권한(누구나, 회의 완료 전까지)."""
_require_user(request)
st = _db_or_503(request)
before = payload.get("before_item_id")
try:
before = None if before in (None, "") else int(before)
except (TypeError, ValueError):
raise HTTPException(status_code=400, detail="before_item_id 가 올바르지 않습니다.")
moved = _goal_call(st.move_meeting_group, item_id=item_id, before_item_id=before)
return JSONResponse({"ok": True, "moved": bool(moved)})
@router.post("/api/goals/meeting-items/{item_id}/split-label")
def api_split_meeting_label(request: Request, item_id: int) -> JSONResponse:
"""항목 칸 나누기(027) — item_id = 묶음 첫 줄. 이어 붙은 줄들이 각자 항목 칸(이름 빈 칸)으로. 줄 순서와 같은 권한."""
+45
View File
@@ -375,6 +375,47 @@ def validate_time(t: Any) -> str | None:
return f"{hh:02d}:{mm:02d}"
# ════════════════════════════════════════════════════════════
# Project 옵션 — 시스템 전체 설정(마이그레이션 029 project_options, 수퍼관리자·Admin 수정)
# 폰트 같은 "일반" 옵션은 브라우저별(localStorage)이라 여기 없다.
# ════════════════════════════════════════════════════════════
PROJECT_VIEWS: tuple[str, ...] = ("board", "list", "calendar", "timeline", "dashboard")
PROJECT_OPTION_DEFAULTS: dict[str, Any] = {
"default_view": "board", # 왼쪽에서 프로젝트를 열 때 처음 보이는 탭
"board_cover": True, # 보드 카드 표지(설명의 첫 이미지)
}
def normalize_project_options(raw: dict[str, Any] | None) -> dict[str, Any]:
"""DB 에서 읽은 값 → 화면용. 모르는 키는 버리고, 이상한 값·없는 키는 기본값(읽기는 실패하지 않는다)."""
out = dict(PROJECT_OPTION_DEFAULTS)
raw = raw or {}
if raw.get("default_view") in PROJECT_VIEWS:
out["default_view"] = raw["default_view"]
if isinstance(raw.get("board_cover"), bool):
out["board_cover"] = raw["board_cover"]
return out
def validate_project_options(payload: Any) -> dict[str, Any]:
"""저장 요청 검사 — 보낸 키만 돌려준다(일부만 바꿀 수 있게). 모르는 키·잘못된 값·빈 요청은 ValueError."""
if not isinstance(payload, dict) or not payload:
raise ValueError("바꿀 옵션이 없습니다.")
unknown = set(payload) - set(PROJECT_OPTION_DEFAULTS)
if unknown:
raise ValueError("알 수 없는 옵션입니다: " + ", ".join(sorted(unknown)))
out: dict[str, Any] = {}
if "default_view" in payload:
if payload["default_view"] not in PROJECT_VIEWS:
raise ValueError("처음 여는 탭 값이 올바르지 않습니다.")
out["default_view"] = payload["default_view"]
if "board_cover" in payload:
if not isinstance(payload["board_cover"], bool):
raise ValueError("카드 표지 값이 올바르지 않습니다.")
out["board_cover"] = payload["board_cover"]
return out
# ════════════════════════════════════════════════════════════
# 연간 목표 (마이그레이션 013) — 사이드바 "목표" → 연도
# ════════════════════════════════════════════════════════════
@@ -444,6 +485,10 @@ class MeetingParentTaskMigrationNeeded(RuntimeError):
"""작업 등록 표의 작업 칸(이미 있는 작업의 세부 작업으로)은 마이그레이션 026 뒤에만 된다."""
class MeetingMigration030Needed(Exception):
"""주차 목표 두 칸(유통·인플 / 카페24·네이버)은 project_db 마이그레이션 030 필요."""
class MeetingMigration020Needed(RuntimeError):
"""새 주차(월요일이 아닌 시작일)·결과 글 칸·주차별 목표는 마이그레이션 020 뒤에만 된다."""
@@ -6,7 +6,7 @@
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>{{ page_title or '주간 회의록' }}</title>
<link rel="stylesheet" href="/static/erp.css?v=20260615b" />
<link rel="stylesheet" href="/static/erp-dialog.css?v=20260930a" />
<link rel="stylesheet" href="/static/erp-dialog.css?v=20261017a" />
{% block head_extra %}{% endblock %}
<link rel="stylesheet" href="/static/project-goal-nav.css?v=20261004e" />
<script>
@@ -17,6 +17,6 @@
</head>
<body class="erp-body">
<main class="erp-page">{% block content %}{% endblock %}</main>
<script src="/static/erp-dialog.js?v=20260930a"></script>
<script src="/static/erp-dialog.js?v=20261017a"></script>
</body>
</html>
@@ -1,25 +1,101 @@
{# Project 옵션 — 상단 바 톱니. 왼쪽 분류(일반·프로젝트 화면·보드·관리자) | 오른쪽 설정. 저장 버튼을 눌러야 한꺼번에 반영된다.
· 일반(폰트) — 모두에게 보이고 이 브라우저에만 저장(localStorage pj_font, 아래 인라인 스크립트가 복원).
· 프로젝트 화면(처음 여는 탭)·보드(카드 표지) — 수퍼관리자·Admin(pj_admin)만 보이고, 서버(project_options, 마이그레이션 029)에
저장해 모든 사용자에게 적용. 창을 열 때 GET /project/api/options, 저장은 PUT. project.html 이 data-default-view·
data-board-cover 로 받아 project.js 가 쓴다. 저장하면 "pj-options-change" 이벤트로 보던 보드에 바로 반영.
· 관리자(긴급 공지) — 수퍼관리자만(공지 화면이 수퍼관리자 전용). #}
<button type="button" class="pj-help-btn" id="pj-options-btn" aria-label="Project 옵션" title="Project 옵션">
<span class="material-symbols-outlined">settings</span>
</button>
<dialog class="pj-options-dialog" id="pj-options-dialog" aria-labelledby="pj-options-title">
<form id="pj-options-form">
<h2 id="pj-options-title">Project 옵션</h2>
<label for="pj-options-font">폰트</label>
<select id="pj-options-font" name="font">
<option value="system">기본 시스템 폰트</option>
<option value="pretendard">프리텐다드</option>
<option value="nanum-square">나눔 스퀘어</option>
<option value="nanum-square-neo">나눔 스퀘어 네오</option>
<option value="nanum-square-round">나눔 스퀘어 라운드</option>
</select>
<div class="pj-options-preview" id="pj-options-preview">프로젝트와 목표를 한눈에<br><b>Project · 업무 이름 · 가나다 123</b></div>
<p>이 브라우저의 모든 Project 화면에 적용됩니다.</p>
{% if user and user.is_super_admin %}<p class="pj-options-notice"><a class="pj-btn" href="/notice/"><span class="material-symbols-outlined" style="font-size:16px;vertical-align:-3px">campaign</span> 긴급 공지 만들기·관리</a> <small>ERP 전체 화면 가운데에 띄우는 공지(수퍼관리자)</small></p>{% endif %}
<p class="pj-options-error" id="pj-options-error" role="alert" hidden></p>
<div class="pj-options-actions">
<header class="pj-options-head">
<h2 id="pj-options-title"><span class="material-symbols-outlined">tune</span> Project 옵션</h2>
<button type="button" class="pj-options-x" id="pj-options-x" aria-label="닫기" title="닫기">
<span class="material-symbols-outlined">close</span>
</button>
</header>
<div class="pj-options-body">
<nav class="pj-options-nav" role="tablist" aria-orientation="vertical" aria-label="옵션 분류">
<button type="button" role="tab" class="is-active" aria-selected="true" aria-controls="pj-opt-pane-general" id="pj-opt-tab-general" data-pane="general">
<span class="material-symbols-outlined">text_fields</span>일반</button>
{% if pj_admin %}
<button type="button" role="tab" aria-selected="false" aria-controls="pj-opt-pane-view" id="pj-opt-tab-view" data-pane="view" tabindex="-1">
<span class="material-symbols-outlined">space_dashboard</span>프로젝트 화면</button>
<button type="button" role="tab" aria-selected="false" aria-controls="pj-opt-pane-board" id="pj-opt-tab-board" data-pane="board" tabindex="-1">
<span class="material-symbols-outlined">view_kanban</span>보드</button>
{% endif %}
{% if user and user.is_super_admin %}
<button type="button" role="tab" aria-selected="false" aria-controls="pj-opt-pane-admin" id="pj-opt-tab-admin" data-pane="admin" tabindex="-1">
<span class="material-symbols-outlined">admin_panel_settings</span>관리자</button>
{% endif %}
</nav>
<div class="pj-options-panes">
<section class="pj-options-pane" role="tabpanel" id="pj-opt-pane-general" aria-labelledby="pj-opt-tab-general" data-pane="general">
<h3>일반 <span class="pj-options-badge"><span class="material-symbols-outlined">computer</span>이 브라우저에만 적용</span></h3>
<div class="pj-options-group">
<div class="pj-options-row is-stack">
<label for="pj-options-font"><b>폰트</b><small>Project 화면 전체의 글꼴</small></label>
<select id="pj-options-font" name="font">
<option value="system">기본 시스템 폰트</option>
<option value="pretendard">프리텐다드</option>
<option value="nanum-square">나눔 스퀘어</option>
<option value="nanum-square-neo">나눔 스퀘어 네오</option>
<option value="nanum-square-round">나눔 스퀘어 라운드</option>
</select>
<div class="pj-options-preview" id="pj-options-preview">프로젝트와 목표를 한눈에<br><b>Project · 업무 이름 · 가나다 123</b></div>
</div>
</div>
</section>
{% if pj_admin %}
<section class="pj-options-pane" role="tabpanel" id="pj-opt-pane-view" aria-labelledby="pj-opt-tab-view" data-pane="view" hidden>
<h3>프로젝트 화면 <span class="pj-options-badge is-global"><span class="material-symbols-outlined">groups</span>모든 사용자에게 적용</span></h3>
<div class="pj-options-group">
<div class="pj-options-row is-stack">
<span class="pj-options-label" id="pj-options-view-label"><b>처음 여는 탭</b><small>왼쪽에서 프로젝트를 고르면 바로 보이는 보기</small></span>
<div class="pj-options-views" role="radiogroup" aria-labelledby="pj-options-view-label">
<label><input type="radio" name="default_view" value="board"><span class="material-symbols-outlined">view_kanban</span>보드</label>
<label><input type="radio" name="default_view" value="list"><span class="material-symbols-outlined">format_list_bulleted</span>목록</label>
<label><input type="radio" name="default_view" value="calendar"><span class="material-symbols-outlined">calendar_month</span>캘린더</label>
<label><input type="radio" name="default_view" value="timeline"><span class="material-symbols-outlined">view_timeline</span>타임라인</label>
<label><input type="radio" name="default_view" value="dashboard"><span class="material-symbols-outlined">monitoring</span>대시보드</label>
</div>
<small class="pj-options-note">왼쪽 "전체 보기"는 지금처럼 대시보드로 열립니다.</small>
</div>
</div>
</section>
<section class="pj-options-pane" role="tabpanel" id="pj-opt-pane-board" aria-labelledby="pj-opt-tab-board" data-pane="board" hidden>
<h3>보드 <span class="pj-options-badge is-global"><span class="material-symbols-outlined">groups</span>모든 사용자에게 적용</span></h3>
<div class="pj-options-group">
<label class="pj-options-row" for="pj-options-cover">
<span class="pj-options-label"><b>카드 표지 이미지</b><small>메인 업무 설명의 첫 이미지를 보드 카드 위에 보여 줍니다</small></span>
<span class="pj-switch"><input type="checkbox" role="switch" id="pj-options-cover" name="board_cover"><span aria-hidden="true"></span></span>
</label>
</div>
</section>
{% endif %}
{% if user and user.is_super_admin %}
<section class="pj-options-pane" role="tabpanel" id="pj-opt-pane-admin" aria-labelledby="pj-opt-tab-admin" data-pane="admin" hidden>
<h3>관리자</h3>
<div class="pj-options-group">
<div class="pj-options-row">
<span class="pj-options-label"><b>긴급 공지</b><small>ERP 전체 화면 가운데에 띄우는 공지(수퍼관리자)</small></span>
<a class="pj-btn" href="/notice/"><span class="material-symbols-outlined" style="font-size:16px;vertical-align:-3px">campaign</span> 만들기·관리</a>
</div>
</div>
</section>
{% endif %}
</div>
</div>
<footer class="pj-options-foot">
<button type="button" class="pj-btn pj-options-reset" id="pj-options-reset" title="모든 옵션을 처음 값으로(저장해야 반영)">기본값으로</button>
<p class="pj-options-error" id="pj-options-error" role="alert" hidden></p>
<button type="button" class="pj-btn" id="pj-options-cancel">취소</button>
<button type="submit" class="pj-btn pj-btn-primary" id="pj-options-save">저장</button>
</div>
</footer>
</form>
</dialog>
<script>
@@ -29,4 +105,4 @@
document.documentElement.dataset.pjFont = pf;
} catch (_) {}
</script>
<script src="/static/project-options.js?v=20261002g" defer></script>
<script src="/static/project-options.js?v=20261016c" defer></script>
@@ -1,7 +1,7 @@
{% extends "project/_meeting_content_base.html" if meeting_embedded else "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -50,24 +50,9 @@
{% endif %}
</span>
{% endif %}
{# 주차 탭 — 주차는 그 달 안(1일이 월~금이면 1일~일요일, 토·일이면 1일~다음 주 일요일, 말일이 월·화면 앞 주차에 붙음). 점 = 회의록 있음 #}
<nav class="pj-meet-weeks" aria-label="주차">
{% for w in weeks %}
<a class="pj-meet-week{% if w.start == week %} is-on{% endif %}{% if w.now %} is-now{% endif %}"
href="?week={{ w.start }}" title="{{ w.n }}주차 {{ w.label }}">
{# 날짜는 짧게 — 주차는 달을 넘지 않아 끝 월 생략(10/5~11) #}
{% set ws = w.start.split('-') %}{% set we = w.end.split('-') %}
<b>{{ w.n }}주차</b><span>{{ ws[1] | int }}/{{ ws[2] | int }}~{% if we[1] != ws[1] %}{{ we[1] | int }}/{% endif %}{{ we[2] | int }}</span>
{% if w.has %}<i class="pj-meet-dot" title="회의록 있음"></i>{% endif %}
{% if w.now %}<em>이번 주</em>{% endif %}
</a>
{% endfor %}
</nav>
</div>
{# ── 머리 영역 3칸(스크롤해도 보임 — 표만 아래 .pj-meet-pane 에서 스크롤) ──
① 월 계획 + 머리 줄 오른쪽에 숫자 4개를 작게 한 줄로 ② 결정 사항·메모 ③ 작업 빠른 등록 표(project.js initMeetQuickTasks) #}
<div class="pj-meet-board">
<section class="pj-meet-area pj-meet-plan">
<span class="pj-meet-title-break" aria-hidden="true"></span>
{# 월 계획 숫자 한 줄 — 주차 탭과 같은 줄 왼쪽(2026-10-19 — 제목 줄 안, 줄바꿈 뒤), 잘리지 않게. 카드 안 머리는 결정사항 제목만(왼쪽) #}
<div class="pj-meet-kpitop">
<div class="pj-meet-plan-head">
<span class="pj-meet-plan-title"><span class="material-symbols-outlined">event_note</span>{{ goal_month }}월 계획</span>
{% if h %}
@@ -93,26 +78,32 @@
</div>
{% endif %}
</div>
<div class="pj-meet-area-body">
{% if month_plan is none %}<p class="pj-meet-plan-empty">연간 목표 표가 없어 월 계획을 보여 줄 수 없습니다.</p>
{% elif month_plan %}
<div class="pj-meet-plan-grid">
{% for a in month_plan %}
<div class="pj-meet-plan-area" style="--goal-bg: {{ a.color or '#f4f5f7' }}">
<b class="pj-meet-plan-name">{{ a.name }}</b>
{% for it in a.lines %}
<div class="pj-meet-plan-item">{% if it.label %}<span class="pj-meet-plan-label">{{ it.label }}</span>{% endif %}<span class="pj-meet-plan-text">{{ it.text_html | safe }}</span>{% if it.range %}<em>{{ it.range }}</em>{% endif %}</div>
{% endfor %}
</div>
{% endfor %}
</div>
{# 주차 탭 — 주차는 그 달 안(1일이 월~금이면 1일~일요일, 토·일이면 1일~다음 주 일요일, 말일이 월·화면 앞 주차에 붙음). 점 = 회의록 있음 #}
<nav class="pj-meet-weeks" aria-label="주차">
{% for w in weeks %}
<a class="pj-meet-week{% if w.start == week %} is-on{% endif %}{% if w.now %} is-now{% endif %}"
href="?week={{ w.start }}" title="{{ w.n }}주차 {{ w.label }}">
{# 날짜는 짧게 — 주차는 달을 넘지 않아 끝 월 생략(10/5~11) #}
{% set ws = w.start.split('-') %}{% set we = w.end.split('-') %}
<b>{{ w.n }}주차</b><span>{{ ws[1] | int }}/{{ ws[2] | int }}~{% if we[1] != ws[1] %}{{ we[1] | int }}/{% endif %}{{ we[2] | int }}</span>
{% if w.has %}<i class="pj-meet-dot" title="회의록 있음"></i>{% endif %}
{% if w.now %}<em>이번 주</em>{% endif %}
</a>
{% endfor %}
</nav>
</div>
{# ── 머리 영역 3칸(스크롤해도 보임 — 표만 아래 .pj-meet-pane 에서 스크롤) ──
① 월 계획 + 머리 줄 오른쪽에 숫자 4개를 작게 한 줄로 ② 결정 사항·메모 ③ 작업 빠른 등록 표(project.js initMeetQuickTasks) #}
<div class="pj-meet-board">
{# ①② 한 칸(2026-10-19) — 결정사항 제목(왼쪽) + 아래 전체 = 결정사항 내용(크게). 월 계획 숫자는 카드 위 .pj-meet-kpitop,
예전 월 계획 상세(목표 표 그 달 글)는 뺐다 #}
<section class="pj-meet-area pj-meet-plan pj-meet-notes pj-meet-pn">
<div class="pj-meet-pn-head">
<h3 class="pj-meet-pn-title">결정사항 : 진행상황 수시 공유 및 완료 되어야 함</h3>
</div>
{% else %}<p class="pj-meet-plan-empty">목표 표에 {{ goal_month }}월 계획이 아직 없습니다.</p>{% endif %}
</div>
</section>
<section class="pj-meet-area pj-meet-notes">
<h3>결정사항 : 진행상황 수시 공유 및 완료 되어야 함</h3>
{% if meeting %}
{% if not meeting.completed %}<textarea id="pj-meet-notes" rows="4" placeholder="이번 회의에서 정한 것, 다음 주까지 확인할 것">{{ meeting.notes }}</textarea>
{% if not meeting.completed %}<textarea id="pj-meet-notes" rows="6" placeholder="이번 회의에서 정한 것, 다음 주까지 확인할 것">{{ meeting.notes }}</textarea>
{% else %}<div class="pj-meet-ro">{{ meeting.notes or '—' }}</div>{% endif %}
{% else %}<p class="pj-meet-plan-empty">이 주차 회의록을 만들면 적을 수 있습니다.</p>{% endif %}
</section>
@@ -298,5 +289,5 @@
<script src="/static/project-goal-text.js?v=20261003d" defer></script>
<script src="/static/project-meeting-cells.js?v=20261012a" defer></script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -202,10 +202,10 @@
</div>
{% if goal_area_colors %}<script>window.PJ_GOAL_COLORS = {{ goal_area_colors | tojson }};</script>{% endif %}
{% if week_targets %}<script>window.PJ_GOAL_WEEKS = {{ week_targets | tojson }}; window.PJ_GOAL_UNIT = {{ (board.sales_unit if board else '') | tojson }};</script>{% endif %}
{% if week_targets %}<script>window.PJ_GOAL_WEEKS = {{ week_targets | tojson }}; window.PJ_GOAL_WEEK_SPLIT = {{ (week_split or false) | tojson }}; window.PJ_GOAL_UNIT = {{ (board.sales_unit if board else '') | tojson }};</script>{% endif %}
{% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project-goal-text.js?v=20261003d" defer></script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
+24 -10
View File
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/project-help.css?v=20261003a" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -116,8 +116,13 @@
<li><span class="pjh-ui"><span class="material-symbols-outlined">notifications</span></span> 종 아이콘 — 읽지 않은 알림 수가 표시되고, 누르면 수신함으로 갑니다.</li>
<li><span class="pjh-ui"><span class="material-symbols-outlined">fit_screen</span></span> 화면 배율 — 누르면(파랗게 켜짐) 화면 전체를 75%로 줄입니다. 2880×1620 모니터를 Windows 배율 200%로 쓰면 화면이 꽉 차 보이는데, 이때 켜면 1920×1080 모니터와 같은 모습이 됩니다. 브라우저마다 기억합니다. 메뉴·말풍선 같은 작은 팝업은 원래 크기로 뜹니다.</li>
<li><span class="pjh-ui"><span class="material-symbols-outlined">help</span></span> 물음표 — 지금 보고 있는 이 도움말을 새 탭으로 엽니다.</li>
<li><span class="pjh-ui"><span class="material-symbols-outlined">settings</span></span> 도움말 오른쪽의 옵션 — 폰트를 고르고 미리 본 뒤 <span class="pjh-ui">저장</span>을 누르면 Project 화면에 적용되고 창이 닫힙니다.
기본 시스템 폰트·프리텐다드·나눔 스퀘어·나눔 스퀘어 네오·나눔 스퀘어 라운드 중 선택할 수 있습니다. 설정은 이 브라우저의 모든 Project 화면에서 기억합니다. <span class="pjh-ui">취소</span>는 변경을 적용하지 않고 닫습니다.</li>
<li><span class="pjh-ui"><span class="material-symbols-outlined">settings</span></span> 도움말 오른쪽의 옵션 — 왼쪽 분류를 골라 설정을 바꾸고 <span class="pjh-ui">저장</span>을 누르면 한꺼번에 적용되고 창이 닫힙니다.
<b>일반</b>: 폰트(기본 시스템 폰트·프리텐다드·나눔 스퀘어·나눔 스퀘어 네오·나눔 스퀘어 라운드, 미리보기) — 누구나 바꿀 수 있고 이 브라우저에만 적용됩니다.
아래 프로젝트 화면·보드 분류는 수퍼관리자·Admin 에게만 보이고, 바꾸면 <b>모든 사용자</b>에게 적용됩니다(다른 사람은 다음에 화면을 열 때부터). 관리자(긴급 공지) 분류는 수퍼관리자에게만 보입니다.
분류 제목 옆 표시(이 브라우저에만 / 모든 사용자에게)로 적용 범위를 알 수 있습니다.
<b>프로젝트 화면</b>: 처음 여는 탭 — 왼쪽에서 프로젝트를 고르면 바로 보일 보기(보드·목록·캘린더·타임라인·대시보드). 왼쪽 "전체 보기"는 늘 대시보드로 열립니다.
<b>보드</b>: 카드 표지 이미지 — 끄면 메인 업무 설명에 이미지가 있어도 보드 카드에 표지를 보여 주지 않습니다(보던 보드에 바로 반영).
<span class="pjh-ui">기본값으로</span>는 창 안의 값만 처음으로 돌립니다(저장해야 반영). <span class="pjh-ui">취소</span>는 변경을 적용하지 않고 닫습니다.</li>
</ul>
<h3>프로젝트 제목</h3>
<p>가운데 위 프로젝트 제목에 마우스를 올리면 테두리가 생깁니다. 누르면 그 자리에서 이름을 고칩니다 — <kbd>Enter</kbd>나 바깥을 누르면 저장, <kbd>Esc</kbd>는 취소. (그 프로젝트 멤버인 Pro user 이상만)</p>
@@ -273,7 +278,9 @@
<li><b>열기</b> — 카드를 누르면 오른쪽에 업무 편집 창이 열립니다. (<a href="#task">8장</a>)</li>
<li><b>완료 체크</b> — 카드 제목 왼쪽의 원형 체크 버튼을 누르면 완료됩니다. 완료된 업무는 <b>녹색 원 안 흰 체크</b>와 흐린 회색 제목으로 표시되며 취소선은 없습니다. 다시 누르면 완료를 취소합니다. 읽기 전용 업무는 상태만 표시합니다.</li>
<li><b>담당자·마감일 바로 바꾸기</b> — 카드의 사람 아이콘이나 날짜를 누르면 그 자리에서 바꿉니다. 비어 있으면 카드에 마우스를 올렸을 때 점선 원 아이콘이 나타납니다.</li>
<li><b>옮기기</b> — 카드를 끌어 다른 섹션에 놓으면 섹션이 바뀌고, 같은 섹션 안에서 위아래로 놓으면 순서가 바뀝니다.</li>
<li><b>파일 → 구글 드라이브</b> — 컴퓨터의 파일을 카드 위로 끌어 오면 카드에 점선과 <span class="pjh-ui">놓으면 드라이브에 올리고 설명에 링크</span>가 보이고, 놓으면 구글 드라이브 업무 폴더에 올라간 뒤 그 업무 설명 끝에 <b>파일 이름.확장자</b> 링크가 붙습니다(여러 개 가능). 펼친 세부 업무 줄에 놓으면 그 세부 업무 설명에 붙습니다. 자세한 규칙은 <a href="#task-drive">구글 드라이브 파일</a>.</li>
<li><b>옮기기</b> — 카드를 끌어 다른 섹션에 놓으면 섹션이 바뀌고, 같은 섹션 안에서 위아래로 놓으면 순서가 바뀝니다.
끄는 동안 카드는 살짝 기울어진 모양으로 마우스를 따라오고, 카드 사이를 지나는 순간 <b>점선 자리</b>가 그 사이로 옮겨 가며 다른 카드가 미끄러지듯 비켜납니다 — 놓으면 그 자리에 그대로 들어갑니다(다른 섹션도 같음). 섹션 밖에 놓으면 원래 자리로 돌아갑니다.</li>
<li><b>우클릭 메뉴</b> — <span class="pjh-ui">열기 · 업무 링크 복사 · 완료로 표시 · 삭제</span></li>
<li><b>댓글</b> — 카드의 <span class="pjh-ui">💬 N</span>을 한 번 누르면 댓글 대화창이 열립니다. (<a href="#comments">16장</a>)</li>
</ul>
@@ -344,11 +351,17 @@
<li><b>체크박스(체크리스트)</b> — 글머리 목록처럼 씁니다. <span class="pjh-ui"><span class="material-symbols-outlined">check_box</span></span>를 누르면 지금 줄(또는 고른 줄들)이 체크리스트가 되어 줄마다 체크박스가 붙습니다. <kbd>Enter</kbd>로 새 줄을 만들면 체크박스도 함께 생기고, 빈 줄에서 <kbd>Enter</kbd>를 누르면 목록이 끝납니다. 체크박스를 누르면 체크되고 그 줄은 흐리게 취소선이 그어집니다. 다시 <span class="pjh-ui"><span class="material-symbols-outlined">check_box</span></span>를 누르면 평범한 글로, 글머리·번호 버튼을 누르면 그 목록으로 바뀝니다. 체크 상태도 바로 저장됩니다.</li>
<li><b>이미지</b> — 캡처한 그림을 <kbd>Ctrl</kbd>+<kbd>V</kbd>로 바로 붙여 넣을 수 있습니다. 그림을 누르면 모서리를 끌어 크기를 바꾸거나 지울 수 있습니다.
그림을 누른 채 <kbd>Ctrl</kbd>+<kbd>C</kbd>를 누르면 그림이 복사되어 카카오톡·한글·그림판 등에 그대로 붙습니다. 그림을 더블클릭해 연 창에서는 아래 <span class="pjh-ui">복사</span> 버튼이나 <kbd>Ctrl</kbd>+<kbd>C</kbd>로 복사합니다(마우스 오른쪽 메뉴의 "이미지 복사"는 일부 프로그램에서 빈칸으로 붙을 수 있습니다).</li>
<li><b>링크</b> — 웹 주소를 붙여 넣으면 자동으로 링크가 되고, 누르면 새 탭에서 열립니다.</li>
<li><b>링크</b> — 웹 주소를 붙여 넣으면 자동으로 링크가 되고, 누르면 새 탭에서 열립니다. 링크는 <b><i><u>굵게·기울임·밑줄</u></i></b>로 보이고 <b>한 글자처럼</b> 다뤄집니다 — 링크 바로 뒤에서 <kbd>Backspace</kbd>, 바로 앞에서 <kbd>Delete</kbd>를 한 번 누르면 링크 전체가 지워집니다(<kbd>Ctrl</kbd>+<kbd>Z</kbd>로 되살림). 링크 글자를 고치려면 지우고 다시 넣습니다.</li>
<li><b>@태그</b> — <kbd>@</kbd>를 누르면 사람 목록이 뜹니다. 고른 사람의 수신함에 이 업무가 쌓입니다.</li>
</ul>
<h3>첨부 파일</h3>
<p><span class="pjh-ui">파일 추가</span>로 파일을 올립니다(한 파일 최대 20MB). 파일 이름 옆에 이미지·엑셀·텍스트·PPT·문서·PDF 형식별 아이콘이 표시됩니다. 파일 이름을 누르면 내려받고, <span class="pjh-ui">×</span>로 지웁니다.</p>
<p><b>끌어 놓기</b> — 컴퓨터의 파일을 업무 창의 설명란·세부 업무 목록 <b>밖</b>에 끌어 오면 창 전체에 점선 안내가 뜨고, 놓으면 첨부 파일로 올라갑니다(여러 개 한꺼번에). 설명란·세부 업무 목록에 놓으면 첨부가 아니라 구글 드라이브에 올라갑니다(아래). 아직 제목을 쓰지 않은 새 업무·읽기 전용 업무에는 넣을 수 없습니다.</p>
<h3 id="task-drive">구글 드라이브 파일</h3>
<p><b>설명란에 파일 끌어 놓기</b> — 설명란 위에 점선과 <span class="pjh-ui">놓으면 구글 드라이브에 올리고 이 자리에 링크</span>가 보이고, 놓으면 구글 드라이브에 올라간 뒤 <b>놓은 자리</b>에 <b>파일 이름.확장자</b> 링크가 들어갑니다(누르면 새 탭에서 드라이브 파일). 올리는 동안은 그 자리에 <span class="pjh-ui">구글 드라이브에 올리는 중…</span>이 보입니다.</p>
<p><b>세부 업무에 놓기</b> — 업무 창 세부 업무 목록의 줄, 보드 카드의 펼친 세부 업무 줄에 놓으면 그 세부 업무 설명 끝에 링크가 붙습니다. 세부 업무 목록의 빈 곳·보드 카드에 놓으면 그 업무 설명 끝에 붙습니다.</p>
<p><b>폴더</b> — 업무 파일 폴더 아래 <b>프로젝트 이름 / 섹션 이름 / 업무 이름 / 세부 업무 이름</b> 폴더를 자동으로 만들어 넣습니다(같은 이름 폴더가 있으면 그 폴더). 폴더는 올릴 때의 이름으로 만들어지고, 나중에 업무 이름을 바꿔도 이미 만든 폴더 이름은 그대로입니다.</p>
<p><b>링크를 지우면</b> — 설명에서 링크를 지우고 저장되면 그 파일이 구글 드라이브 <b>휴지통</b>으로 갑니다(30일 안에는 드라이브 휴지통에서 되살릴 수 있고, 링크를 다시 붙여 넣거나 되돌리기로 살리면 휴지통에서 자동으로 꺼냅니다). 같은 링크가 다른 업무 설명에 남아 있으면 지우지 않습니다. 여기서 올린 파일만 해당되고, 직접 붙여 넣은 다른 드라이브 링크는 건드리지 않습니다.</p>
<h3>프로젝트 (다른 프로젝트에 추가)</h3>
<p>업무 하나를 <b>여러 프로젝트의 보드에 동시에</b> 보이게 합니다. 예) 신상품 프로젝트의 업무를 디자인 프로젝트 보드에도 올리기. 협업자 아래의 프로젝트 줄에 연결 목록·프로젝트 선택·섹션 선택·추가 버튼이 한 줄로 표시됩니다. 창이 좁으면 이 줄을 좌우로 스크롤할 수 있습니다.</p>
<ol class="pjh-steps">
@@ -556,7 +569,7 @@
<h3 id="goals-metrics">매출·로아스 입력과 달성률 계산</h3>
<table class="pjh-table">
<tr><th>칸</th><th>입력·계산 방법</th></tr>
<tr><td>매출 목표</td><td>월 칸을 누르면 그 달 입력 창이 열립니다. 맨 위 <b>월 전체 목표</b>를 직접 넣고, 아래에 <b>주차별 목표</b>(매출 단위)를 넣은 뒤 <span class="pjh-ui">저장</span>합니다. 월 목표는 주차 합계와 따로 저장되고, 맨 아래에 <b>주차 합계</b>와 <b>차이(월 목표 − 주차 합계)</b>가 나옵니다 — +면 아직 주차에 못 나눈 금액, −면 주차 합계가 월 목표를 넘은 것입니다. 주차는 <a href="#meetings-week">주간 회의록 주차</a>와 같습니다.</td></tr>
<tr><td>매출 목표</td><td>월 칸을 누르면 그 달 입력 창이 열립니다. 맨 위 <b>월 전체 목표</b>를 직접 넣고, 아래에 <b>주차별 목표</b>(매출 단위)를 주차마다 두 칸 — 왼쪽 <b>유통·인플</b>, 오른쪽 <b>카페24·네이버</b> — 으로 넣은 뒤 <span class="pjh-ui">저장</span>합니다(주차 목표 = 두 칸 합계, 회의록 누적 목표도 이 합계). 월 목표는 주차 합계와 따로 저장되고, 맨 아래에 <b>주차 합계</b>와 <b>차이(월 목표 − 주차 합계)</b>가 나옵니다 — +면 아직 주차에 못 나눈 금액, −면 주차 합계가 월 목표를 넘은 것입니다. 주차는 <a href="#meetings-week">주간 회의록 주차</a>와 같습니다.</td></tr>
<tr><td>매출 실적</td><td>Pro user 이상이 월별 숫자를 직접 입력합니다. 목표 표의 실적은 회의록의 자동 매출과 별도로 관리하므로 실적 모듈에서 자동으로 채워지지 않습니다.</td></tr>
<tr><td>매출 단위</td><td>예를 들어 단위가 <b>백만원</b>이면 30은 30,000,000원입니다. 단위를 바꿔도 이미 적은 숫자는 자동 환산되지 않으므로 숫자와 단위를 함께 확인하세요.</td></tr>
<tr><td>연간·분기 매출</td><td>해당 기간에 입력한 월 숫자의 합계입니다. 합계 칸에 따로 입력하지 않습니다.</td></tr>
@@ -634,10 +647,10 @@
</ul>
<h3 id="meetings-month-plan">이 달 계획 확인</h3>
<p>제목 아래 <span class="pjh-ui">해당 월 계획</span>은 연간 목표 표에 적은 월 계획을 업무 영역별로 보여 줍니다. 굵게·기울임·밑줄·글자 색상과 줄바꿈·들여쓰기를 유지하고, 글자 크기는 월 계획의 기본 크기로 표시합니다. 빈 계획은 생략하고, 병합 칸은 해당 월을 포함하는 계획을 한 번 표시합니다. 여기서는 읽기만 하므로 수정하려면 연간 목표 표로 돌아갑니다.</p>
<p>월 계획 상세(연간 목표 표의 그 달 글)는 회의록 위쪽에 보이지 않습니다 — 연간 목표 표에서 확인합니다.</p>
<h3 id="meetings-kpis">위쪽 3칸 — 월 계획·숫자, 결정 사항, 업무 등록</h3>
<p>제목 아래 세 칸은 표를 스크롤해도 그대로 보입니다. 왼쪽은 <b>월 계획</b>이고 그 머리 줄 오른쪽에 숫자 4개(월 목표 · 누적 목표 · 누적 실적 · 목표 대비)가 작게 한 줄로 나옵니다(목표 표 매출 단위, 예: 백만원 — 숫자에 마우스를 올리면 원 단위 금액과 뜻). 가운데는 <b>결정사항</b>(진행상황 수시 공유 및 완료 되어야 할 것), 오른쪽은 <b>업무 등록</b> 표입니다.</p>
<h3 id="meetings-kpis">위쪽 — 월 계획 숫자·결정 사항, 업무 등록</h3>
<p>제목 아래 두 칸은 표를 스크롤해도 그대로 보입니다. 왼쪽 칸 머리 한 줄에 <b>N월 계획</b>과 숫자 4개(월 목표 · 누적 목표 · 누적 실적 · 목표 대비, 목표 표 매출 단위 예: 백만원 — 숫자에 마우스를 올리면 원 단위 금액과 뜻)와 <b>결정사항</b> 제목이 나오고, 그 아래 칸 전체가 <b>결정사항</b>(진행상황 수시 공유 및 완료 되어야 할 것) 입력란입니다. 오른쪽은 <b>업무 등록</b> 표입니다.</p>
<ol class="pjh-steps">
<li><b>업무 등록</b>(제목에 <b>N주차 업무 등록</b>) — 주차마다 한 표를 <b>모두가 같이</b> 봅니다(다른 사람이 적거나 등록한 줄도 보임, 30초마다·창을 다시 볼 때 새로 읽음). 내가 멤버가 아닌 프로젝트를 고른 남의 줄은 프로젝트 이름을 가립니다. 회의 완료면 읽기 전용입니다.
<b>업무</b> 칸 — 비워 두면 고른 섹션에 새 업무로, 업무를 고르면 <b>그 업무의 세부 업무</b>로 등록합니다(목록 = 그 섹션의 진행 중인 메인 업무, 고르면 섹션 칸은 —). 등록된 줄의 <b>제목을 누르면 오른쪽에 업무 창</b>이 열려 바로 편집할 수 있습니다(업무 창에서 저장이 끝나야 닫히거나 다른 업무로 바뀝니다).
@@ -702,6 +715,7 @@
<ul>
<li>구역 이름 옆 <span class="pjh-ui">+</span>는 그 구역 끝에 줄을 추가합니다. 표 아래 <span class="pjh-ui">+ 구역 추가</span>로 새 구역을 만듭니다.</li>
<li>항목 이름을 클릭하면 그 자리에서 고칩니다. 우클릭 또는 ⋯ 메뉴에서 <span class="pjh-ui">위에 줄 추가 · 아래에 줄 추가 · 위로 · 아래로 · 줄 삭제</span>를 사용합니다. 순서 이동은 같은 구역 안에서 합니다.</li>
<li><b>끌어서 순서 바꾸기</b> — <b>항목</b> 칸을 잡고 위아래로 끌면 그 줄(항목 칸으로 묶인 줄·세로 병합 포함)이 마우스를 따라 다른 항목 사이로 바로 옮겨 가고, 놓으면 저장됩니다. 같은 구역 안에서만 움직이며 <kbd>Esc</kbd>는 취소. 살짝 누르기만 하면 예전처럼 이름 수정입니다.</li>
<li><b>주요 업무</b> 칸을 우클릭해 <span class="pjh-ui">위에 줄 추가 · 아래에 줄 추가</span>를 하면 <b>항목 칸은 그대로</b> 두고 그 항목 안에 줄이 늘어납니다(줄마다 주요 업무·정량 목표는 따로). 같은 메뉴의 <span class="pjh-ui">줄 삭제</span>는 그 한 줄만 지웁니다. 묶인 항목 칸은 항목 칸 메뉴의 <span class="pjh-ui">항목 칸 나누기</span>로 다시 나눕니다. 줄을 추가·삭제하면 새로고침 없이 표가 그 자리에서 움직이며 바뀝니다.</li>
<li><b>구역 순서</b> — 첫 열 <b>구분</b> 칸을 우클릭하거나 마우스를 올려 나오는 <span class="pjh-ui">⋯</span>를 누르면 <span class="pjh-ui">구역 위로 · 구역 아래로 · 구역 끝에 줄 추가</span>가 나옵니다. 구역 안의 줄 순서·병합은 그대로 함께 옮겨지고, 다음에 만드는 회의록도 바뀐 순서를 이어받습니다(회의 완료 전까지, 누구나).</li>
<li>줄을 삭제하면 주요 업무·정량 목표도 함께 삭제됩니다. 새 줄은 지난주에 이어진 항목이 없으면 지난주 리뷰가 비어 있습니다.</li>
@@ -729,7 +743,7 @@
<p><b>Q. 프로젝트가 목록에 안 보여요.</b><br>그 프로젝트의 멤버가 아니면 보이지 않습니다. 그 프로젝트의 Pro user 이상 멤버나 관리자에게 멤버 배정을 부탁하세요.</p>
<p><b>Q. 삭제 버튼을 눌렀는데 “삭제는 만든 사람만 할 수 있습니다”라고 나와요.</b><br>섹션·프로젝트는 만든 사람(또는 Admin 이상)만 지울 수 있습니다. 업무는 멤버 누구나 휴지통으로 지울 수 있습니다.</p>
<p><b>Q. 업무를 잘못 지웠어요.</b><br>3개월 안이라면 Pro user 이상이 휴지통에서 복구할 수 있습니다.</p>
<p><b>Q. 카드 순서를 끌어도 안 바뀌어요.</b><br>필터를 쓰고 있거나 정렬이 “기본”이 아니면 순서를 바꿀 수 없습니다. 필터 바의 <span class="pjh-ui">초기화</span>를 누른 뒤 다시 해 보세요.</p>
<p><b>Q. 카드 순서를 끌어도 안 바뀌어요.</b><br>정렬이 “기본”이 아니면 순서를 바꿀 수 없습니다. 필터 바의 정렬을 <span class="pjh-ui">기본</span>으로 바꾼 뒤 다시 해 보세요. 필터(상태·담당자 등)를 켜 둔 채로는 바꿀 수 있고, 필터로 숨은 업무는 제자리에 그대로 있습니다.</p>
<p><b>Q. 다른 사람이 바꾼 내용이 안 보여요.</b><br>보통 8초 안에 자동으로 반영됩니다. 오래 걸리면 새로고침(<kbd>F5</kbd>)하세요.</p>
<p><b>Q. 세부 업무를 다른 프로젝트 업무로 옮길 수 있나요?</b><br>세부 업무는 같은 프로젝트 안의 업무로만 옮길 수 있습니다.</p>
<p><b>Q. 업무를 두 프로젝트에 같이 두고 싶어요.</b><br>업무 편집 창의 “프로젝트” 칸에서 <span class="pjh-ui">다른 프로젝트에 추가</span>를 쓰세요. (<a href="#task">8장</a>)</p>
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -106,5 +106,5 @@
{% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -100,5 +100,5 @@
"today": {{ today | tojson }}
}
</script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -108,5 +108,5 @@
});
})();
</script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<!-- 구글 머티리얼 심볼(담당자 아이콘 등) — self-host -->
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<!-- 타임라인 vis-timeline — self-host -->
@@ -29,6 +29,8 @@
data-can-manage="{{ 'true' if can_manage else 'false' }}"
data-is-pro="{{ 'true' if pj_pro else 'false' }}" data-is-padmin="{{ 'true' if pj_admin else 'false' }}"
data-is-super="{{ 'true' if user.is_super_admin else 'false' }}"
data-default-view="{{ pj_options.default_view if pj_options else 'board' }}"
data-board-cover="{{ '0' if pj_options and not pj_options.board_cover else '1' }}"
data-me="{{ user.email }}">
<div class="pj-layout">
@@ -377,7 +379,7 @@
<div class="pj-extra-head">
<span class="material-symbols-outlined pj-gicon pj-gicon-sm">attach_file</span> 첨부 파일
<label class="pj-upload-btn">
파일 추가<input type="file" id="pj-attach-input" hidden />
파일 추가<input type="file" id="pj-attach-input" multiple hidden />
</label>
</div>
<ul class="pj-attach-list" id="pj-attach-list"></ul>
@@ -470,5 +472,5 @@
</script>
<script src="/static/vendor/vis-timeline/vis-timeline-graph2d.min.js"></script>
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/project.css?v=20261015e" />
<link rel="stylesheet" href="/static/project.css?v=20261019j" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
{% endblock %}
@@ -70,5 +70,5 @@
{% include "project/_side_modals.html" %}
{% include "project/_member_tasks_modal.html" %}
<script src="/static/project.js?v=20261015c" defer></script>
<script src="/static/project.js?v=20261019g" defer></script>
{% endblock %}
+7
View File
@@ -0,0 +1,7 @@
# [휴가] 휴가 관리 모듈 — `app/modules/vacation/`, `vacation_db`
> 이 모듈만 고칠 때 읽는 요약. 별도 상세 문서 없음 — 코드가 기준.
> 정적 파일: `app/static/vacation.css`, `app/static/vacation.js`. 템플릿: `templates/`.
- 월간 달력(구글식 bar) / 연차·반차 신청 / 승인 워크플로 / 공휴일·연차 설정.
- 권한키 `vacation`(사용)·`vacation_approver`(승인).
+43 -1
View File
@@ -68,7 +68,8 @@
openBtn.addEventListener("click", function () {
var nameEl = document.getElementById("cf24-name-text");
modal.open((nameEl ? nameEl.textContent : "") + " (상품번호 " + no + ")");
state.productName = nameEl ? nameEl.textContent.trim() : "";
modal.open(state.productName + " (상품번호 " + no + ")");
myGen = modal.gen;
load();
});
@@ -233,6 +234,34 @@
return state.imageBase ? state.imageBase + (path.charAt(0) === "/" ? "" : "/") + path : "";
}
// 이미지 주소 → 쇼핑몰 기준 경로("/web/product/…"). 도메인·CDN 주소(이중 주소 포함)는 뗀다.
function shopPath(url) {
url = String(url || "").trim();
var at = url.lastIndexOf("/web/");
if (at >= 0) return url.slice(at);
return url.indexOf("web/") === 0 ? "/" + url : url;
}
// 모바일 스와이프(product-swiper.js)에 붙여 넣을 품목코드 → 썸네일 경로 목록.
// 썸네일은 행에 **지금 보이는** 이미지(버튼 → 연결 → 품목 이미지, 깨진 후보는 건너뛴 결과)다.
// // 상품명
// "P00000CM000A": "/web/product/extra/202503/….jpg",
function swipeCode(tbody) {
var lines = ["// " + (state.productName || ("상품번호 " + no))];
var count = 0;
var missing = 0;
tbody.querySelectorAll("tr").forEach(function (tr) {
var code = tr.dataset.code;
if (!code) return; // 아직 품목코드 없는 행(새 행·생성 대기)
var img = tr.querySelector("img.cf24-opt-thumb");
var path = img ? shopPath(img.getAttribute("src")) : "";
if (!path) missing++;
lines.push(' "' + code + '": "' + path + '",');
count++;
});
return { text: lines.join("\n"), count: count, missing: missing };
}
// 후보(버튼 이미지 → 연결 이미지 → 품목 image) 중 첫 번째를 보여주고, 깨지면 다음
// 후보로 넘어간다(cf24ThumbFallback). 전부 실패하면 "없음".
var THUMB_EMPTY = '<div class="cf24-opt-thumb-empty">없음</div>';
@@ -367,6 +396,7 @@
' <label class="cf24-side-field cf24-u-optname"><span>옵션명</span><input type="text" name="option_name" value="' + esc(group.option_name) + '" placeholder="예: 구성" /></label>' +
' <label class="cf24-side-field cf24-side-field-type"><span>표시방식</span>' + typeSelect(group.option_display_type || DEFAULT_TYPE, "option_display_type") + "</label>" +
' <span class="cf24-u-head-actions">' +
(isNew ? "" : ' <button type="button" class="erp-btn erp-btn-outline" id="cf24-u-swipe" title="품목코드와 썸네일 경로를 모바일 스와이프(product-swiper.js) 형식으로 복사합니다">모바일 스와이프 코드 복사</button>') +
' <button type="button" class="erp-btn erp-btn-outline" id="cf24-u-import">옵션값 불러오기</button>' +
' <button type="button" class="erp-btn erp-btn-outline" id="cf24-u-add">+ 행 추가</button>' +
" </span>" +
@@ -416,6 +446,18 @@
tr.querySelector('[name="option_text"]').focus();
});
body.querySelector("#cf24-u-import").addEventListener("click", function () { openImport(isNew, tbody, msg); });
var swipeBtn = body.querySelector("#cf24-u-swipe");
if (swipeBtn) swipeBtn.addEventListener("click", function () {
var out = swipeCode(tbody);
if (!out.count) { window.erpAlert("품목코드가 있는 행이 없습니다."); return; }
copyText(out.text, function () {
var old = swipeBtn.textContent;
swipeBtn.textContent = "복사됨";
setTimeout(function () { swipeBtn.textContent = old; }, 1200);
msg.textContent = "스와이프 코드 " + out.count + "개 품목 복사" +
(out.missing ? " — 썸네일 없는 품목 " + out.missing + "개는 경로가 비어 있습니다" : "");
});
});
body.querySelector("#cf24-u-save").addEventListener("click", function () { saveUnified(isNew, tbody, msg); });
var del = body.querySelector("#cf24-opt-delete");
if (del) del.addEventListener("click", deleteOptions);
+16
View File
@@ -4,6 +4,22 @@
없다. 화면 정중앙에 같은 모양으로 띄우기 위해 직접 그린다(erp-dialog.js).
════════════════════════════════════════════════════ */
/* 모달 <dialog> 위에 띄울 때 감싸는 껍데기(erp-dialog.js) — 모양은 안쪽 .erp-dialog-backdrop 그대로, 껍데기는 보이지 않게 */
.erp-dialog-host {
position: fixed;
inset: 0;
width: 100%;
height: 100%;
max-width: none;
max-height: none;
margin: 0;
padding: 0;
border: 0;
background: transparent;
overflow: visible;
}
.erp-dialog-host::backdrop { background: transparent; }
.erp-dialog-backdrop {
position: fixed;
inset: 0;
+19 -1
View File
@@ -116,11 +116,23 @@
var previous = document.activeElement;
var closed = false;
// 모달 <dialog>(showModal — 브라우저 맨 위 층)가 열려 있으면 body 에 붙인 창은 그 뒤에 깔려 안 보이고 눌리지도 않는다
// (예: 입출고 옵션 팝업 안 [지우기] 확인). 그때만 이 창도 모달 <dialog> 로 감싸 그 위에 띄운다. 평소엔 예전 그대로.
var host = null;
try {
if (document.querySelector("dialog[open]:modal")) {
host = document.createElement("dialog");
host.className = "erp-dialog-host";
host.addEventListener("cancel", function (e) { e.preventDefault(); close(false); }); // Esc = 취소
}
} catch (_) { host = null; } // :modal 을 모르는 아주 옛 브라우저
function close(result) {
if (closed) return;
closed = true;
document.removeEventListener("keydown", onKey, true);
el.backdrop.remove();
if (host) { if (host.open) host.close(); host.remove(); }
if (previous && typeof previous.focus === "function") previous.focus();
// 입력창이면 확인 = 입력한 글자, 취소 = null
if (el.input) resolve(result ? el.input.value : null);
@@ -154,7 +166,13 @@
});
document.addEventListener("keydown", onKey, true);
document.body.appendChild(el.backdrop);
if (host) {
host.appendChild(el.backdrop);
document.body.appendChild(host);
host.showModal();
} else {
document.body.appendChild(el.backdrop);
}
if (el.input) { el.input.focus(); el.input.select(); }
else el.ok.focus();
});
+323
View File
@@ -0,0 +1,323 @@
/* 입출고 관리(inout) — ERP 공용(erp.css·erp-shell.css) 위에 이 화면만의 것 */
/* 공용 .erp-page 는 width:100% + 안쪽 여백(content-box)이라 표가 넓으면 48px 넘친다 — 이 화면에서만 테두리 기준으로 */
.erp-page:has(> .io) { box-sizing: border-box; }
.io { display: flex; flex-direction: column; gap: 14px; min-width: 0; } /* 넓은 표는 안에서 가로 스크롤(페이지가 화면보다 넓어지지 않게) */
.io-nav { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.io-nav-gap { flex: 1 1 auto; }
.io-roles { display: inline-flex; gap: 4px; align-items: center; }
.io-flash { margin: 0; padding: 10px 14px; border-radius: 8px; background: #eef6ff; color: #0b4a8b; font-size: 13px; border: 1px solid #cfe3fb; }
.io-error { margin: 12px 20px 0; padding: 10px 14px; border-radius: 8px; background: #fbe9e6; color: #a1261b; border: 1px solid #efc6bf; font-size: 13px; }
.io > .io-error { margin: 0; }
.io-hint { color: #a1261b; font-size: 12px; }
.io-help { margin: 0; padding: 12px 20px 0; font-size: 12.5px; color: var(--color-midtone-gray); line-height: 1.6; }
.io-foot { margin: 0; }
/* 거르기 줄 */
.io-filter { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.io-filter .erp-select { width: auto; }
.io-search { width: 260px; }
.io-filter input[type="date"] { width: 150px; }
.io-date { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--color-midtone-gray); }
.io-seg { display: inline-flex; padding: 2px; border: 1px solid var(--color-subtle-ash); border-radius: 10px; background: #fff; }
.io-seg-btn { padding: 5px 12px; border-radius: 8px; font-size: 12.5px; color: var(--color-rich-black); text-decoration: none; white-space: nowrap; }
.io-seg-btn:hover { background: var(--color-ghost-gray); }
.io-seg-btn.is-active, .io-seg-btn.is-active:hover { background: var(--color-deep-black); color: #fff; }
/* 표 */
.io-table td, .io-table th { white-space: nowrap; }
.io-table td.io-items { white-space: normal; min-width: 160px; }
.io-num { text-align: right !important; font-variant-numeric: tabular-nums; }
.io-code { font-family: ui-monospace, Consolas, monospace; font-size: 12px; }
.io-order-no { font-weight: 600; color: var(--color-rich-black); text-decoration: none; font-family: ui-monospace, Consolas, monospace; }
.io-order-no:hover { text-decoration: underline; }
.io-row-link { cursor: pointer; }
.io-row-link.is-late td:first-child { box-shadow: inset 3px 0 0 #d93025; }
.io-remaining { color: #b45309; font-weight: 600; }
.io-over, .io-over-sub { color: #d93025; font-weight: 600; }
.io-over-sub { font-size: 11px; }
.io-late { color: #d93025; font-weight: 600; font-size: 12px; }
.io-block { overflow: visible; }
/* 상태 배지 */
.io-badge { display: inline-flex; align-items: center; padding: 2px 8px; border-radius: 999px; font-size: 11.5px; font-weight: 600; white-space: nowrap; border: 1px solid transparent; }
.io-st-open, .io-st-none { background: #eef0f2; color: #3d4148; }
.io-st-partial { background: #fff4e0; color: #9a5b00; border-color: #f6dcae; }
.io-st-done { background: #e6f8e9; color: #1e7a34; border-color: #c2efc8; }
.io-st-over { background: #fbe9e6; color: #b3261e; border-color: #efc6bf; }
.io-st-closed { background: #f4f4f5; color: #6b6f76; border-color: #dcdde0; }
.io-st-cancelled { background: #fff; color: #9aa0a6; border-color: #dcdde0; text-decoration: line-through; }
/* 진행률 */
.io-progress { display: inline-block; width: 80px; height: 6px; border-radius: 999px; background: #eceef1; overflow: hidden; vertical-align: middle; }
.io-progress-bar { display: block; height: 100%; background: #1e8e3e; border-radius: inherit; }
.io-progress-bar.is-over { background: #d93025; }
.io-progress-pct { margin-left: 6px; font-size: 12px; color: var(--color-midtone-gray); font-variant-numeric: tabular-nums; }
/* 요약 숫자 */
.io-kpis { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 10px; }
.io-kpi-remaining .erp-summary-value { color: #b45309; }
.io-kpi-over .erp-summary-value { color: #d93025; }
/* 발주서 머리 */
.io-head { padding: 16px 20px; display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 12px 20px; overflow: visible; }
.io-head-title { display: flex; align-items: center; gap: 10px; }
.io-head-title h2 { margin: 0; font-size: 18px; font-family: ui-monospace, Consolas, monospace; }
.io-head-meta { display: flex; flex-wrap: wrap; gap: 8px 24px; margin: 12px 0 0; }
.io-head-meta dt { font-size: 11.5px; color: var(--color-midtone-gray); }
.io-head-meta dd { margin: 2px 0 0; font-size: 13.5px; }
.io-head-meta .io-wide { flex-basis: 100%; }
.io-kpis-head { grid-template-columns: repeat(auto-fit, minmax(96px, 1fr)); align-self: start; min-width: 320px; }
.io-head-actions { grid-column: 1 / -1; display: flex; flex-wrap: wrap; gap: 8px; align-items: center; padding-top: 12px; border-top: 1px solid var(--color-subtle-ash); }
.io-head-actions form { display: inline-flex; gap: 6px; align-items: center; margin: 0; }
.io-close-reason { width: 220px; }
/* 입고 입력 */
.io-col-no { width: 36px; color: var(--color-midtone-gray); }
.io-col-recv { width: 130px; background: #f6fbf7; }
.io-table thead th.io-col-recv { background: #eaf6ee; color: #1e7a34; font-weight: 600; }
.io-qty { width: 110px; text-align: right; font-variant-numeric: tabular-nums; }
.io-receipt-bar { display: flex; align-items: flex-end; gap: 10px; flex-wrap: wrap; padding: 14px 20px; border-top: 1px solid var(--color-subtle-ash); background: #fafbfc; }
.io-receipt-bar .erp-field input { min-width: 150px; }
.io-grow { flex: 1 1 260px; }
.io-default-submit { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0 0 0 0); border: 0; }
.io-over-box { margin: 12px 20px 0; padding: 12px 16px; border-radius: 8px; background: #fbe9e6; border: 1px solid #efc6bf; color: #7a1d14; font-size: 13px; }
.io-over-box ul { margin: 6px 0 10px; padding-left: 18px; }
/* [초과 입고로 저장] — 분홍 안내 상자 위에서도 또렷하게: 진한 빨강 바탕 + 흰 글씨(공용 erp-btn-danger 는 연해서 안 보였다) */
.io-btn-over { display: inline-flex; align-items: center; gap: 6px; padding: 8px 16px; border: 1px solid #b3261e; border-radius: 8px;
background: #c5221f; color: #fff; font: inherit; font-size: 13px; font-weight: 600; cursor: pointer; box-shadow: 0 1px 2px rgba(0, 0, 0, .15); }
.io-btn-over:hover { background: #a50e0e; border-color: #8c0b0b; }
.io-btn-over:focus-visible { outline: 2px solid #7a1d14; outline-offset: 2px; }
.io-chip { display: inline-block; margin: 2px 6px 2px 0; padding: 1px 8px; border-radius: 6px; background: var(--color-ghost-gray); font-size: 12px; white-space: nowrap; }
/* 발주서 폼 */
.io-order-form { overflow: visible; }
.io-lines .io-col-qty { width: 130px; }
.io-lines .erp-input { width: 100%; }
.io-lines .io-col-del { width: 48px; text-align: center; }
.io-lines tfoot td { padding: 10px 16px; border-top: 1px solid var(--color-subtle-ash); }
.io-item-cell { position: relative; min-width: 320px; }
.io-item-search { width: 100%; }
.io-item-search.is-invalid { border-color: #d93025; box-shadow: 0 0 0 3px rgba(217, 48, 37, .12); }
.io-item-search[readonly] { background: var(--color-ghost-gray); }
.io-total { margin-left: 12px; }
.io-form-actions { display: flex; justify-content: flex-end; gap: 8px; padding: 14px 20px; border-top: 1px solid var(--color-subtle-ash); }
/* 검색 드롭다운 — 표 가로 스크롤 상자에 잘리지 않게 화면 기준(fixed), 위치는 inout.js 가 입력칸에 맞춤 */
.io-suggest { position: fixed; z-index: 1000; max-height: 280px; overflow-y: auto;
background: #fff; border: 1px solid var(--color-subtle-ash); border-radius: 8px; box-shadow: 0 8px 24px rgba(0, 0, 0, .12); }
.io-suggest-item { padding: 7px 12px; font-size: 13px; cursor: pointer; white-space: normal; }
.io-suggest-item:hover, .io-suggest-item.is-active { background: #eef6ff; }
.io-suggest-empty { padding: 10px 12px; font-size: 12.5px; color: var(--color-midtone-gray); white-space: normal; }
/* ── 공용 ERP 스타일과 겹치는 부분(2026-10-16 옵션 화면 겹침) ──
· .erp-input 은 min-width 240px + content-box 라 좁은 칸에서 옆 칸을 덮는다 → 이 모듈 안에서는 테두리 기준·최소폭 없음
· .erp-table-wrap 은 카드 모양(그림자·둥근 모서리)이라 카드 안에 넣으면 상자가 겹쳐 보인다 → 카드 안에서는 평평하게 */
.io *, .io *::before, .io *::after, .io-dlg *, .io-dlg *::before, .io-dlg *::after { box-sizing: border-box; }
/* hidden 속성은 늘 숨김 — display 를 준 요소(예: 메일 창 아래 줄 flex)가 hidden 을 덮어써 보이던 문제(2026-10-16) */
.io [hidden], .io-dlg [hidden], .io-viewer [hidden] { display: none !important; }
.io .erp-input { min-width: 0; }
.io .erp-card-block .erp-table-wrap { border-radius: 0; box-shadow: none; background: transparent; }
/* 옵션 톱니(관리자) — 실적 설정 톱니처럼 둥근 아이콘 단추 */
.io-gear { display: inline-flex; align-items: center; justify-content: center; width: 36px; height: 36px; padding: 0;
border: 1px solid var(--color-subtle-ash); border-radius: 50%; background: #fff; color: #525860; cursor: pointer;
transition: background .12s, color .12s, border-color .12s; }
.io-gear:hover { background: var(--color-ghost-gray); color: var(--color-rich-black); border-color: #c9ccd1; }
.io-gear:focus-visible { outline: 2px solid var(--color-rich-black); outline-offset: 2px; }
.io-factory-who { display: block; font-size: 12px; color: var(--color-midtone-gray); margin-top: 2px; }
/* 옵션 팝업 */
.io-dlg { width: min(1180px, calc(100vw - 40px)); max-height: min(760px, calc(100vh - 40px)); padding: 0; border: 1px solid var(--color-subtle-ash);
border-radius: 12px; box-shadow: 0 12px 40px rgba(0, 0, 0, .2); color: var(--color-rich-black); overflow: hidden; }
.io-dlg[open] { display: flex; flex-direction: column; }
.io-dlg:focus { outline: none; }
.io-dlg-tabs button:focus-visible { outline: 2px solid var(--color-rich-black); outline-offset: -4px; border-radius: 6px; }
.io-dlg::backdrop { background: rgba(0, 0, 0, .35); }
.io-dlg-head { display: flex; align-items: center; justify-content: space-between; padding: 14px 16px 14px 22px; border-bottom: 1px solid var(--color-subtle-ash); }
.io-dlg-head h2 { margin: 0; font-size: 17px; font-weight: 600; }
.io-dlg-x { display: inline-flex; padding: 6px; border: 0; border-radius: 6px; background: none; color: #6d6e6f; cursor: pointer; }
.io-dlg-x:hover { background: var(--color-ghost-gray); color: var(--color-rich-black); }
.io-dlg-msg { margin: 12px 22px 0; padding: 9px 12px; border-radius: 8px; background: #e6f8e9; color: #1e7a34; border: 1px solid #c2efc8; font-size: 13px; }
.io-dlg-msg.is-bad { background: #fbe9e6; color: #a1261b; border-color: #efc6bf; }
.io-dlg-body { flex: 1 1 auto; min-height: 0; overflow-y: auto; padding: 14px 22px 18px; }
.io-dlg-tabs { display: flex; gap: 4px; border-bottom: 1px solid var(--color-subtle-ash); margin-bottom: 14px; }
.io-dlg-tabs button { padding: 8px 14px; border: 0; border-bottom: 2px solid transparent; margin-bottom: -1px; background: none;
font: inherit; font-size: 14px; color: var(--color-midtone-gray); cursor: pointer; }
.io-dlg-tabs button:hover { color: var(--color-rich-black); }
.io-dlg-tabs button.is-active { color: var(--color-rich-black); font-weight: 600; border-bottom-color: var(--color-rich-black); }
.io-dlg-count { display: inline-block; min-width: 18px; padding: 0 5px; margin-left: 4px; border-radius: 999px; background: var(--color-ghost-gray); font-size: 11px; text-align: center; }
.io-dlg-body .io-help { padding: 0 0 12px; }
.io-dlg-form { margin: 0; }
.io-dlg-table { width: 100%; border-collapse: collapse; font-size: 13px; table-layout: fixed; }
.io-dlg-table th { text-align: left; font-weight: 500; font-size: 12px; color: var(--color-midtone-gray); padding: 8px 6px; border-bottom: 1px solid var(--color-subtle-ash); white-space: nowrap; }
.io-dlg-table td { padding: 7px 6px; border-bottom: 1px solid var(--color-subtle-ash); vertical-align: middle; }
.io-dlg-table tbody tr:last-child td { border-bottom: 0; }
.io-dlg-table .io-c { text-align: center; }
.io-dlg-table td.io-c input[type="checkbox"] { width: 16px; height: 16px; }
.io-user { display: block; font-weight: 500; }
.io-sub { font-size: 12px; color: var(--color-midtone-gray); }
.io-empty { text-align: center; padding: 18px; color: var(--color-midtone-gray); }
.io-in { width: 100%; min-width: 0; padding: 6px 9px; border: 1px solid var(--color-subtle-ash); border-radius: 6px; font: inherit; font-size: 13px;
color: var(--color-rich-black); background: #fff; }
.io-in:focus { outline: none; border-color: var(--color-rich-black); box-shadow: 0 0 0 3px rgba(0, 0, 0, .06); }
.io-in-num { text-align: right; }
.io-factory-table col.w-name { width: 15%; }
.io-factory-table col.w-man { width: 10%; }
.io-factory-table col.w-tel { width: 14%; }
.io-factory-table col.w-memo { width: auto; }
.io-factory-table col.w-sort { width: 64px; }
.io-factory-table col.w-use { width: 48px; }
.io-factory-table col.w-cnt { width: 52px; }
.io-factory-table col.w-btn { width: 128px; }
.io-factory-table tr.is-inactive .io-in { background: var(--color-ghost-gray); color: var(--color-midtone-gray); }
.io-factory-table .io-new-row td { background: #fafbfc; border-top: 1px solid var(--color-subtle-ash); }
.io-btns { text-align: right; white-space: nowrap; } /* td 에 flex 를 주면 표 칸이 깨진다(줄 선·배경 어긋남) */
.io-btns .erp-btn + .erp-btn { margin-left: 4px; }
.io-dlg-actions { display: flex; justify-content: flex-end; padding-top: 12px; }
.io-dlg-foot { margin: 14px 0 0; font-size: 12px; color: var(--color-midtone-gray); }
@media (max-width: 900px) {
.io-kpis { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.io-head { grid-template-columns: 1fr; }
.io-kpis-head { min-width: 0; }
.io-dlg-body { overflow-x: auto; }
.io-factory-table { min-width: 860px; }
}
/* ── 발주 메일(003) ── */
.io-mail-btn { display: inline-flex; align-items: center; gap: 6px; }
.io-mail-sent { color: #1e7a34; font-weight: 600; }
.io-mail-dlg { width: min(860px, calc(100vw - 40px)); }
.io-mail-fields { display: grid; grid-template-columns: 1fr 1fr; gap: 10px 14px; margin-bottom: 12px; }
.io-mail-fields label { display: flex; flex-direction: column; gap: 4px; font-size: 12px; color: var(--color-midtone-gray); }
.io-mail-fields input[readonly] { background: var(--color-ghost-gray); color: #3d3f42; }
.io-mail-sentlist { margin: 0 0 12px; padding: 10px 12px; border-radius: 8px; background: #f3fbf5; border: 1px solid #cdeed6; font-size: 12.5px; }
.io-mail-sentlist ul { margin: 4px 0 0; padding-left: 18px; }
.io-mail-preview { width: 100%; height: 380px; border: 1px solid var(--color-subtle-ash); border-radius: 8px; background: #fff; }
.io-mail-connect { padding: 8px 2px 4px; font-size: 13.5px; line-height: 1.7; }
.io-mail-connect .erp-btn { margin-top: 6px; }
.io-mail-admin { margin-top: 14px; padding: 10px 12px; border-radius: 8px; background: var(--color-ghost-gray); font-size: 12px; color: #3d3f42; }
.io-mail-admin code { display: inline-block; margin-top: 4px; padding: 2px 6px; border-radius: 4px; background: #fff; border: 1px solid var(--color-subtle-ash); font-size: 12px; user-select: all; word-break: break-all; }
.io-hint { margin: -4px 0 12px; font-size: 12.5px; color: #9a5b00; }
.io-dlg-footbar { display: flex; align-items: center; gap: 8px; padding: 12px 22px; border-top: 1px solid var(--color-subtle-ash); background: #fafbfc; }
.io-link-btn { border: 0; background: none; padding: 0; font: inherit; font-size: 12px; color: var(--color-midtone-gray); text-decoration: underline; cursor: pointer; }
.io-link-btn:hover { color: var(--color-rich-black); }
/* ── 입고증 사진(003) ── */
.io-photo-field { min-width: 180px; }
.io-photo-pick { position: relative; display: inline-flex; align-items: center; gap: 6px; padding: 6px 12px; border: 1px dashed #b7bcc4;
border-radius: 8px; background: #fff; color: var(--color-rich-black); font-size: 13px; cursor: pointer; white-space: nowrap; }
.io-photo-pick:hover { border-color: var(--color-rich-black); background: var(--color-ghost-gray); }
.io-photo-pick:focus-within { outline: 2px solid var(--color-rich-black); outline-offset: 2px; }
.io-photo-input { position: absolute; inset: 0; width: 100%; height: 100%; opacity: 0; cursor: pointer; }
.io-photo-previews { flex-basis: 100%; display: flex; flex-wrap: wrap; gap: 8px; }
.io-photo-previews:empty { display: none; }
.io-photo-chip { display: inline-flex; align-items: center; gap: 8px; padding: 4px 6px 4px 4px; border: 1px solid var(--color-subtle-ash);
border-radius: 8px; background: #fff; font-size: 12px; color: #3d3f42; max-width: 280px; }
.io-photo-chip img { width: 40px; height: 40px; object-fit: cover; border-radius: 6px; background: var(--color-ghost-gray); }
.io-photo-chip span { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.io-photo-chip button { border: 0; background: none; color: #6d6e6f; cursor: pointer; font-size: 13px; padding: 2px 4px; border-radius: 4px; }
.io-photo-chip button:hover { background: var(--color-ghost-gray); color: #c5221f; }
.io-photo-lost { margin: 0 0 8px; font-size: 12.5px; color: #7a1d14; font-weight: 600; }
.io-photos-cell { white-space: normal !important; min-width: 120px; }
.io-photos-cell .io-add-photo-form { display: inline-block; margin: 0; vertical-align: middle; }
.io-thumb { position: relative; display: inline-flex; align-items: center; justify-content: center; width: 44px; height: 44px; margin: 2px 4px 2px 0;
padding: 0; overflow: hidden; border: 1px solid var(--color-subtle-ash); border-radius: 6px; background: var(--color-ghost-gray); cursor: zoom-in; vertical-align: middle; }
.io-thumb img { width: 100%; height: 100%; object-fit: cover; }
.io-thumb:hover { border-color: var(--color-rich-black); }
.io-thumb-heic { font-size: 10px; font-weight: 700; color: #6d6e6f; }
.io-thumb-add { cursor: pointer; border-style: dashed; background: #fff; color: #6d6e6f; font-size: 20px; }
.io-thumb-add:hover { color: var(--color-rich-black); }
.io-viewer { width: min(1100px, calc(100vw - 40px)); height: min(860px, calc(100vh - 40px)); padding: 0; border: 0; border-radius: 12px;
background: #111; color: #fff; overflow: hidden; }
.io-viewer[open] { display: flex; align-items: center; justify-content: center; }
.io-viewer:focus { outline: none; }
.io-viewer::backdrop { background: rgba(0, 0, 0, .7); }
.io-viewer-bar { position: absolute; top: 0; left: 0; right: 0; display: flex; align-items: center; gap: 8px; padding: 10px 14px;
background: linear-gradient(rgba(0, 0, 0, .6), rgba(0, 0, 0, 0)); z-index: 1; }
.io-viewer-bar form { margin: 0; }
.io-viewer-title { flex: 1 1 auto; font-size: 13px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.io-viewer-btn { padding: 5px 12px; border: 1px solid rgba(255, 255, 255, .35); border-radius: 6px; background: rgba(0, 0, 0, .35); color: #fff;
font: inherit; font-size: 12.5px; text-decoration: none; cursor: pointer; }
.io-viewer-btn:hover { background: rgba(255, 255, 255, .15); }
.io-viewer-img { max-width: 100%; max-height: 100%; object-fit: contain; }
.io-viewer-heic { padding: 24px; text-align: center; }
.io-viewer-nav { position: absolute; top: 50%; transform: translateY(-50%); width: 44px; height: 64px; border: 0; border-radius: 8px;
background: rgba(0, 0, 0, .45); color: #fff; font-size: 30px; cursor: pointer; z-index: 1; }
.io-viewer-nav:hover { background: rgba(255, 255, 255, .2); }
.io-viewer-nav.is-prev { left: 10px; }
.io-viewer-nav.is-next { right: 10px; }
.io-factory-table col.w-mail { width: 17%; }
@media (max-width: 900px) {
.io-mail-fields { grid-template-columns: 1fr; }
}
/* ── 상품 정보 탭(004) — 단가·무게(PP)·은 함유량 ── */
.io-prod-bar { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; margin-bottom: 10px; }
.io-prod-search { width: 220px; }
.io-prod-scroll { max-height: min(440px, calc(100vh - 340px)); overflow-y: auto; border: 1px solid var(--color-subtle-ash); border-radius: 8px; }
.io-prod-table thead th { position: sticky; top: 0; z-index: 1; background: #fafbfc; }
.io-prod-table col.w-code { width: 128px; }
.io-prod-table col.w-num { width: 120px; }
.io-prod-table col.w-ag { width: 92px; }
.io-prod-table col.w-del { width: 44px; }
.io-prod-table th.io-r, .io-r { text-align: right; }
.io-prod-name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.io-ag { color: var(--color-midtone-gray); font-variant-numeric: tabular-nums; }
.io-prod-table tr.is-dirty td { background: #fff8e1; }
.io-icon-btn { width: 26px; height: 26px; padding: 0; border: 0; border-radius: 6px; background: none; color: #8a8b8c; font-size: 13px; cursor: pointer; }
.io-icon-btn:hover { background: #fbe9e6; color: #a1261b; }
.io-excluded { margin-top: 12px; font-size: 13px; }
.io-excluded summary { cursor: pointer; color: var(--color-midtone-gray); }
.io-excluded ul { margin: 8px 0 0; padding: 0; list-style: none; }
.io-excluded li { display: flex; align-items: center; gap: 8px; padding: 5px 0; border-bottom: 1px solid var(--color-subtle-ash); }
.io-excluded li .io-link-btn { margin-left: auto; }
/* 발주서 단가·금액 칸 */
.io-col-money { width: 110px; text-align: right; white-space: nowrap; font-variant-numeric: tabular-nums; }
.io-col-spec { width: 96px; white-space: nowrap; font-variant-numeric: tabular-nums; }
.io-table tfoot .io-total-row td { padding: 10px var(--sp-16, 16px); vertical-align: middle; background: #fafbfc; font-weight: 500; border-top: 1px solid var(--color-subtle-ash); }
.io-suggest-price { float: right; margin-left: 12px; color: var(--color-midtone-gray); font-size: 12px; font-variant-numeric: tabular-nums; }
.io-table th.io-col-money, .io-table th.io-col-spec { text-align: right; }
/* 전체 입고 완료(모든 품목 입고완료·초과입고) — 2026-10-17 */
.io-st-all { gap: 3px; }
.io-badge-note { margin-left: 4px; font-size: 11px; font-weight: 600; color: #b3261e; white-space: nowrap; }
.io-status-cell { white-space: nowrap; }
/* 발주 삭제(수퍼관리자, 2026-10-17) */
.io-table .io-col-trash { width: 44px; padding-left: 0; padding-right: 8px; text-align: center; }
.io-table .io-col-trash form { margin: 0; display: inline-flex; }
.io-del-btn { display: inline-flex; align-items: center; justify-content: center; }
.sr-only { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
/* 입고 요청 메일(005) — 입고 기록 칸 · 옵션 → 물류센터 */
.io-rmail-cell { white-space: nowrap; }
.io-rmail-cell .io-rmail-btn { margin-top: 4px; }
.io-logi-form { display: grid; gap: 12px; max-width: 640px; }
.io-logi-field { display: grid; gap: 4px; }
.io-logi-field > span { font-weight: 600; }
.io-logi-field small { font-weight: 400; color: var(--color-midtone-gray, #777); }
.io-rmail-cell .io-sabang-btn { margin-top: 4px; display: inline-flex; }
/* 사방넷 입고 파일 버튼 — 엑셀 초록(2026-10-19) */
.io .erp-btn.io-sabang-btn { background: #217346; border-color: #217346; color: #fff; }
.io .erp-btn.io-sabang-btn:hover, .io .erp-btn.io-sabang-btn:focus-visible { background: #185c37; border-color: #185c37; color: #fff; }
/* 전체 입고 완료 — 입고 칸·버튼 흐리게, 누를 수 없게 */
.io-receipt-bar.is-locked { opacity: .5; }
.io-receipt-bar.is-locked .erp-btn, .io-receipt-bar.is-locked .io-photo-pick, .io-receipt-bar.is-locked input { cursor: not-allowed; pointer-events: none; }
.io-table .io-recv:disabled { opacity: .5; cursor: not-allowed; background: #f3f4f6; }
.io-recv-done-note { color: #1e7a34; font-weight: 600; }
/* 입고 줄 — 입력칸·[입고증 업로드]·[남은 수량 모두 채우기]·[입고 저장] 높이를 34px 로 맞춤(2026-10-19).
입고증 업로드의 사진 아이콘은 버튼 높이에 거의 꽉 차게(28px, 위아래 여백 없이) */
.io-receipt-bar .erp-field input, .io-receipt-bar .erp-btn, .io-receipt-bar .io-photo-pick { height: 34px; box-sizing: border-box; }
.io-receipt-bar .erp-btn { display: inline-flex; align-items: center; justify-content: center; padding-top: 0; padding-bottom: 0; }
.io-receipt-bar .io-photo-pick { padding: 0 12px 0 8px; gap: 6px; }
.io-receipt-bar .io-photo-pick-icon { flex: none; width: 28px; height: 28px; }
/* 옵션 → 공장: 발주 메일 참조(2026-10-19) */
.io-ordercc-form { margin: 0 0 14px; max-width: 640px; }
.io-ordercc-row { display: flex; gap: 8px; align-items: center; }
.io-ordercc-row .io-in { flex: 1 1 auto; }
/* [남은 수량 모두 채우기] 를 누른 뒤 = 되돌리기 모드 */
.io-receipt-bar #io-fill-remaining.is-filled { border-color: #1e7a34; color: #1e7a34; background: #f3fbf5; }
/* 발주 메일 창 — 입고 담당 발주 알림 자동 발송 안내 */
.io-mail-notice { margin: -4px 0 12px; padding: 8px 12px; border-radius: 8px; background: #f0f6ff; border: 1px solid #cfe0fb; color: #1d4f91; font-size: 12.5px; }
+699
View File
@@ -0,0 +1,699 @@
/* 입출고 관리(inout) 화면 스크립트 — 화면 전환·저장은 서버(폼)가 하고, 여기는 입력을 돕기만 한다.
· 목록 줄 누르기 = 발주서로
· 발주서 폼: 제품 줄 추가·지우기·번호·합계, 코드표 단품 검색(GET /inout/api/items?q=) 드롭다운
· 발주서 화면: [남은 수량 모두 채우기], 이번 입고 합계
· 옵션 팝업(톱니): 담당자·공장 — 열 때 내용을 받고, 저장은 제자리
· 입고증 사진: 브라우저에서 줄여 올리기·미리보기·크게 보기, 입고 저장 전 초과 확인(사진이 사라지지 않게)
· 발주 메일·입고 요청 메일: 미리보기 팝업 → [메일 발송](보내는 사람 본인 Gmail), 처음엔 [Gmail 연결]
· data-erp-confirm-btn: 버튼별 확인(formaction 이 있는 버튼 — 공용 data-erp-confirm 은 form.submit() 이라 누른 버튼이 사라짐) */
(function () {
"use strict";
function confirmMsg(msg) {
return window.erpConfirm ? window.erpConfirm(msg) : Promise.resolve(window.confirm(msg));
}
function alertMsg(msg) {
return window.erpAlert ? window.erpAlert(msg) : Promise.resolve(window.alert(msg));
}
function num(v) {
const n = parseInt(String(v || "").replace(/[,\s]/g, ""), 10);
return Number.isFinite(n) && n > 0 ? n : 0;
}
function fmt(n) { return n.toLocaleString("ko-KR"); }
// ── 목록 줄 누르기 → 발주서 ──
document.addEventListener("click", function (e) {
const row = e.target.closest(".io-row-link");
if (!row || e.target.closest("a, button, input, select, label")) return;
if (window.getSelection && String(window.getSelection())) return; // 글자 고르는 중
location.href = row.dataset.href;
});
// ── 버튼별 확인 ──
document.addEventListener("click", function (e) {
const btn = e.target.closest("[data-erp-confirm-btn]");
if (!btn || btn.dataset.confirmed === "1") return;
e.preventDefault();
confirmMsg(btn.dataset.erpConfirmBtn).then(function (ok) {
if (!ok) return;
btn.dataset.confirmed = "1";
if (btn.form.requestSubmit) btn.form.requestSubmit(btn); else btn.click();
});
});
// ── 발주서 폼 ──
const form = document.getElementById("io-order-form");
if (form) initOrderForm(form);
function initOrderForm(form) {
const body = form.querySelector("#io-lines tbody");
const tpl = document.getElementById("io-line-tpl");
const totalQty = document.getElementById("io-total-qty");
const totalLines = document.getElementById("io-total-lines");
const totalAmount = document.getElementById("io-total-amount"), noPrice = document.getElementById("io-total-noprice");
function renumber() {
let q = 0, k = 0, amount = 0, missing = 0;
body.querySelectorAll(".io-line").forEach(function (tr, i) {
tr.querySelector(".io-col-no").textContent = String(i + 1);
const n = num(tr.querySelector(".io-qty").value);
const has = !!tr.querySelector('input[name="item_code"]').value;
const price = tr.dataset.price === "" || tr.dataset.price === undefined ? null : parseFloat(tr.dataset.price);
const cell = tr.querySelector(".io-amount");
// 금액 = 수량 × 단가(상품 정보 단가, 이미 있던 품목은 발주 당시 단가) — 표시만, 저장은 서버가 단가 사본으로
if (cell) cell.textContent = has && price !== null && n ? (Math.round(price * n * 100) / 100).toLocaleString("ko-KR") : "-";
if (has) { k++; q += n; if (price === null) missing++; else amount += price * n; }
});
totalQty.textContent = fmt(q);
totalLines.textContent = fmt(k);
if (totalAmount) totalAmount.textContent = (Math.round(amount * 100) / 100).toLocaleString("ko-KR");
if (noPrice) noPrice.textContent = missing ? " (단가 없는 " + missing + "종 제외)" : "";
}
function addLine(focus) {
const tr = tpl.content.firstElementChild.cloneNode(true);
body.appendChild(tr);
wireSearch(tr.querySelector(".io-item-search"));
renumber();
if (focus) tr.querySelector(".io-item-search").focus();
return tr;
}
form.querySelector("#io-add-line").addEventListener("click", function () { addLine(true); });
body.addEventListener("click", function (e) {
const del = e.target.closest(".io-del");
if (!del) return;
const tr = del.closest(".io-line");
const search = tr.querySelector(".io-item-search");
if (search && search._ioBox) search._ioBox.remove(); // body 에 붙은 드롭다운도 함께
tr.remove();
if (!body.querySelector(".io-line")) addLine(false);
renumber();
});
body.addEventListener("input", renumber); // 수량을 바꾸거나 제품 글을 고치면(고른 것 풀림) 다시 셈
body.addEventListener("io-chosen", renumber); // 검색 목록에서 제품을 고르면
body.querySelectorAll(".io-item-search").forEach(wireSearch);
if (!body.querySelector(".io-line")) { addLine(false); addLine(false); addLine(false); }
renumber();
form.addEventListener("submit", function (e) {
// 검색 글만 있고 목록에서 고르지 않은 줄, 같은 제품 두 줄 — 서버도 막지만 여기서 먼저 알려 준다
const codes = [];
let bad = null;
body.querySelectorAll(".io-line").forEach(function (tr) {
const code = tr.querySelector('input[name="item_code"]').value;
const text = tr.querySelector(".io-item-search").value.trim();
if (!code && text && !bad) bad = { tr: tr, msg: "'" + text + "' — 검색 목록에서 제품을 골라 주세요." };
if (code && codes.indexOf(code) >= 0 && !bad) bad = { tr: tr, msg: code + " — 같은 제품이 두 줄에 있습니다. 한 줄로 합쳐 주세요." };
if (code) codes.push(code);
});
if (bad) {
e.preventDefault();
bad.tr.querySelector(".io-item-search").classList.add("is-invalid");
alertMsg(bad.msg).then(function () { bad.tr.querySelector(".io-item-search").focus(); });
}
});
}
// 코드표 단품 검색 드롭다운 — 고르면 숨은 칸(코드·이름)을 채우고 수량 칸으로. 글을 다시 고치면 고른 것을 지운다.
function wireSearch(input) {
if (!input || input.readOnly || input.dataset.wired) return;
input.dataset.wired = "1";
const cell = input.closest(".io-item-cell");
const codeEl = cell.querySelector('input[name="item_code"]');
const nameEl = cell.querySelector('input[name="item_name"]');
const box = document.createElement("div");
box.className = "io-suggest";
box.setAttribute("role", "listbox");
box.hidden = true;
document.body.appendChild(box); // 표 가로 스크롤 상자 밖(fixed) — 아래 줄에서도 잘리지 않게
input._ioBox = box;
let timer = 0, seq = 0, items = [], active = -1;
function place() {
const r = input.getBoundingClientRect();
const below = window.innerHeight - r.bottom;
box.style.left = r.left + "px";
box.style.width = Math.max(r.width, 320) + "px";
if (below < 200 && r.top > below) { box.style.top = ""; box.style.bottom = (window.innerHeight - r.top + 2) + "px"; }
else { box.style.bottom = ""; box.style.top = (r.bottom + 2) + "px"; }
}
window.addEventListener("resize", function () { if (!box.hidden) place(); });
document.addEventListener("scroll", function () { if (!box.hidden) place(); }, true);
function close() { box.hidden = true; active = -1; input.setAttribute("aria-expanded", "false"); }
function paint() {
box.innerHTML = "";
if (!items.length) {
const empty = document.createElement("div");
empty.className = "io-suggest-empty";
empty.textContent = box.dataset.message || "맞는 단품이 없습니다.";
box.appendChild(empty);
}
items.forEach(function (it, i) {
const opt = document.createElement("div");
opt.className = "io-suggest-item" + (i === active ? " is-active" : "");
opt.setAttribute("role", "option");
const c = document.createElement("span");
c.className = "io-code";
c.textContent = it.code;
opt.appendChild(c);
opt.appendChild(document.createTextNode(" " + it.name));
if (it.unit_price) {
const pr = document.createElement("span");
pr.className = "io-suggest-price";
pr.textContent = it.unit_price + "원";
opt.insertBefore(pr, c); // float:right 는 글자보다 앞에 둬야 같은 줄 오른쪽
}
opt.addEventListener("mousedown", function (e) { e.preventDefault(); choose(i); });
box.appendChild(opt);
});
box.hidden = false;
place();
input.setAttribute("aria-expanded", "true");
}
function choose(i) {
const it = items[i];
if (!it) return;
codeEl.value = it.code;
const row = input.closest("tr");
if (row) { // 단가(상품 정보) — 금액 계산용
row.dataset.price = it.price === null || it.price === undefined ? "" : String(it.price);
const pc = row.querySelector(".io-price");
if (pc) pc.textContent = it.unit_price || "-";
}
nameEl.value = it.name;
input.value = it.code + " · " + it.name;
input.classList.remove("is-invalid");
close();
const qty = input.closest("tr").querySelector(".io-qty");
if (qty) qty.focus();
input.dispatchEvent(new Event("io-chosen", { bubbles: true }));
}
async function search(q) {
const my = ++seq;
try {
const res = await fetch("/inout/api/items?q=" + encodeURIComponent(q), { headers: { Accept: "application/json" } });
const data = await res.json();
if (my !== seq) return;
items = data.items || [];
box.dataset.message = data.enabled === false ? (data.message || "코드표가 연결되지 않았습니다.") : "";
active = items.length ? 0 : -1;
paint();
} catch (_) {
if (my !== seq) return;
items = [];
box.dataset.message = "검색하지 못했습니다. 잠시 뒤 다시 입력하세요.";
paint();
}
}
input.setAttribute("aria-autocomplete", "list");
input.addEventListener("input", function () {
codeEl.value = ""; // 글을 고치면 고른 제품은 풀린다(다시 골라야 저장)
const row0 = input.closest("tr");
if (row0 && row0.dataset.price !== undefined) { row0.dataset.price = ""; const pc0 = row0.querySelector(".io-price"); if (pc0) pc0.textContent = "-"; }
nameEl.value = "";
clearTimeout(timer);
const q = input.value.trim();
if (!q) { close(); return; }
timer = setTimeout(function () { search(q); }, 200);
});
input.addEventListener("keydown", function (e) {
if (box.hidden) return;
if (e.key === "ArrowDown" || e.key === "ArrowUp") {
e.preventDefault();
if (!items.length) return;
active = (active + (e.key === "ArrowDown" ? 1 : items.length - 1)) % items.length;
paint();
} else if (e.key === "Enter") {
e.preventDefault(); // 고르기만 — 폼 저장 아님
choose(active < 0 ? 0 : active);
} else if (e.key === "Escape") {
close();
}
});
input.addEventListener("blur", function () { setTimeout(close, 120); });
}
// ── 발주서 화면: 입고 입력 ──
const recvForm = document.getElementById("io-receipt-form");
if (recvForm) {
const total = document.getElementById("io-recv-total");
const inputs = Array.from(recvForm.querySelectorAll(".io-recv"));
const paintTotal = function () {
const t = inputs.reduce(function (s, i) { return s + num(i.value); }, 0);
if (total) total.textContent = t ? "(" + fmt(t) + "개)" : "";
};
recvForm.addEventListener("input", paintTotal);
// [남은 수량 모두 채우기] — 한 번 더 누르면 채우기 전 값으로 되돌린다(2026-10-19). 채운 뒤 손으로 고친 칸도 되돌림.
const fill = document.getElementById("io-fill-remaining");
if (fill) {
const fillLabel = fill.textContent;
let before = null; // 채우기 직전 칸 값들 — 있으면 다음 클릭은 되돌리기
const setMode = function (filled) {
before = filled ? before : null;
fill.textContent = filled ? "채운 수량 되돌리기" : fillLabel;
fill.setAttribute("aria-pressed", filled ? "true" : "false");
fill.classList.toggle("is-filled", filled);
};
fill.addEventListener("click", function () {
if (before) {
inputs.forEach(function (i, k) { i.value = before[k]; });
setMode(false);
} else {
const snap = inputs.map(function (i) { return i.value; });
let changed = false;
inputs.forEach(function (i) {
if (!i.value.trim() && num(i.dataset.remaining)) { i.value = i.dataset.remaining; changed = true; }
});
if (changed) { before = snap; setMode(true); }
}
paintTotal();
});
}
paintTotal();
}
// ── 옵션 팝업(톱니, 관리자) — 내용은 GET /inout/settings?panel=1, 저장은 제자리(X-Inout-Options: 1 → JSON) ──
const optBtn = document.getElementById("io-options-btn");
const optDlg = document.getElementById("io-options");
if (optBtn && optDlg) initOptions(optBtn, optDlg);
function initOptions(btn, dlg) {
const body = dlg.querySelector("#io-options-body");
const msgEl = dlg.querySelector(".io-dlg-msg");
let changed = false, pane = "roles";
function say(text, bad) {
msgEl.textContent = text || "";
msgEl.hidden = !text;
msgEl.classList.toggle("is-bad", !!bad);
}
function showPane(name) {
pane = name;
body.querySelectorAll(".io-dlg-tabs [data-pane]").forEach(function (t) {
const on = t.dataset.pane === name;
t.classList.toggle("is-active", on);
t.setAttribute("aria-selected", on ? "true" : "false");
t.tabIndex = on ? 0 : -1;
});
body.querySelectorAll(".io-dlg-pane").forEach(function (p) { p.hidden = p.dataset.pane !== name; });
}
async function load() {
const res = await fetch("/inout/settings?panel=1", { headers: { "X-Inout-Options": "1" } });
if (!res.ok) throw new Error("HTTP " + res.status);
body.innerHTML = await res.text();
showPane(pane);
}
async function open() {
say("");
if (!dlg.open) dlg.showModal();
try {
await load();
dlg.focus({ preventScroll: true }); // 닫기(✕)에 초점 테두리가 생기지 않게 창 자체에(Tab 으로 안으로 이동)
} catch (_) {
body.innerHTML = '<p class="io-error">옵션을 불러오지 못했습니다. 잠시 뒤 다시 여세요.</p>';
}
}
btn.addEventListener("click", open);
dlg.addEventListener("click", function (e) {
if (e.target.closest("[data-close]")) { dlg.close(); return; }
const tab = e.target.closest(".io-dlg-tabs [data-pane]");
if (tab) showPane(tab.dataset.pane);
});
dlg.addEventListener("close", function () {
const url = new URL(location.href);
const hadParam = url.searchParams.has("options");
url.searchParams.delete("options");
url.searchParams.delete("msg");
if (changed) location.href = url.toString(); // 담당 표시·공장 목록이 바뀌었을 수 있다
else if (hadParam) history.replaceState(null, "", url.toString());
});
dlg.addEventListener("submit", async function (e) {
const form = e.target;
if (!form.classList || !form.classList.contains("io-dlg-form")) return;
e.preventDefault();
const sub = e.submitter;
if (sub && sub.dataset.confirm && !(await confirmMsg(sub.dataset.confirm))) return;
const action = sub && sub.getAttribute("formaction") ? sub.getAttribute("formaction") : form.getAttribute("action");
const buttons = Array.from(dlg.querySelectorAll("button[type=submit]"));
buttons.forEach(function (b) { b.disabled = true; });
try {
const res = await fetch(action, { method: "POST", headers: { "X-Inout-Options": "1" },
body: new URLSearchParams(new FormData(form)) });
let data = {};
try { data = await res.json(); } catch (_) {}
if (!res.ok || data.ok === false) { say(data.message || data.detail || "저장하지 못했습니다.", true); return; }
changed = true;
await load();
say(data.message || "저장했습니다.");
} catch (_) {
say("저장하지 못했습니다(연결 오류). 다시 눌러 주세요.", true);
} finally {
buttons.forEach(function (b) { if (b.isConnected) b.disabled = false; });
}
});
// ── 상품 정보 탭(004) — 단가·무게·은 함유량, 바뀐 줄만 [변경 저장], 불러오기·지우기·되살리기 ──
function dirtyRows() {
return Array.from(body.querySelectorAll(".io-prod-table tbody tr")).filter(function (tr) {
return Array.from(tr.querySelectorAll("input[data-key]")).some(function (i) { return i.value.trim() !== i.defaultValue.trim(); });
});
}
function paintDirty() {
const n = dirtyRows().length;
const save = body.querySelector("#io-prod-save"), badge = body.querySelector("#io-prod-dirty");
if (save) save.disabled = !n;
if (badge) badge.textContent = n ? "(" + n + ")" : "";
}
function dec(v) { const n = parseFloat(String(v || "").replace(/[,%\s]/g, "")); return Number.isFinite(n) ? n : null; }
async function postJSON(url, payload) {
const res = await fetch(url, { method: "POST", headers: { "X-Inout-Options": "1", "Content-Type": "application/json" },
body: payload === undefined ? "{}" : JSON.stringify(payload) });
let out = {};
try { out = await res.json(); } catch (_) {}
return { ok: res.ok && out.ok !== false, message: out.message || out.detail || (res.ok ? "" : "HTTP " + res.status) };
}
async function act(url, payload) {
const r = await postJSON(url, payload);
if (r.ok) { changed = true; await load(); }
say(r.message || (r.ok ? "저장했습니다." : "저장하지 못했습니다."), !r.ok);
return r.ok;
}
body.addEventListener("input", function (e) {
const inp = e.target;
if (inp.id === "io-prod-search") {
const q = inp.value.trim().toLowerCase();
let shown = 0;
body.querySelectorAll(".io-prod-table tbody tr").forEach(function (tr) {
const hit = !q || tr.dataset.search.indexOf(q) >= 0;
tr.hidden = !hit;
if (hit) shown++;
});
const cnt = body.querySelector("#io-prod-count");
if (cnt) cnt.dataset.base = cnt.dataset.base || cnt.textContent;
if (cnt) cnt.textContent = q ? shown + "개 찾음" : cnt.dataset.base;
return;
}
if (!inp.dataset || !inp.dataset.key) return;
const tr = inp.closest("tr");
const w = dec(tr.querySelector('[data-key="weight_g"]').value), pct = dec(tr.querySelector('[data-key="silver_pct"]').value);
const ag = tr.querySelector(".io-ag");
if (ag) ag.textContent = w !== null && pct !== null ? (Math.round(w * pct / 100 * 10000) / 10000).toLocaleString("ko-KR", { maximumFractionDigits: 4 }) : "-";
tr.classList.toggle("is-dirty", Array.from(tr.querySelectorAll("input[data-key]")).some(function (i) { return i.value.trim() !== i.defaultValue.trim(); }));
paintDirty();
});
body.addEventListener("click", async function (e) {
const t = e.target;
if (t.id === "io-prod-import") {
if (dirtyRows().length && !(await confirmMsg("저장 안 한 변경이 있습니다. 버리고 불러올까요?"))) return;
t.disabled = true;
say("코드표에서 단품을 불러오는 중…");
try { await act("/inout/settings/products/import"); } finally { t.disabled = false; }
} else if (t.closest("#io-prod-save")) {
const rows = dirtyRows().map(function (tr) {
const v = function (k) { return tr.querySelector('[data-key="' + k + '"]').value.trim(); };
return { code: tr.dataset.code, unit_price: v("unit_price"), weight_g: v("weight_g"), silver_pct: v("silver_pct") };
});
if (rows.length) await act("/inout/settings/products/save", { rows: rows });
} else if (t.dataset && t.dataset.exclude) {
if (await confirmMsg(t.dataset.exclude + " 를 상품 정보에서 지울까요? 다음 불러오기에서도 빠집니다(지난 발주서는 그대로)."))
await act("/inout/settings/products/" + encodeURIComponent(t.dataset.exclude) + "/exclude");
} else if (t.dataset && t.dataset.restore) {
await act("/inout/settings/products/" + encodeURIComponent(t.dataset.restore) + "/restore");
}
});
// 저장 안 한 상품 정보가 있으면 닫기 전에 묻는다(✕·취소·Esc)
dlg.addEventListener("cancel", function (e) {
if (dirtyRows().length) { e.preventDefault(); confirmMsg("저장 안 한 상품 정보 변경이 있습니다. 닫을까요?").then(function (ok) { if (ok) dlg.close(); }); }
});
dlg.addEventListener("click", function (e) {
if (e.target.closest("[data-close]") && dirtyRows().length) {
e.stopImmediatePropagation();
confirmMsg("저장 안 한 상품 정보 변경이 있습니다. 닫을까요?").then(function (ok) { if (ok) dlg.close(); });
}
}, true);
if (btn.dataset.open === "1") open();
}
// ── 입고증 사진(003) — 브라우저에서 줄여(긴 변 2000px JPEG) 올린다. 못 줄이는 형식(HEIC 등)은 원본 그대로 ──
const PHOTO_MAX_SIDE = 2000;
async function shrinkPhoto(file) {
if (!/^image\/(jpeg|png|webp)$/i.test(file.type)) return file; // GIF(움직임)·HEIC 등은 그대로
try {
const bmp = await createImageBitmap(file);
const scale = Math.min(1, PHOTO_MAX_SIDE / Math.max(bmp.width, bmp.height));
if (scale === 1 && file.size < 1.5 * 1024 * 1024) { bmp.close && bmp.close(); return file; }
const cv = document.createElement("canvas");
cv.width = Math.round(bmp.width * scale);
cv.height = Math.round(bmp.height * scale);
cv.getContext("2d").drawImage(bmp, 0, 0, cv.width, cv.height);
bmp.close && bmp.close();
const blob = await new Promise(function (r) { cv.toBlob(r, "image/jpeg", 0.85); });
if (!blob || blob.size >= file.size) return file;
return new File([blob], file.name.replace(/\.[^.]+$/, "") + ".jpg", { type: "image/jpeg", lastModified: file.lastModified });
} catch (_) { return file; }
}
async function prepare(input) {
const max = parseInt(input.dataset.max || "10", 10);
let files = Array.from(input._ioFiles || []).concat(Array.from(input.files || []));
if (files.length > max) {
alertMsg("입고증 사진은 " + max + "장까지 올릴 수 있습니다 — 앞의 " + max + "장만 넣습니다.");
files = files.slice(0, max);
}
input.disabled = true;
const done = [];
for (const f of files) done.push(f._ioShrunk ? f : Object.assign(await shrinkPhoto(f), { _ioShrunk: true }));
input.disabled = false;
setFiles(input, done);
return done;
}
function setFiles(input, files) {
input._ioFiles = files;
try {
const dt = new DataTransfer();
files.forEach(function (f) { dt.items.add(f); });
input.files = dt.files;
} catch (_) { /* 아주 옛 브라우저 — 고른 원본 그대로 올라간다 */ }
}
function paintPreviews(input, box) {
box.innerHTML = "";
(input._ioFiles || []).forEach(function (f, i) {
const chip = document.createElement("span");
chip.className = "io-photo-chip";
const img = document.createElement("img");
img.alt = "";
if (/^image\/(jpeg|png|webp|gif)$/i.test(f.type)) img.src = URL.createObjectURL(f);
chip.appendChild(img);
const meta = document.createElement("span");
meta.textContent = f.name + " · " + Math.max(1, Math.round(f.size / 1024)) + "KB";
chip.appendChild(meta);
const x = document.createElement("button");
x.type = "button";
x.textContent = "✕";
x.setAttribute("aria-label", f.name + " 빼기");
x.addEventListener("click", function () {
const left = input._ioFiles.filter(function (_f, k) { return k !== i; });
input.value = "";
setFiles(input, left);
paintPreviews(input, box);
});
chip.appendChild(x);
box.appendChild(chip);
});
}
document.addEventListener("change", async function (e) {
const input = e.target;
if (!input.classList || !input.classList.contains("io-photo-input")) return;
if (input.classList.contains("io-photo-auto")) { // 입고 기록 [+] — 고르면 바로 올림
input._ioFiles = [];
const files = await prepare(input);
if (files.length) input.form.submit();
return;
}
const fresh = Array.from(input.files || []);
input._ioFiles = (input._ioFiles || []).filter(function () { return true; });
input.value = "";
try { const dt = new DataTransfer(); fresh.forEach(function (f) { dt.items.add(f); }); input.files = dt.files; } catch (_) {}
await prepare(input);
const box = document.getElementById("io-photo-previews");
if (box) paintPreviews(input, box);
});
// ── 입고 저장 전 초과 확인(브라우저) — 서버까지 갔다 오면 고른 사진이 사라지므로 여기서 먼저 묻는다 ──
const recvForm2 = document.getElementById("io-receipt-form");
if (recvForm2) recvForm2.addEventListener("submit", function (e) {
const flag = document.getElementById("io-confirm-over");
if (!flag || flag.value === "1" || (e.submitter && e.submitter.name === "confirm_over")) return;
const overs = Array.from(recvForm2.querySelectorAll(".io-recv")).map(function (i) {
const after = num(i.dataset.received) + num(i.value);
return { code: i.dataset.code, name: i.dataset.name, ordered: num(i.dataset.ordered), after: after, add: num(i.value) };
}).filter(function (x) { return x.add && x.after > x.ordered; });
if (!overs.length) return;
e.preventDefault();
const lines = overs.map(function (x) { return x.code + " " + x.name + " — 발주 " + fmt(x.ordered) + "개, 입고 후 " + fmt(x.after) + "개(+" + fmt(x.after - x.ordered) + ")"; });
confirmMsg("발주보다 많이 입고하려고 합니다.\n\n" + lines.join("\n") + "\n\n초과 입고로 저장할까요?").then(function (ok) {
if (!ok) return;
flag.value = "1";
if (recvForm2.requestSubmit) recvForm2.requestSubmit(); else recvForm2.submit();
});
});
// ── 입고증 사진 크게 보기 ──
const viewer = document.getElementById("io-viewer");
if (viewer) {
const img = document.getElementById("io-viewer-img"), heic = document.getElementById("io-viewer-heic");
const title = document.getElementById("io-viewer-title"), openA = document.getElementById("io-viewer-open");
const del = document.getElementById("io-viewer-del");
let list = [], at = 0;
function show(i) {
at = (i + list.length) % list.length;
const b = list[at], id = b.dataset.photo, isHeic = b.dataset.type === "image/heic";
img.hidden = isHeic;
heic.hidden = !isHeic;
if (!isHeic) img.src = "/inout/photos/" + id;
openA.href = "/inout/photos/" + id;
title.textContent = (b.dataset.name || "입고증") + " (" + (at + 1) + "/" + list.length + ")";
if (del) del.action = "/inout/orders/" + viewer.dataset.order + "/photos/" + id + "/delete";
viewer.querySelectorAll(".io-viewer-nav").forEach(function (n) { n.hidden = list.length < 2; });
}
document.addEventListener("click", function (e) {
const b = e.target.closest(".io-thumb[data-photo]");
if (!b) return;
list = Array.from(document.querySelectorAll('.io-thumb[data-receipt="' + b.dataset.receipt + '"][data-photo]'));
show(list.indexOf(b));
viewer.showModal();
viewer.focus({ preventScroll: true }); // [원본]에 초점 테두리가 생기지 않게(←/→ 는 창에서 받음)
});
viewer.addEventListener("click", function (e) {
if (e.target === viewer || e.target.closest("[data-close]")) viewer.close();
const step = e.target.closest("[data-step]");
if (step) show(at + parseInt(step.dataset.step, 10));
});
viewer.addEventListener("keydown", function (e) {
if (e.key === "ArrowLeft") show(at - 1);
if (e.key === "ArrowRight") show(at + 1);
});
}
// ── 메일 창 — 발주 메일(003)·입고 요청 메일(005) 공용. 미리보기를 받아 보여 주고, [메일 발송]을 눌러야 보낸다 ──
// 발주 메일: 머리 [발주 메일 보내기] → GET|POST /inout/orders/{id}/mail (발주 담당 본인 Gmail, 받는 사람 = 공장 이메일)
// 입고 요청 메일: 입고 저장 뒤 바로(?rmail=입고 id) 또는 입고 기록 줄 [보내기] → GET|POST …/receipts/{rid}/mail
// (입고 담당 본인 Gmail, 받는 사람 = 옵션 → 물류센터 이메일, 참조 기본 = 옵션 값, 본문에 입고증 사진)
const mailBtn = document.getElementById("io-mail-btn"), mailDlg = document.getElementById("io-mail");
if (mailBtn && mailDlg) {
const om = initMail(mailDlg, { param: "mail", what: "발주 메일" });
const url = "/inout/orders/" + mailBtn.dataset.order + "/mail";
mailBtn.addEventListener("click", function () { om.open(url); });
if (mailBtn.dataset.open === "1") om.open(url);
}
const rmailDlg = document.getElementById("io-rmail");
if (rmailDlg) {
const rm = initMail(rmailDlg, { param: "rmail", what: "입고 요청 메일" });
document.querySelectorAll(".io-rmail-btn").forEach(function (b) {
b.addEventListener("click", function () { rm.open(b.dataset.url, b.dataset.title); });
});
if (rmailDlg.dataset.openUrl) rm.open(rmailDlg.dataset.openUrl, rmailDlg.dataset.openTitle);
}
function initMail(dlg, cfg) {
const body = dlg.querySelector("[data-mail-body]"), foot = dlg.querySelector("[data-mail-foot]");
const msgEl = dlg.querySelector(".io-dlg-msg"), sendBtn = dlg.querySelector("[data-mail-send]");
const titleEl = dlg.querySelector("[data-mail-title]");
let base = "", data = null, sent = false;
function say(text, bad) { msgEl.textContent = text || ""; msgEl.hidden = !text; msgEl.classList.toggle("is-bad", !!bad); }
function esc(s) { const d = document.createElement("div"); d.textContent = s == null ? "" : String(s); return d.innerHTML; }
function field(name) { return body.querySelector('[data-mail-field="' + name + '"]'); }
async function load() {
const res = await fetch(base, { headers: { Accept: "application/json" } });
data = await res.json();
if (!res.ok) throw new Error(data.detail || "HTTP " + res.status);
if (!data.connected) {
foot.hidden = true;
body.innerHTML = '<div class="io-mail-connect">' +
"<p><b>" + esc(cfg.what) + "은 내 Gmail(" + esc(data.from) + ")로 보냅니다.</b> 처음 한 번만 Gmail 연결이 필요합니다.</p>" +
"<p class=\"erp-muted\">구글 화면에서 <b>같은 계정</b>을 고르고 '메일 보내기' 권한을 허락하세요. 보내기 권한만 받으며, 메일함은 읽지 않습니다.</p>" +
(data.configured ? "" : '<p class="io-error">서버 설정(APP_ENCRYPTION_KEY·구글 OAuth)이 없어 연결할 수 없습니다 — 관리자에게 알려 주세요.</p>') +
'<a class="erp-btn erp-btn-primary" href="' + esc(data.connect_url) + '">Gmail 연결</a>' +
// 구글이 redirect_uri_mismatch 로 막으면 ERP 로 돌아오지 않는다 — 등록할 주소를 미리 보여 준다
'<div class="io-mail-admin">구글 화면에 <b>400 오류: redirect_uri_mismatch</b> 가 나오면, 관리자가 구글 클라우드 → API 및 서비스 → 사용자 인증 정보 → ' +
'로그인용 OAuth 클라이언트 → <b>승인된 리디렉션 URI</b>에 아래 주소를 추가해야 합니다(Gmail API 사용·gmail.send 범위도 함께).<br>' +
'<code>' + esc(data.callback_url) + '</code></div></div>';
return;
}
foot.hidden = false;
const receipt = data.kind === "receipt";
const sentList = (data.sent || []).map(function (m) { return "<li>" + esc(m.at) + " · " + esc(m.by) + " → " + esc(m.to) + "</li>"; }).join("");
let hint = "";
if (!data.to) {
hint = receipt ? "물류센터 담당자 이메일이 옵션에 없습니다 — 받는 사람을 직접 넣거나, 관리자가 옵션 → 물류센터에 넣어 두세요."
: (data.factory || "공장") + " 이메일이 옵션에 없습니다 — 받는 사람을 직접 넣거나, 관리자가 옵션 → 공장에 넣어 두세요.";
}
if (receipt && data.ready === false) hint += (hint ? " " : "") + "(DB 마이그레이션 005 전이라 보낸 기록이 남지 않습니다.)";
// 발주 메일 — 보내면 입고 담당에게 발주 알림(발주번호·발주일·품목·수량)이 같은 제목으로 따로 자동 발송된다
const notice = !receipt && data.notice_to ? (data.notice_to.length
? "메일 발송 시 입고 담당(" + data.notice_to.join(", ") + ")에게 발주 알림 메일(발주번호·발주일·제품 코드·제품명·수량)이 따로 자동 발송됩니다."
: "입고 담당이 옵션에 없어 발주 알림 메일은 가지 않습니다(옵션 → 담당자에서 지정).") : "";
body.innerHTML =
'<div class="io-mail-fields">' +
"<label><span>보내는 사람</span><input class=\"io-in\" value=\"" + esc(data.from) + "\" readonly /></label>" +
"<label><span>받는 사람 *</span><input class=\"io-in\" data-mail-field=\"to\" value=\"" + esc(data.to) + "\" placeholder=\"" +
(receipt ? "물류센터 담당자 이메일 — 옵션에서 넣어 두면 자동" : "공장 이메일 — 옵션에서 넣어 두면 자동") + "\" /></label>" +
"<label><span>참조</span><input class=\"io-in\" data-mail-field=\"cc\" value=\"" + esc(data.cc || "") + "\" placeholder=\"여러 개는 쉼표로\" /></label>" +
"<label><span>제목</span><input class=\"io-in\" value=\"" + esc(data.subject) + "\" readonly /></label></div>" +
(hint ? '<p class="io-hint">' + esc(hint) + "</p>" : "") +
(notice ? '<p class="io-mail-notice">' + esc(notice) + "</p>" : "") +
(receipt && data.photos_skipped ? '<p class="io-hint">HEIC 등 본문에 넣지 못하는 입고증 사진 ' + esc(data.photos_skipped) + "장은 빠집니다(입고 기록에는 그대로).</p>" : "") +
(sentList ? '<div class="io-mail-sentlist"><b>보낸 기록</b><ul>' + sentList + "</ul></div>" : "") +
'<iframe class="io-mail-preview" sandbox title="메일 본문 미리보기"></iframe>';
body.querySelector(".io-mail-preview").srcdoc = data.html;
sendBtn.textContent = (data.sent || []).length ? "다시 발송" : "메일 발송";
}
async function open(url, title) {
base = url;
if (title && titleEl) titleEl.textContent = title;
say("");
sent = false;
if (!dlg.open) dlg.showModal();
dlg.focus({ preventScroll: true });
body.innerHTML = '<p class="erp-muted">불러오는 중…</p>';
foot.hidden = true;
try { await load(); } catch (err) { body.innerHTML = '<p class="io-error">' + esc(err.message) + "</p>"; foot.hidden = true; }
}
async function send(resend) {
const to = field("to").value, cc = field("cc").value;
sendBtn.disabled = true;
say("보내는 중…");
try {
const res = await fetch(base, { method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ to: to, cc: cc, resend: !!resend }) });
const out = await res.json();
if (out.resend_needed) {
say("");
if (await confirmMsg(out.message)) return send(true);
return;
}
if (out.reconnect) { say(out.message, true); await load(); return; }
if (!res.ok || !out.ok) { say(out.message || out.detail || "보내지 못했습니다.", true); return; }
sent = true;
say(out.message);
await load();
} catch (_) {
say("보내지 못했습니다(연결 오류). 다시 눌러 주세요.", true);
} finally { sendBtn.disabled = false; }
}
sendBtn.addEventListener("click", function () { send(false); });
dlg.querySelector("[data-gmail-disconnect]").addEventListener("click", async function () {
if (!(await confirmMsg("Gmail 연결을 끊을까요? 다음에 보낼 때 다시 연결해야 합니다."))) return;
await fetch("/inout/gmail/disconnect", { method: "POST" });
await load();
say("Gmail 연결을 끊었습니다.");
});
dlg.addEventListener("click", function (e) { if (e.target.closest("[data-close]")) dlg.close(); });
dlg.addEventListener("close", function () {
const url = new URL(location.href);
const had = url.searchParams.has(cfg.param);
url.searchParams.delete(cfg.param);
url.searchParams.delete("msg");
if (sent) location.href = url.toString(); // 보낸 기록(머리·입고 기록 칸)이 바뀌었다
else if (had) history.replaceState(null, "", url.toString());
});
return { open: open };
}
})();
+34
View File
@@ -75,6 +75,9 @@ a.perf-tab.is-active:link, a.perf-tab.is-active:visited { color: #fff; }
.perf-detail-btn .material-symbols-outlined { font-size: 16px; }
.perf-detail-btn:hover { background: #fff1ea; text-decoration: underline; }
.perf-detail-table th, .perf-detail-table td { white-space: nowrap; }
/* 상세보기 [합계 | 계정…] 탭(메타 — 여러 광고 계정) */
.perf-detail-tabs { flex-wrap: wrap; margin-bottom: 10px; }
.perf-detail-tabs .perf-seg.is-active { background: var(--perf-ad); }
.perf-ad-upload-btn { margin-left: auto; }
.perf-kpi-pct { font-size: 26px; font-weight: 700; }
@@ -140,6 +143,11 @@ a.perf-seg.is-active, a.perf-seg.is-active:link, a.perf-seg.is-active:visited {
.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; }
/* 매출 실적 KPI 한 줄(2026-10-19) — 수수료 차감 매출 금액 + 비교 기간 대비 %, 화면 왼쪽 */
.perf-kpi-line { display: flex; align-items: baseline; gap: 8px; flex-wrap: wrap; font-size: 13px; padding: 2px 2px 0; }
.perf-kpi-line-value { font-size: 22px; font-weight: 700; letter-spacing: -.5px; color: var(--color-rich-black); white-space: nowrap; }
/* 다음 자동 업데이트까지 남은 시간(초 단위) — 숫자 폭이 바뀌어도 흔들리지 않게 */
.perf-next-update b { font-variant-numeric: tabular-nums; }
.perf-delta { font-weight: 600; }
.perf-delta.is-up { color: var(--perf-good); } /* is-up = 좋음(수수료는 줄어야 좋음, invert) */
.perf-delta.is-down { color: var(--perf-down); }
@@ -349,3 +357,29 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; }
.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; }
/* ── 매출 칸 아래 광고비(ROAS%) — 광고비 화면 색(--perf-ad), 카페24 는 구글·메타 두 줄(2026-10-19) ── */
.perf-adl { display: block; margin-top: 1px; font-size: 11px; line-height: 1.35; font-weight: 600; color: var(--perf-ad); white-space: nowrap; }
.perf-adl i { margin-right: 3px; font-style: normal; font-weight: 500; opacity: .8; }
.perf-adl em { margin-left: 1px; font-style: normal; font-weight: 500; opacity: .85; }
.perf .perf-main td.is-editing .perf-adl { visibility: hidden; }
/* 일 합계 광고비(ROAS%) — ROAS 는 일 합계 금액 ÷ 광고비라 표시 기준(수수료 차감 매출 / 그 밖)에 따라 하나만 */
.perf .perf-adl-tot { display: none; }
.perf[data-metric="net"] .perf-adl-tot.for-net,
.perf:not([data-metric="net"]) .perf-adl-tot.for-gross { display: block; }
.perf-adl-note { display: inline-flex; align-items: center; gap: 5px; color: var(--perf-ad); font-weight: 600; }
.perf-adl-key { width: 10px; height: 10px; border-radius: 3px; background: var(--perf-ad); }
.perf-unit-note { margin-left: 4px; }
.perf-unit-suffix { margin-left: 2px; font-size: .55em; font-weight: 600; color: var(--color-midtone-gray, #777); }
/* 보기 설정(매출 단위) */
.perf-opt-row { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
.perf-opt-label { font-weight: 600; }
.perf-head-notes { display: inline-flex; align-items: center; gap: 12px; margin-right: auto; margin-left: 12px; font-size: 12px; }
/* 주문 내역 추가 칸(카페24 적립금 · 네이버 배송비·환불금액, 2026-10-19) */
.perf-ev-table .perf-ev-x { white-space: nowrap; color: #6b4e00; }
.perf-ev-xsub { font-size: 11px; font-weight: 500; color: var(--color-midtone-gray, #777); }
.perf-ev-table tfoot .perf-ev-x, .perf-ev-table tfoot .perf-ev-x b { color: #fff; } /* 검은 합계 줄 — 흰 글자 */
.perf-ev-table tfoot .perf-ev-xsub { color: #c9c9c9; }
/* [매출 업데이트] — 업데이트 중이면 "업데이트 중 · 진행 보기"(눌러서 진행 창 다시 열기), 살짝 깜박임 */
#perf-sync-btn.is-running { animation: perf-sync-pulse 1.6s ease-in-out infinite; }
@keyframes perf-sync-pulse { 0%, 100% { opacity: 1; } 50% { opacity: .72; } }
+177 -476
View File
@@ -24,6 +24,13 @@
}
function fmt(n) { return Number(n || 0).toLocaleString("ko-KR"); }
function won(n) { return n ? fmt(n) : '<span class="perf-zero">–</span>'; }
// 매출 단위(실적 설정 "보기 설정", 쿠키 perf_unit) — 서버 dashboard.amount_text 와 같은 표기(천원 정수, 백만원 소수 한 자리)
function unitWon(n, unit) {
if (!n) return won(0);
if (unit === "thousand") return Math.round(n / 1000).toLocaleString("ko-KR");
if (unit === "million") return (Math.round(n / 100000) / 10).toLocaleString("ko-KR", { minimumFractionDigits: 1, maximumFractionDigits: 1 });
return fmt(n);
}
// 축 눈금용 짧은 금액(1.2억 / 350만)
function short(n) {
const a = Math.abs(n), s = n < 0 ? "-" : "";
@@ -141,7 +148,8 @@
if (job.error) html += '<p class="perf-notice is-warn">' + esc(job.error) + "</p>";
box.innerHTML = html;
}
function runSyncWithProgress(payload, title) {
// existing = 이미 돌고 있는 작업(GET /api/sync/current) — 주면 새로 시작하지 않고 그 진행 창만 다시 연다(2026-10-19)
function runSyncWithProgress(payload, title, existing) {
return new Promise(function (resolve, reject) {
let timer = null, closed = false, last = null;
const m = openModal(title || "매출 업데이트", { narrow: true, onClose: function () { closed = true; clearTimeout(timer); if (last) resolve(last); } });
@@ -187,7 +195,8 @@
alertMsg("취소 실패: " + err.message);
}
});
api("POST", "/performance/api/sync", Object.assign({ background: true }, payload)).then(function (res) {
(existing ? Promise.resolve({ job: existing, joined: true })
: api("POST", "/performance/api/sync", Object.assign({ background: true }, payload))).then(function (res) {
last = res.job;
jobId = res.job.id;
const joined = res.joined;
@@ -235,7 +244,6 @@
function initDashboard(root) {
const data = JSON.parse((document.getElementById("perf-data") || {}).textContent || "{}");
const METRIC_NAMES = { gross: "총매출", commission: "수수료", net: "수수료 차감 매출" };
const KEY = "perf_metric";
const FIXED_METRIC = root.dataset.fixedMetric || ""; // 광고비 화면 = 금액 하나(gross)뿐
const MANUAL_API = data.manual_api || "/performance/api/manual-sales/";
const MANUAL_WORD = data.manual_word || "총매출";
@@ -249,7 +257,6 @@
root.querySelectorAll(".perf-metric .perf-seg").forEach(function (b) {
b.classList.toggle("is-active", b.dataset.metric === m);
});
if (!FIXED_METRIC) { try { localStorage.setItem(KEY, m); } catch (_) {} }
drawDaily(m);
drawShare(m);
root.querySelectorAll(".perf-metric-name").forEach(function (n) { n.textContent = METRIC_NAMES[m]; });
@@ -403,7 +410,7 @@
}
});
// 광고 보고서 일자별 상세(네이버·구글 머리글) — 지금 보는 기간의 날마다 광고비·ROAS·보고서 항목, 맨 아래 합계.
// 광고 보고서 일자별 상세(네이버·구글·메타 머리글) — 지금 보는 기간의 날마다 광고비·ROAS·보고서 항목, 맨 아래 합계.
root.addEventListener("click", async function (e) {
const btn = e.target.closest("[data-detail-channel]");
if (!btn) return;
@@ -425,15 +432,48 @@
const d = new Date(iso + "T00:00:00");
return iso.slice(5, 7) + "/" + iso.slice(8, 10) + "(" + WD[d.getDay()] + ")";
};
m.body.innerHTML = '<div class="perf-ev-wrap"><table class="perf-table perf-detail-table"><thead><tr><th class="perf-th-label">날짜</th>' +
cols.map(function (c) { return "<th>" + esc(c) + "</th>"; }).join("") + "</tr></thead><tbody>" +
res.rows.map(function (r) {
return '<tr><th class="perf-td-label" scope="row">' + esc(day(r.date)) + "</th>" +
cols.map(function (c) { return '<td class="perf-num">' + cell((r.values || {})[c]) + "</td>"; }).join("") + "</tr>";
}).join("") + '</tbody><tfoot><tr class="perf-row-total"><th class="perf-td-label" scope="row">합계</th>' +
cols.map(function (c) { return '<td class="perf-num">' + cell((res.total || {})[c]) + "</td>"; }).join("") +
"</tr></tfoot></table></div>" +
'<p class="perf-muted">합계: 숫자 항목은 더한 값, 클릭률 = 클릭수 ÷ 노출수, 광고수익률·ROAS = 날짜별 값을 광고비로 가중 평균.</p>';
const table = function (t) {
const tcols = t.columns || cols;
const labels = t.labels || res.labels || {};
return '<div class="perf-ev-wrap"><table class="perf-table perf-detail-table"><thead><tr><th class="perf-th-label">날짜</th>' +
tcols.map(function (c) {
// 화면 머리글(labels)이 따로 있으면 그것을, 말풍선엔 파일 원래 머리글(네이버 "구매완료 광고수익률(%)" → ROAS(%))
return labels[c] ? '<th title="' + esc(c) + '">' + esc(labels[c]) + "</th>" : "<th>" + esc(c) + "</th>";
}).join("") + "</tr></thead><tbody>" +
(t.rows || []).map(function (r) {
return '<tr><th class="perf-td-label" scope="row">' + esc(day(r.date)) + "</th>" +
tcols.map(function (c) { return '<td class="perf-num">' + cell((r.values || {})[c]) + "</td>"; }).join("") + "</tr>";
}).join("") + '</tbody><tfoot><tr class="perf-row-total"><th class="perf-td-label" scope="row">합계</th>' +
tcols.map(function (c) { return '<td class="perf-num">' + cell((t.total || {})[c]) + "</td>"; }).join("") +
"</tr></tfoot></table></div>";
};
const foot = '<p class="perf-muted">합계: 숫자 항목은 더한 값, 클릭률 = 클릭수 ÷ 노출수, 광고수익률·ROAS = 날짜별 값을 광고비로 가중 평균.</p>';
const tabs = res.tabs || [];
if (tabs.length < 2) { m.body.innerHTML = table(res) + foot; return; }
// 여러 광고 계정을 합치는 채널(메타) — [합계 | 계정…] 탭. 계정 탭 = 그 계정이 광고를 낸 날만.
const missing = res.accounts_missing
? '<p class="perf-notice">' + fmt(res.accounts_missing) + "일은 계정별 자료가 없어 합계 탭에만 있습니다 — [" + esc(name) +
" 광고 불러오기]로 그 기간을 다시 가져오면 계정별로 나뉩니다.</p>"
: "";
m.body.innerHTML = '<div class="perf-quick perf-detail-tabs" role="tablist" aria-label="계정">' +
tabs.map(function (t, i) {
return '<button type="button" class="perf-seg' + (i ? "" : " is-active") + '" role="tab" aria-selected="' + (i ? "false" : "true") +
'" data-tab="' + i + '"' + (t.account_id ? ' title="act_' + esc(t.account_id) + '"' : "") + ">" + esc(t.label) + "</button>";
}).join("") + '</div><div class="perf-detail-tab-body"></div>' + missing + foot;
const bodyEl = m.body.querySelector(".perf-detail-tab-body");
const show = function (i) {
m.body.querySelectorAll(".perf-detail-tabs [data-tab]").forEach(function (b) {
const on = Number(b.dataset.tab) === i;
b.classList.toggle("is-active", on);
b.setAttribute("aria-selected", on ? "true" : "false");
});
bodyEl.innerHTML = table(tabs[i]) + (i ? '<p class="perf-muted">계정마다 따로 반올림해 계정 광고비의 합이 합계 탭과 1원 다를 수 있습니다.</p>' : "");
};
m.body.querySelector(".perf-detail-tabs").addEventListener("click", function (ev) {
const b = ev.target.closest("[data-tab]");
if (b) show(Number(b.dataset.tab));
});
show(0);
} catch (err) {
m.body.innerHTML = '<p class="perf-notice is-warn">' + esc(err.message) + "</p>";
}
@@ -461,15 +501,24 @@
const syncBtn = document.getElementById("perf-sync-btn");
const resultBox = document.getElementById("perf-sync-result");
if (syncBtn) syncBtn.addEventListener("click", async function () {
syncBtn.disabled = true;
const label = syncBtn.textContent;
syncBtn.textContent = "업데이트 중…";
if (syncBtn.dataset.busy === "1") return; // 같은 창을 두 번 열지 않게
syncBtn.dataset.busy = "1";
syncBtn.textContent = "업데이트 중 · 진행 보기";
syncBtn.classList.add("is-running");
try {
// 지금 보고 있는 기간(오늘까지)을 가져온다 — "이번달"이면 1일부터 오늘까지.
const from = data.period_start, to = data.period_end < data.today ? data.period_end : data.today;
if (from > data.today) throw new Error("앞으로의 기간은 가져올 수 없습니다.");
// 진행 창(쇼핑몰별·전체 막대) — 창을 닫아도 서버에서 계속된다.
const job = await runSyncWithProgress({ from: from, to: to }, "매출 업데이트 " + from + " ~ " + to);
// 이미 돌고 있는 업데이트(다른 사람·자동 업데이트 포함)가 있으면 새로 시작하지 않고 그 진행 창을 다시 연다
let cur = null;
try { cur = (await api("GET", "/performance/api/sync/current")).job; } catch (_) { cur = null; }
let job;
if (cur && !cur.finished) {
job = await runSyncWithProgress(null, "매출 업데이트 진행 상황 " + (cur.from || "") + " ~ " + (cur.to || ""), cur);
} else {
// 지금 보고 있는 기간(오늘까지)을 가져온다 — "이번달"이면 1일부터 오늘까지.
const from = data.period_start, to = data.period_end < data.today ? data.period_end : data.today;
if (from > data.today) throw new Error("앞으로의 기간은 가져올 수 없습니다.");
// 진행 창(쇼핑몰별·전체 막대) — 창을 닫아도 서버에서 계속된다.
job = await runSyncWithProgress({ from: from, to: to }, "매출 업데이트 " + from + " ~ " + to);
}
const res = { results: jobResults(job).filter(function (r) { return r.finished; }), last_update_at: job && job.last_update_at };
const running = job && !job.finished;
// 실패(빨강)는 인증 실패·API 오류처럼 손봐야 하는 것만. 인증정보를 아직 안 넣은 쇼핑몰(미설정)과
@@ -494,7 +543,7 @@
if (cancelled.length) parts.push("<b>취소됨</b>(기존 매출 그대로) " + esc(cancelled.join(", ")));
if (pending.length) parts.push('<span class="perf-muted">연동 준비 중: ' + esc(pending.join(", ")) + "</span>");
if (unset.length) parts.push('<span class="perf-muted">인증정보 미설정: ' + esc(unset.join(", ")) + "</span>");
if (running) parts.unshift("<b>업데이트가 아직 진행 중입니다</b> — 끝나면 다시 [매출 업데이트]를 눌러 결과를 보세요");
if (running) parts.unshift("<b>업데이트가 아직 진행 중입니다</b> — [업데이트 중 · 진행 보기]를 누르면 진행 창을 다시 볼 수 있습니다");
resultBox.innerHTML = parts.join(" · ") || "업데이트할 쇼핑몰이 없습니다.";
resultBox.className = "perf-notice" + (bad.length ? " is-warn" : " is-ok");
resultBox.hidden = false;
@@ -503,13 +552,18 @@
if (lu) lu.textContent = res.last_update_at.slice(0, 16).replace("T", " ");
}
if (changed > 0 && !running) setTimeout(function () { location.reload(); }, 800);
syncBtn.dataset.running = running ? "1" : ""; // 창을 닫았는데 아직 진행 중 → 버튼은 [업데이트 중 · 진행 보기]
} catch (err) {
resultBox.textContent = "업데이트 실패: " + err.message;
resultBox.className = "perf-notice is-warn";
resultBox.hidden = false;
syncBtn.dataset.running = "";
} finally {
syncBtn.disabled = false;
syncBtn.textContent = label === "업데이트 중…" ? "매출 업데이트" : label;
syncBtn.dataset.busy = "";
const still = syncBtn.dataset.running === "1";
syncBtn.textContent = still ? "업데이트 중 · 진행 보기" : "매출 업데이트";
syncBtn.classList.toggle("is-running", still);
syncBtn.title = still ? "업데이트 진행 상황 보기" : "지금 보고 있는 기간의 매출을 쇼핑몰에서 다시 가져옵니다";
}
});
@@ -553,7 +607,7 @@
td.title = manual !== "" ? "직접 입력값 — 눌러 고치기(비우고 저장하면 " + (FIXED_METRIC ? "지움" : "API 값") + ")"
: "눌러 " + MANUAL_WORD + " 직접 입력";
const g = td.querySelector(".v-gross");
if (g) g.innerHTML = won(res.amount);
if (g) g.innerHTML = unitWon(res.amount, data.unit);
td.classList.add("is-stale"); // 수수료·차감 매출은 새로고침 때 다시 계산
manualDirty = true;
return true;
@@ -617,29 +671,58 @@
const rows = res.rows || [];
if (!rows.length) { m.body.innerHTML = '<p class="perf-muted">내역이 없습니다.</p>'; return; }
const KIND = { SALE: "결제", CANCEL: "취소", RETURN: "반품", ADJUST: "조정" };
let sum = 0, sales = 0, minus = 0;
// 쇼핑몰별 추가 칸(2026-10-19) — 카페24 적립금 사용(매출에서 뺀 금액, 환불 줄은 돌려준 적립금 −),
// 네이버 배송비(매출에 더한 금액)·환불금액(환불된 날 매출에서 뺀 금액). 맨 아래 합계.
const EXTRA = { cafe24: [{ key: "points", label: "적립금 사용" }],
naver: [{ key: "ship", label: "배송비" }, { key: "refund", label: "환불금액" }] }[code] || [];
const xsum = EXTRA.map(function () { return { plus: 0, minus: 0 }; });
// 네이버 금액 칸 = 판매금액(배송비 뺀 값, raw goods) — 저장 금액은 판매금액 + 배송비라 배송비 칸과 겹쳐 보이지 않게(2026-10-19)
const goodsOf = function (r) { return code === "naver" && r.goods != null ? r.goods : r.amount; };
let sum = 0, sales = 0, minus = 0, total = 0;
const body = rows.map(function (r) {
sum += r.amount;
if (r.amount >= 0) sales += r.amount; else minus += r.amount;
const shown = goodsOf(r);
sum += shown;
total += r.amount;
if (shown >= 0) sales += shown; else minus += shown;
const xcells = EXTRA.map(function (x, k) {
const v = r[x.key];
if (v == null || v === 0) return '<td class="perf-num perf-ev-x"></td>';
if (v > 0) xsum[k].plus += v; else xsum[k].minus += v;
return '<td class="perf-num perf-ev-x">' + fmt(v) + "</td>";
}).join("");
return '<tr class="' + (r.event_type === "CANCEL" ? "is-cancel" : r.amount < 0 ? "perf-ev-cancel" : "") + '">' +
"<td>" + esc(r.sales_date) + "</td><td>" + esc(KIND[r.event_type] || r.event_type) +
(r.is_sample ? ' <span class="perf-pill">테스트</span>' : "") + "</td>" +
"<td>" + esc(r.external_order_id) + "</td>" +
'<td class="perf-ev-name">' + esc(r.product_name) + (r.option_name ? " <span class='perf-muted'>" + esc(r.option_name) + "</span>" : "") + "</td>" +
'<td class="perf-num">' + esc(r.quantity) + "</td>" +
'<td class="perf-num">' + fmt(r.amount) + "</td>" +
'<td class="perf-num">' + fmt(shown) + "</td>" + xcells +
"<td>" + esc(r.order_date || "") + "</td><td>" + esc(r.payment_date || "") + "</td>" +
"<td>" + esc(r.order_status) + "</td></tr>";
}).join("");
m.body.innerHTML =
'<div class="perf-ev-wrap"><table class="perf-table perf-ev-table"><thead><tr>' +
'<th class="perf-th-label">매출일</th><th class="perf-th-label">구분</th><th class="perf-th-label">주문번호</th>' +
'<th class="perf-th-label perf-ev-name">상품명</th><th>수량</th><th>금액</th><th class="perf-th-label">주문일</th>' +
'<th class="perf-th-label perf-ev-name">상품명</th><th>수량</th><th>' + (code === "naver" ? "판매금액" : "금액") + "</th>" +
EXTRA.map(function (x) { return '<th class="perf-ev-x">' + esc(x.label) + "</th>"; }).join("") +
'<th class="perf-th-label">주문일</th>' +
'<th class="perf-th-label">결제일</th><th class="perf-th-label">상태</th></tr></thead><tbody>' + body +
'</tbody><tfoot><tr class="perf-row-total"><th class="perf-td-label" colspan="5">결제 ' + fmt(sales) +
" / 취소·반품 " + fmt(minus) + '</th><td class="perf-num">' + fmt(sum) + '</td><td colspan="3"></td></tr></tfoot></table></div>' +
" / 취소·반품 " + fmt(minus) + '</th><td class="perf-num">' + fmt(sum) + "</td>" +
EXTRA.map(function (x, k) {
const s = xsum[k];
return '<td class="perf-num perf-ev-x"><b>' + fmt(s.plus || s.minus ? (s.plus || s.minus) : 0) + "</b>" +
(s.plus && s.minus ? '<div class="perf-ev-xsub">환불 ' + fmt(s.minus) + "</div>" : "") + "</td>";
}).join("") +
'<td colspan="3"></td></tr>' +
(code === "naver" ? '<tr class="perf-row-total perf-ev-grand"><th class="perf-td-label" colspan="' + (8 + EXTRA.length + 1) + '">' +
"그날 매출 = 판매금액 " + fmt(sales) + " + 배송비 " + fmt(xsum[0].plus) + " − 환불 " + fmt(xsum[1].plus) + " = <b>" + fmt(total) + "</b>원</th></tr>" : "") +
"</tfoot></table></div>" +
(res.truncated ? '<p class="perf-muted">처음 500건만 표시합니다.</p>' : "") +
'<p class="perf-muted">수수료는 일·쇼핑몰 단위로 계산되어 주문별로는 표시하지 않습니다.</p>';
'<p class="perf-muted">수수료는 일·쇼핑몰 단위로 계산되어 주문별로는 표시하지 않습니다.' +
(code === "cafe24" ? " 금액은 적립금 사용분을 뺀 값입니다(환불도 적립금으로 돌려준 금액은 뺌)." : "") +
(code === "naver" ? " 판매금액은 배송비를 뺀 상품 결제금액입니다. 그날 매출 = 판매금액 + 배송비 − 환불(환불된 날)." : "") +
" 적립금·배송비 칸이 비어 있으면 규칙을 바꾸기 전에 받은 자료입니다 — 실적 설정 → 과거 매출 가져오기로 그 기간을 다시 받으세요.</p>";
} catch (err) {
m.body.innerHTML = '<p class="perf-notice is-warn">' + esc(err.message) + "</p>";
}
@@ -707,15 +790,73 @@
box.innerHTML = svg(W, H, g);
}
let saved = null;
try { saved = localStorage.getItem(KEY); } catch (_) {}
setMetric(saved || root.dataset.metric || "gross");
// 매출 실적 화면은 늘 수수료 차감 매출로 연다(2026-10-19) — 서버 기본 data-metric="net", 예전에 고른 보기(localStorage)는 쓰지 않음
setMetric(root.dataset.metric || "net");
initNextUpdate(data.auto_sync);
}
// 다음 자동 업데이트까지 남은 시간 — 초 단위 실시간(2026-10-19). 서버가 준 다음 회차·지금 시각(PC 시계 차이 보정)으로 세고,
// 회차가 지나면 1분 동안 "자동 업데이트 중" 뒤 같은 규칙(auto_sync.next_slot: KST hours[0]시 정각 ~ hours[1]시 정각, slot 분마다)으로 다음 회차.
function initNextUpdate(cfg) {
const span = document.getElementById("perf-next-update");
if (!span || !cfg || !cfg.next_at) return;
span.innerHTML = '<span class="perf-next-label">다음 업데이트까지 </span><b></b>';
const label = span.firstChild, box = span.lastChild;
const KST = 9 * 3600000, step = (cfg.slot || 30) * 60000;
const first = cfg.hours ? cfg.hours[0] : 9, last = cfg.hours ? cfg.hours[1] : 19;
const skew = cfg.now ? Date.parse(cfg.now) - Date.now() : 0;
function now() { return Date.now() + skew; }
function nextSlot(after) {
let t = Math.floor((after + KST) / step) * step + step; // KST 벽시계(ms)
for (let i = 0; i < 48 * 2 + 2; i++) {
const d = new Date(t), h = d.getUTCHours(), m = d.getUTCMinutes();
if ((h >= first && h < last) || (h === last && m === 0)) return t - KST;
t += step;
}
return null;
}
function two(n) { return (n < 10 ? "0" : "") + n; }
function left(ms) {
const s = Math.max(0, Math.ceil(ms / 1000));
const h = Math.floor(s / 3600), m = Math.floor((s % 3600) / 60), sec = s % 60;
if (h) return h + "시간 " + two(m) + "분 " + two(sec) + "초";
if (m) return m + "분 " + two(sec) + "초";
return sec + "초";
}
let due = Date.parse(cfg.next_at);
function tick() {
const t = now();
if (t >= due) {
if (t - due < 60000) { label.hidden = true; box.textContent = "자동 업데이트 중"; return; }
due = nextSlot(t);
if (due == null) { span.hidden = true; return; }
}
label.hidden = false;
box.textContent = left(due - t);
}
tick();
setInterval(tick, 1000);
}
// ════════════════════════════════════════════════════
// 설정
// ════════════════════════════════════════════════════
function initSettings(root) {
// 보기 설정 — 매출 단위(원·천원·백만원)를 이 브라우저 쿠키에(1년). 매출 실적 화면을 다시 열면 적용
const UNIT_EX = { won: "2,475,300", thousand: "2,475", million: "2.5" };
root.querySelectorAll("#perf-view-opts [data-unit]").forEach(function (b) {
b.addEventListener("click", function () {
const u = b.dataset.unit;
document.cookie = "perf_unit=" + u + "; path=/performance; max-age=31536000; SameSite=Lax";
root.querySelectorAll("#perf-view-opts [data-unit]").forEach(function (x) {
x.classList.toggle("is-active", x === b);
x.setAttribute("aria-checked", x === b ? "true" : "false");
});
const ex = document.getElementById("perf-unit-example");
if (ex) ex.textContent = "예: 2,475,300원 → " + UNIT_EX[u];
});
});
// 사용 / 매출 집계 토글 — 바로 저장, 실패하면 되돌림
root.querySelectorAll(".perf-switch input").forEach(function (box) {
box.addEventListener("change", async function () {
@@ -921,446 +1062,6 @@
} finally { btn.disabled = false; btn.textContent = label; }
}
// ── 카페24 매출 대조 — 카페24 "일별 매출내역" 열 순서대로 ──
let lastShop = {}; // 일별 비교에 붙여넣은 카페24 값(날짜 → 열) — 대조 표에 차이 열로 표시
const recon = document.getElementById("perf-recon");
if (recon) recon.addEventListener("click", async function () {
const day = document.getElementById("perf-recon-date").value;
const out = document.getElementById("perf-recon-result");
if (!day) return;
recon.disabled = true;
out.innerHTML = '<p class="perf-muted">카페24에서 불러오는 중…</p>';
try {
const r = await api("GET", "/performance/api/marketplaces/cafe24/reconcile?date=" + encodeURIComponent(day));
if (!r.ok) { out.innerHTML = '<p class="perf-notice is-warn">' + esc((r.label ? r.label + " — " : "") + r.message) + "</p>"; return; }
const s = r.orders.self, m = r.orders.market, rs = r.refunds.self, rm = r.refunds.market;
const dev = function (n, amt) { return n ? fmt(n) + '건 <span class="perf-muted">' + won(amt) + "</span>" : won(0); };
const MARKET_NAMES = {};
root.querySelectorAll("tr[data-code]").forEach(function (tr) { MARKET_NAMES[tr.dataset.code] = tr.dataset.name; });
const disc = ["membership_discount_amount", "set_product_discount_amount", "app_discount_amount",
"market_other_discount_amount", "shipping_fee_discount_amount"];
const coup = ["coupon_discount_price", "coupon_shipping_fee_amount"];
const LABEL = {
membership_discount_amount: "회원할인", set_product_discount_amount: "세트상품할인", app_discount_amount: "앱할인",
market_other_discount_amount: "마켓 기타할인", shipping_fee_discount_amount: "배송비할인",
coupon_discount_price: "상품쿠폰", coupon_shipping_fee_amount: "배송비쿠폰",
};
const sum = function (g, keys) { return keys.reduce(function (a, k) { return a + (g[k] || 0); }, 0); };
// x[4] = 붙여넣은 카페24 일별 매출내역 열 번호(일별 비교에서 이 날짜를 눌렀을 때 차이 표시)
const rows = [
["주문수", s.orders, m.orders, "cnt", 0], ["품목수(수량 합계)", s.items, m.items, "cnt", 1], ["품목수(품목 줄 수)", s.lines, m.lines, "cnt", 1],
["상품구매금액", s.order_price_amount, m.order_price_amount, "", 2],
["배송비", s.shipping_fee, m.shipping_fee, "", 3],
["할인 합계", sum(s, disc), sum(m, disc), "", 4],
].concat(disc.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; }))
.concat([["쿠폰 합계", sum(s, coup), sum(m, coup), "", 5]])
.concat(coup.map(function (k) { return [" · " + LABEL[k], s[k], m[k], "sub"]; }))
.concat([
[" 참고식: 상품구매금액 + 배송비 − 할인 − 쿠폰", s.goods_total, m.goods_total, "sub"],
["실결제금액", s.payment_amount, m.payment_amount, "", 6],
["적립금 사용", s.points_spent_amount, m.points_spent_amount, "", 7],
["예치금 사용", s.credits_spent_amount, m.credits_spent_amount, "", 8],
["네이버포인트", s.naver_point, m.naver_point, "", 9],
["결제합계(실결제 + 적립금 + 예치금 + 네이버포인트)", s.total, m.total, "key", 10],
["환불 건수(환불 목록)", rs.count, rm.count, "cnt"],
[" · 실제 환불액", rs.actual_refund_amount, rm.actual_refund_amount, "sub"],
[" · 적립금 환불", rs.used_points, rm.used_points, "sub"],
[" · 예치금 환불", rs.used_credits, rm.used_credits, "sub"],
["환불 목록 없는 네이버페이 취소·반품 품목 수", rs.no_record_count, rm.no_record_count, "cnt"],
[" · 취소·반품 금액", rs.no_record, rm.no_record, "sub"],
["환불합계", rs.total, rm.total, "key", 11],
["순매출(결제합계 − 환불합계)", s.total - rs.total, m.total - rm.total, "key", 12],
]);
const shopCols = (lastShop[r.date] || {}).cols || null;
out.innerHTML = '<table class="perf-table" style="margin-top:8px"><thead><tr><th class="perf-th-label">' + esc(r.date) +
"</th><th>카페24 열(자체몰 채널)</th><th>다른 쇼핑몰 열(외부 마켓)</th>" +
(shopCols ? "<th>합계</th><th>카페24 화면</th><th>차이</th>" : "") + "</tr></thead><tbody>" +
rows.map(function (x) {
const cls = x[3] === "key" ? ' class="perf-row-week"' : "";
const f = function (v) { return x[3] === "cnt" ? fmt(v) : won(v); };
let cmp = "";
if (shopCols) {
const both = (x[1] || 0) + (x[2] || 0), c = x[4] == null ? null : shopCols[x[4]];
cmp = '<td class="perf-num">' + f(both) + '</td><td class="perf-num">' + (c == null ? "" : f(c)) + '</td><td class="perf-num">' +
(c == null ? "" : both === c ? '<span class="perf-diff-ok">✓</span>' : '<span class="perf-diff-bad">' + (both > c ? "+" : "") + fmt(both - c) + "</span>") + "</td>";
}
return "<tr" + cls + '><th class="perf-td-label' + (x[3] === "sub" ? " perf-muted" : "") + '">' + esc(x[0]) +
'</th><td class="perf-num">' + f(x[1]) + '</td><td class="perf-num">' + f(x[2]) + "</td>" + cmp + "</tr>";
}).join("") + "</tbody></table>" +
(r.refund_basis
? (function () {
const b = r.refund_basis;
const row = function (label, x, cls) {
return "<tr" + (cls ? ' class="' + cls + '"' : "") + '><th class="perf-td-label">' + label + '</th><td class="perf-num">' +
fmt(x.count) + '</td><td class="perf-num">' + won(x.actual_refund_amount) + '</td><td class="perf-num">' +
won(x.used_points + x.used_credits) + '</td><td class="perf-num">' + won(x.with_points) + "</td></tr>";
};
return '<h4 class="perf-h" style="margin:14px 0 6px">환불 기준 비교 — 카페24 화면의 그날 "환불합계"와 같은 칸을 찾아 주세요</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">기준</th><th>건수</th><th>실제 환불액</th>' +
"<th>적립금·예치금 환불</th><th>합계(포함)</th></tr></thead><tbody>" +
row("환불완료일 기준 · 완료 <span class='perf-pill is-ok'>적용(합계 포함 칸)</span>", b.completed, "perf-row-week") +
row("환불접수일 기준 · 전체 상태", b.accepted_all) +
(b.by_pay_date ? row("결제일 기준 · 그날 결제한 주문의 환불(오늘까지" +
(b.by_pay_date.refund_dates.length ? ", 환불일 " + esc(b.by_pay_date.refund_dates.join(", ")) : "") + ")", b.by_pay_date) : "") +
(b.accepted_by_status || []).map(function (s) {
return row(" · 접수일 기준 " + esc(s.label), s);
}).join("") + "</tbody></table>";
})()
: "") +
((r.refund_candidates || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">환불합계 후보 — 카페24 화면 값을 넣으면 같은 줄을 표시합니다</h4>' +
'<div class="perf-row-inline" style="margin-bottom:6px"><input class="erp-input perf-date" type="text" inputmode="numeric" ' +
'id="perf-recon-target" placeholder="카페24 환불합계" /></div>' +
'<table class="perf-table" id="perf-recon-cands"><thead><tr><th class="perf-th-label">후보</th><th>금액</th><th>차이</th></tr></thead><tbody>' +
r.refund_candidates.map(function (c) {
return '<tr data-amount="' + c.amount + '"><td class="perf-td-label">' + esc(c.label) + '</td><td class="perf-num">' +
won(c.amount) + '</td><td class="perf-num perf-cand-diff">–</td></tr>';
}).join("") + "</tbody></table>"
: "") +
((r.refund_list || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">환불 건별 (환불 API)</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">환불코드</th><th class="perf-th-label">주문번호</th>' +
'<th class="perf-th-label">채널</th><th class="perf-th-label">상태</th><th class="perf-th-label">접수일</th><th class="perf-th-label">완료일</th>' +
"<th>수량</th><th>실제 환불액</th><th>적립금·예치금</th><th class=\"perf-th-label\">환불수단</th></tr></thead><tbody>" +
r.refund_list.map(function (x) {
const st = { T: "환불완료", F: "환불전", M: "환불보류" }[x.status] || x.status;
return '<tr><td class="perf-td-label">' + esc(x.refund_code) + "</td><td>" + esc(x.order_id) + "</td><td>" + esc(x.channel || "–") +
"</td><td>" + esc(st) + "</td><td>" + esc(x.accepted_date || "–") + "</td><td>" + esc(x.refund_date || "–") +
'</td><td class="perf-num">' + fmt(x.quantity) + '</td><td class="perf-num">' + won(x.actual_refund_amount) +
'</td><td class="perf-num">' + won(x.used_points + x.used_credits) + "</td><td>" + esc((x.methods || []).join(", ") || "–") + "</td></tr>";
}).join("") + "</tbody></table>"
: "") +
((r.no_record_claims || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">환불 목록에 없는 네이버페이 취소·반품 (환불합계에 넣은 건 — 주문 전체취소면 배송비 포함)</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">주문번호</th><th class="perf-th-label">품목</th>' +
'<th class="perf-th-label">채널</th><th class="perf-th-label">상태</th><th class="perf-th-label">반영일</th><th class="perf-th-label">상품</th>' +
"<th>수량</th><th>뺀 금액</th><th>품목 결제금액</th><th>쿠폰</th><th class=\"perf-th-label\">주문 전체취소</th><th>주문 배송비</th></tr></thead><tbody>" +
r.no_record_claims.map(function (c) {
return '<tr><td class="perf-td-label">' + esc(c.order_id) + "</td><td>" + esc(c.item_code) + "</td><td>" + esc(c.place_name || c.market_id || "–") +
"</td><td>" + esc(c.status + (c.naver_pay_claim_status ? " / 네이버페이 " + c.naver_pay_claim_status : "")) + "</td><td>" + esc(c.day) +
"</td><td>" + esc(c.product_name) + '</td><td class="perf-num">' + fmt(c.quantity) + '</td><td class="perf-num">' + won(c.amount) +
(c.shipping_refund ? ' <span class="perf-muted">(배송비 ' + fmt(c.shipping_refund) + ")</span>" : "") +
'</td><td class="perf-num">' + won(c.item_payment_amount) + '</td><td class="perf-num">' + won(c.coupon) + "</td><td>" +
(c.order_all_claimed ? "<b>예</b>" : "아니오") + '</td><td class="perf-num">' + won(c.order_shipping_fee) + "</td></tr>";
}).join("") + "</tbody></table>"
: "") +
((r.reduced_orders || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">그날 결제한 주문 중 금액이 줄어든 주문 (취소·반품) — "환불 기록 없음"이 환불 API 에 안 잡힌 건</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">주문번호</th><th class="perf-th-label">채널</th>' +
'<th class="perf-th-label">결제수단</th><th class="perf-th-label">품목 상태</th><th class="perf-th-label">취소·환불일</th>' +
"<th>결제 당시</th><th>현재</th><th>줄어든 금액</th><th>환불 기록</th></tr></thead><tbody>" +
r.reduced_orders.map(function (x) {
const miss = x.diff - x.refunded;
return "<tr" + (miss > 0 ? ' class="perf-row-match"' : "") + '><td class="perf-td-label">' + esc(x.order_id) + "</td><td>" +
esc(x.channel || "–") + "</td><td>" + esc(x.payment || "–") + "</td><td>" +
esc(x.statuses.join(", ") + (x.naver_pay.length ? " / 네이버페이 " + x.naver_pay.join(",") : "")) + "</td><td>" +
esc(x.claim_dates.join(", ") || "–") + '</td><td class="perf-num">' + won(x.initial) + '</td><td class="perf-num">' +
won(x.now) + '</td><td class="perf-num">' + won(x.diff) + '</td><td class="perf-num">' +
(x.refunded ? won(x.refunded) + ' <span class="perf-muted">' + esc(x.refund_dates.join(", ")) + "</span>" : "<b>없음</b>") + "</td></tr>";
}).join("") + "</tbody></table>"
: "") +
(r.claims
? '<h4 class="perf-h" style="margin:14px 0 6px">그날 취소·반품·교환 완료 품목 (주문 API)</h4>' +
((r.claims.errors || []).length ? '<p class="perf-notice is-warn">' + esc(r.claims.errors.join(" / ")) + "</p>" : "") +
((r.claims.items || []).length
? '<table class="perf-table"><thead><tr><th class="perf-th-label">조회</th><th class="perf-th-label">주문번호</th>' +
'<th class="perf-th-label">채널</th><th class="perf-th-label">상태</th><th class="perf-th-label">클레임</th><th class="perf-th-label">상품</th>' +
"<th>수량</th><th>판매가×수량</th><th>품목 결제금액</th><th>쿠폰</th><th class=\"perf-th-label\">환불 기록</th></tr></thead><tbody>" +
r.claims.items.map(function (c) {
return "<tr" + (c.done ? "" : ' class="perf-muted"') + '><td class="perf-td-label">' + esc(c.via) + "</td><td>" + esc(c.order_id) +
"</td><td>" + esc(c.channel || "–") + "</td><td>" + esc(c.status + (c.status_text ? " " + c.status_text : "")) +
"</td><td>" + esc(c.claim_code || "–") + "</td><td>" + esc(c.product_name) + '</td><td class="perf-num">' + fmt(c.quantity) +
'</td><td class="perf-num">' + won(c.product_amount) + '</td><td class="perf-num">' + won(c.payment_amount) +
'</td><td class="perf-num">' + won(c.coupon) + "</td><td>" + (c.has_refund ? "있음" : '<b>없음</b>') + "</td></tr>";
}).join("") + "</tbody></table>" +
'<p class="perf-foot perf-muted">전체취소 주문 배송비 ' + won(r.claims.full_cancel_shipping) +
'. 흐린 줄은 아직 완료되지 않은 클레임(후보 합계에서 제외).</p>'
: '<p class="perf-muted">없음</p>')
: "") +
((r.by_channel || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">주문 채널별</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">market_id</th><th class="perf-th-label">주문경로</th>' +
'<th class="perf-th-label">구분</th><th class="perf-th-label">반영 열</th><th>주문수</th><th>결제합계</th>' +
"<th>PC 주문</th><th>모바일 주문</th><th>환불</th><th>순매출</th></tr></thead><tbody>" +
r.by_channel.map(function (b) {
const col = MARKET_NAMES[b.target] || b.target;
const kind = b.kind === "self" ? "자체몰 채널" + (b.label ? "(" + b.label + ")" : "")
: b.kind === "market" ? "외부 마켓" : '<span class="perf-err" style="display:inline">알 수 없는 채널</span>';
return '<tr><td class="perf-td-label">' + esc(b.market_id) + "</td><td>" + esc(b.place || "–") +
(b.place_id && b.place_id !== b.place ? ' <span class="perf-muted">' + esc(b.place_id) + "</span>" : "") +
"</td><td>" + (b.kind === "unknown" ? kind : esc(kind)) + "</td><td>" + esc(col) +
'</td><td class="perf-num">' + fmt(b.orders) + '</td><td class="perf-num">' + won(b.total) +
'</td><td class="perf-num">' + dev(b.pc_orders, b.pc_total) + '</td><td class="perf-num">' + dev(b.mobile_orders, b.mobile_total) +
'</td><td class="perf-num">' + won(-b.refund_amount) + '</td><td class="perf-num">' + won(b.total - b.refund_amount) + "</td></tr>";
}).join("") + "</tbody>" +
// 카페24 열(자체몰) 기기 합계
(function () {
const own = r.by_channel.filter(function (b) { return b.target === "cafe24"; });
const t = own.reduce(function (a, b) {
a.o += b.orders; a.t += b.total; a.po += b.pc_orders; a.pt += b.pc_total; a.mo += b.mobile_orders; a.mt += b.mobile_total;
a.ra += b.refund_amount; return a;
}, { o: 0, t: 0, po: 0, pt: 0, mo: 0, mt: 0, ra: 0 });
return '<tfoot><tr class="perf-row-week"><th class="perf-td-label" colspan="4">카페24 열(자체몰) 합계</th><td class="perf-num">' +
fmt(t.o) + '</td><td class="perf-num">' + won(t.t) + '</td><td class="perf-num">' + dev(t.po, t.pt) +
'</td><td class="perf-num">' + dev(t.mo, t.mt) + '</td><td class="perf-num">' + won(-t.ra) +
'</td><td class="perf-num">' + won(t.t - t.ra) + "</td></tr></tfoot>";
})() + "</table>" +
'<p class="perf-foot perf-muted">한 줄 = market_id × 주문경로. market_id "self"는 PC 전용이 아니라 자체몰 전체이며, 그 안에 PC쇼핑몰·모바일웹 경로가 섞여 있습니다. ' +
'PC/모바일 주문은 카페24가 주문마다 주는 모바일 주문 여부(order_from_mobile) 기준입니다.</p>'
: "") +
((r.by_payment || []).length
? '<h4 class="perf-h" style="margin:14px 0 6px">결제수단별 (카페24 열)</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">결제수단</th><th>주문수</th><th>결제합계</th><th>비중</th></tr></thead><tbody>' +
(function () {
const tot = r.by_payment.reduce(function (a, p) { return a + p.total; }, 0);
return r.by_payment.map(function (p) {
return '<tr><td class="perf-td-label">' + esc(p.method) + '</td><td class="perf-num">' + fmt(p.orders) +
'</td><td class="perf-num">' + won(p.total) + '</td><td class="perf-num">' +
(tot > 0 ? (p.total / tot * 100).toFixed(1) + "%" : "–") + "</td></tr>";
}).join("");
})() + "</tbody></table>"
: "") +
(r.diag
? (function () {
// 판매가 합계 − 카페24 상품구매금액 = 찾는 금액(예: 9/23 → 62). 같은 값인 필드를 강조.
const gap = shopCols ? (s.order_price_amount + m.order_price_amount) - shopCols[2] : null;
const PART = { initial: "주문 금액(결제 당시 initial_order_amount)", actual: "주문 금액(현재 actual_order_amount)",
item: "품목(items) 합계", order: "주문 최상위 필드" };
const cells = ["initial", "actual", "item", "order"].map(function (p) {
const f = r.diag[p] || {};
const keys = Object.keys(f).filter(function (k) { return f[k]; });
return '<div><h5 class="perf-h" style="margin:6px 0">' + esc(PART[p]) + "</h5>" +
(keys.length ? '<table class="perf-table"><tbody>' + keys.map(function (k) {
return "<tr" + (gap && f[k] === gap ? ' class="perf-row-match"' : "") + '><td class="perf-td-label">' + esc(k) +
'</td><td class="perf-num">' + fmt(f[k]) + "</td></tr>";
}).join("") + "</tbody></table>" : '<p class="perf-muted">0 아닌 값 없음</p>') + "</div>";
}).join("");
const odd = (r.odd_orders || []).map(function (o) {
return '<tr><td class="perf-td-label">' + esc(o.order_id) + "</td><td>" + esc(o.channel || "–") + '</td><td class="perf-num">' +
fmt(o.items_gross) + '</td><td class="perf-num">' + fmt(o.order_price_amount) + '</td><td class="perf-num">' + fmt(o.total) +
'</td><td style="white-space:normal;font-size:11.5px">' + o.items.map(function (i) {
return esc(i.code + " " + i.status + " ×" + i.quantity + " — " +
Object.keys(i.fields).map(function (k) { return k + "=" + fmt(i.fields[k]); }).join(", "));
}).join("<br>") + "</td></tr>";
}).join("");
return '<h4 class="perf-h" style="margin:14px 0 6px">원본 금액 필드 합계 (진단 — 그날 결제 주문 전체)' +
(gap ? ' · 판매가 합계 − 카페24 상품구매금액 = <b>' + fmt(gap) + "</b> (같은 값 강조)" : "") + "</h4>" +
'<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(240px,1fr));gap:10px">' + cells + "</div>" +
(odd ? '<h4 class="perf-h" style="margin:14px 0 6px">상품금액이 100원 단위가 아니거나 판매가×수량 합과 다른 주문</h4>' +
'<table class="perf-table"><thead><tr><th class="perf-th-label">주문번호</th><th class="perf-th-label">채널</th><th>판매가×수량</th>' +
'<th>주문 상품금액</th><th>결제합계(계산)</th><th class="perf-th-label">품목 금액 필드(0 제외)</th></tr></thead><tbody>' + odd + "</tbody></table>" : "");
})()
: "") +
'<p class="perf-foot perf-muted">' + esc(r.formula) + ". 미결제 주문 " + fmt(r.unpaid_orders) +
"건 제외. \"알 수 없는 채널\"은 카페24 열에 넣습니다 — 외부 마켓이면 어느 쇼핑몰인지 알려 주세요.</p>";
const target = document.getElementById("perf-recon-target");
if (target) target.addEventListener("input", function () {
const v = parseInt(target.value.replace(/[^0-9-]/g, ""), 10);
out.querySelectorAll("#perf-recon-cands tr[data-amount]").forEach(function (tr) {
const a = parseInt(tr.dataset.amount, 10);
const d = tr.querySelector(".perf-cand-diff");
if (isNaN(v)) { d.textContent = "–"; tr.classList.remove("perf-row-match"); return; }
d.textContent = a === v ? "일치" : fmt(a - v);
tr.classList.toggle("perf-row-match", a === v);
});
});
} catch (err) {
out.innerHTML = '<p class="perf-notice is-warn">' + esc(err.message) + "</p>";
} finally { recon.disabled = false; }
});
// ── 일별 한 번에 비교 — 카페24 일별 매출내역 붙여넣기 ↔ 저장값 ↔ 지금 API 값 ──
// 붙여넣은 한 줄: "2026-09-29(화) 주문수 품목수 … 결제합계 환불합계 순매출" — 뒤의 세 숫자와 첫 숫자(주문수)만 쓴다.
function parseDaily(text) {
const out = {};
String(text || "").split(/\r?\n/).forEach(function (line) {
const m = line.match(/(\d{4})[-./](\d{2})[-./](\d{2})/);
if (!m) return;
const nums = (line.slice(m.index + m[0].length).match(/-?\d[\d,]*/g) || [])
.map(function (x) { return parseInt(x.replace(/,/g, ""), 10); });
if (nums.length < 3) return;
const n = nums.length;
out[m[1] + "-" + m[2] + "-" + m[3]] = { orders: n >= 13 ? nums[0] : null, paid: nums[n - 3], refund: nums[n - 2], net: nums[n - 1],
cols: n >= 13 ? nums.slice(n - 13) : null };
});
return out;
}
const dailyBtn = document.getElementById("perf-daily-check");
if (dailyBtn) dailyBtn.addEventListener("click", async function () {
const out = document.getElementById("perf-daily-result");
const shop = lastShop = parseDaily(document.getElementById("perf-daily-paste").value);
const dates = Object.keys(shop).sort();
if (!dates.length) { out.innerHTML = '<p class="perf-notice is-warn">날짜가 있는 줄을 찾지 못했습니다. 카페24 일별 매출내역 표를 복사해 붙여 넣으세요.</p>'; return; }
const live = document.getElementById("perf-daily-live").checked;
dailyBtn.disabled = true;
out.innerHTML = '<p class="perf-muted">' + (live ? "저장값과 카페24 API 값을 계산하는 중… (기간이 길면 1~2분)" : "저장값을 불러오는 중…") + "</p>";
try {
const from = dates[0], to = dates[dates.length - 1];
const r = await api("GET", "/performance/api/marketplaces/cafe24/daily-check?from=" + from + "&to=" + to + (live ? "&live=1" : ""));
if (!r.ok) { out.innerHTML = '<p class="perf-notice is-warn">' + esc(r.message) + "</p>"; return; }
const byDate = function (rows) { const o = {}; (rows || []).forEach(function (x) { o[x.date] = x; }); return o; };
const db = byDate(r.db), lv = r.live ? byDate(r.live) : null;
const zero = { paid: 0, refund: 0, orders: 0 };
const diff = function (ours, theirs) {
const d = ours - theirs;
return d === 0 ? '<span class="perf-diff-ok">✓</span>' : '<span class="perf-diff-bad">' + (d > 0 ? "+" : "") + fmt(d) + "</span>";
};
const todayIso = today();
let bad = 0, stale = 0, rule = 0;
const sum = { cp: 0, cr: 0, dp: 0, dr: 0, lp: 0, lr: 0 };
const body = dates.slice().reverse().map(function (d) {
const c = shop[d], x = db[d] || zero, l = lv ? (lv[d] || zero) : null;
sum.cp += c.paid; sum.cr += c.refund; sum.dp += x.paid; sum.dr += x.refund;
if (l) { sum.lp += l.paid; sum.lr += l.refund; }
const dbOk = x.paid === c.paid && x.refund === c.refund;
const liveOk = l && l.paid === c.paid && l.refund === c.refund;
let verdict;
if (dbOk) verdict = '<span class="perf-pill is-ok">일치</span>';
else if (l && liveOk) { verdict = '<span class="perf-pill">다시 가져오면 해결</span>'; stale++; }
else if (l) {
const what = [l.paid !== c.paid ? "결제" : "", l.refund !== c.refund ? "환불" : ""].filter(Boolean).join("·");
verdict = '<span class="perf-pill is-bad">규칙 차이(' + what + ")</span>"; rule++;
} else verdict = '<span class="perf-pill is-bad">차이</span>';
if (!dbOk) bad++;
const wd = "일월화수목금토"[new Date(d + "T00:00:00").getDay()];
return "<tr" + (dbOk ? "" : ' class="perf-row-diff"') + '><td class="perf-td-label"><button type="button" class="perf-link" data-recon-day="' + d + '">' +
esc(d) + "(" + wd + ")</button>" + (d === todayIso ? ' <span class="perf-muted">오늘·집계 중</span>' : "") + "</td>" +
'<td class="perf-num">' + (c.orders == null ? "–" : fmt(c.orders)) + ' <span class="perf-muted">/ ' + fmt(x.orders) + (l ? " / " + fmt(l.orders) : "") + "</span></td>" +
'<td class="perf-num">' + won(c.paid) + '</td><td class="perf-num">' + diff(x.paid, c.paid) + "</td>" + (l ? '<td class="perf-num">' + diff(l.paid, c.paid) + "</td>" : "") +
'<td class="perf-num">' + won(c.refund) + '</td><td class="perf-num">' + diff(x.refund, c.refund) + "</td>" + (l ? '<td class="perf-num">' + diff(l.refund, c.refund) + "</td>" : "") +
"<td>" + verdict + (x.synced_at ? '<div class="perf-muted" style="font-size:11px">저장 ' + esc(String(x.synced_at).slice(5, 16).replace("T", " ")) + "</div>" : "") + "</td></tr>";
}).join("");
const head = '<tr><th class="perf-th-label">날짜</th><th>주문수 <span class="perf-muted">카페24 / 저장' + (lv ? " / API" : "") + "</span></th>" +
"<th>결제합계(카페24)</th><th>저장값 차이</th>" + (lv ? "<th>API 차이</th>" : "") +
"<th>환불합계(카페24)</th><th>저장값 차이</th>" + (lv ? "<th>API 차이</th>" : "") + '<th class="perf-th-label">판정</th></tr>';
const foot = '<tr class="perf-row-week"><th class="perf-td-label">합계</th><td></td><td class="perf-num">' + won(sum.cp) + '</td><td class="perf-num">' +
diff(sum.dp, sum.cp) + "</td>" + (lv ? '<td class="perf-num">' + diff(sum.lp, sum.cp) + "</td>" : "") + '<td class="perf-num">' + won(sum.cr) +
'</td><td class="perf-num">' + diff(sum.dr, sum.cr) + "</td>" + (lv ? '<td class="perf-num">' + diff(sum.lr, sum.cr) + "</td>" : "") + "<td></td></tr>";
const summary = bad
? "저장값이 다른 날 " + bad + "일" + (lv ? " — 다시 가져오면 해결 " + stale + "일, 규칙 차이 " + rule + "일" : " — [API 값도 계산]을 켜고 다시 비교하면 원인을 나눠 볼 수 있습니다")
: "모든 날짜가 일치합니다.";
out.innerHTML = '<p class="perf-notice ' + (bad ? "is-warn" : "is-ok") + '" style="margin-top:8px">' + esc(summary) +
(r.live_error ? "<br>API 계산 실패: " + esc(r.live_error) : "") + "</p>" +
(stale ? '<div class="perf-sample-form"><button type="button" class="erp-btn erp-btn-primary" id="perf-daily-resync" data-from="' + from +
'" data-to="' + to + '">' + esc(from + " ~ " + to) + " 카페24 다시 가져오기</button></div>" : "") +
'<table class="perf-table" style="margin-top:8px"><thead>' + head + "</thead><tbody>" + body + "</tbody><tfoot>" + foot + "</tfoot></table>" +
'<p class="perf-foot perf-muted">차이 = 우리 값 − 카페24 값. 저장값은 카페24 수집분 전체(카페24 화면과 같은 범위)입니다.</p>';
} catch (err) {
out.innerHTML = '<p class="perf-notice is-warn">' + esc(err.message) + "</p>";
} finally { dailyBtn.disabled = false; }
});
const dailyOut = document.getElementById("perf-daily-result");
if (dailyOut) dailyOut.addEventListener("click", async function (e) {
const dayBtn = e.target.closest("[data-recon-day]");
if (dayBtn && recon) {
document.getElementById("perf-recon-date").value = dayBtn.dataset.reconDay;
recon.click();
recon.scrollIntoView({ behavior: "smooth", block: "center" });
return;
}
const rs = e.target.closest("#perf-daily-resync");
if (!rs) return;
if (!(await confirmMsg(rs.dataset.from + " ~ " + rs.dataset.to + " 카페24 매출을 지금 규칙으로 다시 가져옵니다."))) return;
rs.disabled = true;
rs.textContent = "가져오는 중…";
try {
const res = await api("POST", "/performance/api/sync", { from: rs.dataset.from, to: rs.dataset.to, codes: ["cafe24"] });
const r0 = (res.results || [])[0];
if (r0 && !r0.ok) throw new Error((r0.label || r0.status) + ": " + (r0.message || ""));
dailyBtn.click();
} catch (err) {
alertMsg("다시 가져오기 실패: " + err.message);
rs.disabled = false;
}
});
// ── 쇼핑몰 원본 데이터 확인(네이버·11번가·GS샵·토스쇼핑·쿠팡) — 조회 주소별 동작 여부·항목 합계, 네이버는 날짜별 현재 규칙 매출 ──
const probe = document.getElementById("perf-probe");
if (probe) probe.addEventListener("click", async function () {
const day = document.getElementById("perf-probe-date").value;
const out = document.getElementById("perf-probe-result");
if (!day) return;
probe.disabled = true;
const codeSel = document.getElementById("perf-probe-code");
const code = codeSel ? codeSel.value : "elevenst";
const loading = { naver: "네이버에서 불러오는 중… (하루씩, 기간이 길면 수십 초)",
gsshop: "GS샵에서 불러오는 중… (10일 단위)", toss: "토스쇼핑에서 불러오는 중… (31일 단위)",
coupang: "쿠팡에서 불러오는 중… (판매자배송 상태 6개 + 로켓그로스, 수십 초)" }[code] || "11번가에서 불러오는 중… (주소 10개 × 7일 단위, 기간이 길면 1분 이상)";
out.innerHTML = '<p class="perf-muted">' + loading + "</p>";
try {
const to = document.getElementById("perf-probe-to").value || day;
const r = await api("GET", "/performance/api/marketplaces/" + code + "/reconcile?date=" + encodeURIComponent(day) +
"&to=" + encodeURIComponent(to));
if (!r.ok) { out.innerHTML = '<p class="perf-notice is-warn">' + esc((r.label ? r.label + " — " : "") + r.message) + "</p>"; return; }
// 원본 확인은 최대 31일 — 더 긴 기간을 넣으면 서버가 앞 31일만 본다. 실제 조회 기간을 꼭 보여 준다.
const shown = r.date ? (r.date === r.to ? r.date : r.date + " ~ " + r.to) : "";
const cut = r.to && r.to < to;
const range = shown ? '<p class="perf-notice' + (cut ? " is-warn" : "") + '" style="margin-top:8px">조회 기간 <b>' + esc(shown) + "</b>" +
(cut ? " — 원본 데이터 확인은 한 번에 31일까지라 " + esc(r.to) + " 뒤(~" + esc(to) + ")는 조회하지 않았습니다. " +
"1년치 매출은 위 [과거 매출 가져오기]로 받으세요(31일씩 나눠 불러 저장)." : "") + "</p>" : "";
const summary = range + '<table class="perf-table" style="margin-top:8px"><thead><tr><th class="perf-th-label">조회</th>' +
'<th class="perf-th-label">주소</th><th class="perf-th-label">결과</th><th>건수</th></tr></thead><tbody>' +
r.probes.map(function (p) {
return '<tr><td class="perf-td-label">' + esc(p.label) + '</td><td class="perf-muted">' + esc(p.path) + "</td><td>" +
(p.ok ? '<span class="perf-pill is-ok">동작</span>' : '<span class="perf-pill is-bad">실패</span> <span class="perf-muted" style="white-space:normal">' + esc(p.error) + "</span>") +
'</td><td class="perf-num">' + (p.ok ? fmt(p.count) : "") + "</td></tr>";
}).join("") + "</tbody></table>";
const details = r.probes.filter(function (p) { return p.ok && p.count; }).map(function (p) {
return '<h4 class="perf-h" style="margin:14px 0 6px">' + esc(p.label) + " — " + fmt(p.count) + "줄</h4>" +
'<table class="perf-table"><thead><tr><th class="perf-th-label">항목</th><th>채워진 줄</th><th>숫자 합계</th>' +
'<th class="perf-th-label">예시 값</th></tr></thead><tbody>' +
p.fields.map(function (f) {
return '<tr><td class="perf-td-label">' + esc(f.name) + '</td><td class="perf-num">' + fmt(f.filled) + '</td><td class="perf-num">' +
(f.sum == null ? "" : fmt(f.sum)) + "</td><td>" + (f.personal ? '<span class="perf-muted">개인정보(숨김)</span>' : esc(f.sample)) + "</td></tr>";
}).join("") + "</tbody></table>";
}).join("");
// 날짜별 현재 규칙 매출(네이버·토스쇼핑) — 쇼핑몰 관리자 화면 매출과 나란히 비교
const days = (r.days || []).length ? '<h4 class="perf-h" style="margin:14px 0 6px">날짜별 현재 규칙 매출</h4>' +
(r.rule ? '<p class="perf-muted">규칙: ' + esc(r.rule) + "</p>" : "") +
'<table class="perf-table"><thead><tr><th class="perf-th-label">날짜</th><th>주문 수</th><th>' +
esc((r.day_cols || {}).amount || "매출") + "</th>" +
"<th>" + esc((r.day_cols || {}).claimed || "그중 결제 뒤 취소·반품(참고)") + "</th><th>" +
esc((r.day_cols || {}).ship || "배송비(참고, 매출 제외)") + "</th></tr></thead><tbody>" +
r.days.map(function (d) {
return '<tr><td class="perf-td-label">' + esc(d.date) + '</td><td class="perf-num">' + fmt(d.orders) +
'</td><td class="perf-num">' + fmt(d.amount) + '</td><td class="perf-num">' + fmt(d.claimed || 0) +
'</td><td class="perf-num">' + fmt(d.ship || 0) + "</td></tr>";
}).join("") + '<tr><td class="perf-td-label"><b>합계</b></td>' +
["orders", "amount", "claimed", "ship"].map(function (k) {
return '<td class="perf-num"><b>' + fmt(r.days.reduce(function (a, d) { return a + (d[k] || 0); }, 0)) + "</b></td>";
}).join("") + "</tr></tbody></table>" : "";
// 환불 출처별(토스쇼핑) — 출처별 날짜 합계를 나란히, 아래에 건별 목록(주문번호·금액·메모)
const rc = r.refund_candidates || [];
const candDays = (r.days || []).map(function (d) { return d.date; });
const cands = rc.length ? '<h4 class="perf-h" style="margin:14px 0 6px">' + esc(r.candidates_title || "환불 출처별 비교 — 첫 열(적용 규칙)이 저장되는 환불") + "</h4>" +
'<table class="perf-table"><thead><tr><th class="perf-th-label">날짜</th>' +
rc.map(function (c) { return "<th>" + esc(c.label) + "</th>"; }).join("") + "</tr></thead><tbody>" +
candDays.map(function (dt) {
return '<tr><td class="perf-td-label">' + esc(dt) + "</td>" + rc.map(function (c) {
return '<td class="perf-num">' + (c.error ? "" : fmt((c.days || {})[dt] || 0)) + "</td>";
}).join("") + "</tr>";
}).join("") + '<tr><td class="perf-td-label"><b>합계</b></td>' + rc.map(function (c) {
if (c.error) return '<td><span class="perf-pill is-bad">실패</span> <span class="perf-muted" style="white-space:normal">' + esc(c.error) + "</span></td>";
const t = Object.keys(c.days || {}).reduce(function (a, k) { return a + c.days[k]; }, 0);
return '<td class="perf-num"><b>' + fmt(t) + "</b></td>";
}).join("") + "</tr></tbody></table>" +
rc.filter(function (c) { return !c.error && (c.rows || []).length; }).map(function (c) {
return '<p class="perf-muted" style="margin:10px 0 4px">' + esc(c.label) + " — " + fmt(c.rows.length) + "건</p>" +
'<table class="perf-table"><thead><tr><th class="perf-th-label">환불일</th><th class="perf-th-label">주문일</th>' +
'<th class="perf-th-label">주문번호</th>' +
'<th class="perf-th-label">주문상품</th><th>금액</th><th class="perf-th-label">메모</th></tr></thead><tbody>' +
c.rows.map(function (x) {
return '<tr><td class="perf-td-label">' + esc(x.date) + "</td><td>" + esc(x.orderDate || "") + "</td><td>" +
esc(x.orderId) + "</td><td>" + esc(x.orderProductId) +
'</td><td class="perf-num">' + fmt(x.amount) + '</td><td class="perf-muted">' + esc(x.note) + "</td></tr>";
}).join("") + "</tbody></table>";
}).join("") : "";
out.innerHTML = summary + days + cands + (details ||'<p class="perf-muted" style="margin-top:8px">그 기간에 조회된 주문이 없습니다. 쇼핑몰 관리자 화면에서 매출이 있던 날로 다시 해 보세요.</p>');
} catch (err) {
out.innerHTML = '<p class="perf-notice is-warn">' + esc(err.message) + "</p>";
} finally { probe.disabled = false; }
});
// ── 과거 매출 가져오기(기간 지정 수집, 관리자) ──
const backfill = document.getElementById("perf-backfill");
if (backfill) backfill.addEventListener("click", async function () {
+111 -13
View File
@@ -5,36 +5,134 @@
button.dataset.bound = "1";
const names = { system: null, pretendard: "Pretendard Variable", "nanum-square": "NanumSquare",
"nanum-square-neo": "NanumSquareNeo", "nanum-square-round": "NanumSquareRound" };
const VIEWS = ["board", "list", "calendar", "timeline", "dashboard"];
const FONT_DEFAULT = "system";
const SYS_DEFAULTS = { default_view: "board", board_cover: true }; // 서버 store.PROJECT_OPTION_DEFAULTS 와 같게
const form = document.getElementById("pj-options-form");
const select = document.getElementById("pj-options-font"), preview = document.getElementById("pj-options-preview");
const error = document.getElementById("pj-options-error"), save = document.getElementById("pj-options-save");
const cancel = document.getElementById("pj-options-cancel");
function current() { const v = document.documentElement.dataset.pjFont; return Object.hasOwn(names, v) ? v : "system"; }
const cancel = document.getElementById("pj-options-cancel"), closeX = document.getElementById("pj-options-x");
const reset = document.getElementById("pj-options-reset");
const tabs = Array.from(dialog.querySelectorAll(".pj-options-nav [role=tab]"));
const panes = Array.from(dialog.querySelectorAll(".pj-options-pane"));
// 처음 여는 탭·카드 표지 = 시스템 전체 설정(서버, 모든 사용자) — 수퍼관리자·Admin 창에만 있다(_options.html).
// 없으면 폰트(이 브라우저)만 다룬다.
const cover = document.getElementById("pj-options-cover");
const views = form.elements.default_view || null;
const sysControls = [cover].concat(Array.from(views || [])).filter(Boolean);
const localControls = [select, cancel, closeX, reset];
let sys = null; // 서버에서 읽은 시스템 옵션 — 못 읽었으면 null(그때는 폰트만 저장)
let openSeq = 0; // 창을 다시 열면 앞의 늦은 응답은 버린다
function setError(msg) { error.textContent = msg || ""; error.hidden = !msg; }
async function request(method, body) {
const opts = { method: method, headers: { "Content-Type": "application/json" } };
if (body !== undefined) opts.body = JSON.stringify(body);
const res = await fetch("/project/api/options", opts);
let data = null;
try { data = await res.json(); } catch (_) {}
if (!res.ok) throw new Error((data && typeof data.detail === "string" && data.detail) || res.statusText || "오류");
return data || {};
}
function currentFont() { const f = document.documentElement.dataset.pjFont; return Object.hasOwn(names, f) ? f : FONT_DEFAULT; }
function fillSys(o) {
if (views) views.value = o.default_view;
if (cover) cover.checked = o.board_cover;
}
function paint() {
const font = names[select.value];
preview.style.fontFamily = font ? '"' + font + '", sans-serif' : "var(--pj-system-font)";
}
function showPane(name, focus) {
tabs.forEach(function (t) {
const on = t.dataset.pane === name;
t.classList.toggle("is-active", on);
t.setAttribute("aria-selected", on ? "true" : "false");
t.tabIndex = on ? 0 : -1;
if (on && focus) t.focus();
});
panes.forEach(function (p) { p.hidden = p.dataset.pane !== name; });
}
function busy(on) {
save.disabled = on;
localControls.forEach(function (c) { c.disabled = on; });
sysControls.forEach(function (c) { c.disabled = on || !sys; });
}
function close() { if (!save.disabled) dialog.close(); }
async function loadSys() {
if (!sysControls.length) return;
const seq = ++openSeq;
sys = null; busy(false); // 읽는 동안 시스템 칸은 잠금
try {
const data = await request("GET");
if (seq !== openSeq) return;
sys = { default_view: data.options.default_view, board_cover: !!data.options.board_cover };
fillSys(sys);
} catch (err) {
if (seq !== openSeq) return;
setError("모든 사용자 설정을 불러오지 못했습니다(" + err.message + "). 폰트만 저장됩니다.");
}
if (!save.disabled) busy(false);
}
button.addEventListener("click", function () {
select.value = current(); error.hidden = true; paint(); dialog.showModal(); select.focus();
select.value = currentFont(); fillSys(SYS_DEFAULTS); paint(); setError("");
showPane(tabs[0].dataset.pane); dialog.showModal(); tabs[0].focus();
loadSys();
});
dialog.querySelector(".pj-options-nav").addEventListener("click", function (e) {
const t = e.target.closest("[role=tab]");
if (t) showPane(t.dataset.pane);
});
// 분류 목록 — 위/아래 화살표로 이동(데스크톱 프로그램 설정 창처럼)
dialog.querySelector(".pj-options-nav").addEventListener("keydown", function (e) {
const i = tabs.indexOf(document.activeElement);
if (i < 0 || (e.key !== "ArrowDown" && e.key !== "ArrowUp")) return;
e.preventDefault();
showPane(tabs[(i + (e.key === "ArrowDown" ? 1 : tabs.length - 1)) % tabs.length].dataset.pane, true);
});
select.addEventListener("change", paint);
cancel.addEventListener("click", function () { if (!save.disabled) dialog.close(); });
reset.addEventListener("click", function () {
select.value = FONT_DEFAULT; paint();
if (sys) fillSys(SYS_DEFAULTS);
});
cancel.addEventListener("click", close);
closeX.addEventListener("click", close);
dialog.addEventListener("cancel", function (e) { if (save.disabled) e.preventDefault(); });
dialog.addEventListener("close", function () { button.focus(); });
document.getElementById("pj-options-form").addEventListener("submit", async function (e) {
dialog.addEventListener("close", function () { openSeq++; button.focus(); });
form.addEventListener("submit", async function (e) {
e.preventDefault(); if (save.disabled) return;
const value = select.value, font = names[value];
if (!Object.hasOwn(names, value)) return;
save.disabled = select.disabled = cancel.disabled = true; error.hidden = true;
const fontValue = select.value, font = names[fontValue];
if (!Object.hasOwn(names, fontValue)) return;
// 시스템 옵션은 바뀐 키만 보낸다(그대로면 서버에 쓰지 않음)
const sysChanges = {};
if (sys) {
if (views && VIEWS.indexOf(views.value) >= 0 && views.value !== sys.default_view) sysChanges.default_view = views.value;
if (cover && cover.checked !== sys.board_cover) sysChanges.board_cover = cover.checked;
}
busy(true); setError("");
try {
if (font && document.fonts) {
const loaded = await Promise.all([document.fonts.load('400 14px "' + font + '"', "가나다 Project"), document.fonts.load('700 14px "' + font + '"', "가나다 Project")]);
if (loaded.some(function (list) { return !list.length; })) throw new Error("폰트를 불러오지 못했습니다. 다시 시도해 주세요.");
}
localStorage.setItem("pj_font", value);
document.documentElement.dataset.pjFont = value;
const changed = Object.keys(sysChanges);
if (changed.length) {
const data = await request("PUT", sysChanges);
sys = { default_view: data.options.default_view, board_cover: !!data.options.board_cover };
}
if (fontValue !== currentFont()) changed.push("font");
localStorage.setItem("pj_font", fontValue);
document.documentElement.dataset.pjFont = fontValue;
// project.js 가 듣는다 — 보드 표지가 바뀌면 보던 보드를 다시 그린다(다른 사용자는 다음에 화면을 열 때부터).
if (changed.length) {
window.dispatchEvent(new CustomEvent("pj-options-change", {
detail: { options: Object.assign({ font: fontValue }, sys || {}), changed: changed },
}));
}
window.dispatchEvent(new Event("resize"));
dialog.close();
} catch (err) { error.textContent = "설정을 저장하지 못했습니다. " + err.message; error.hidden = false; }
finally { save.disabled = select.disabled = cancel.disabled = false; }
} catch (err) { setError("설정을 저장하지 못했습니다. " + err.message); }
finally { busy(false); }
});
})();
+144 -11
View File
@@ -424,6 +424,21 @@ html.pj-side-resizing, html.pj-side-resizing * { cursor: col-resize !important;
}
.pj-card:hover { box-shadow: var(--pj-card-shadow-hover); transform: translateY(-1px); }
.pj-card.is-dragging { opacity: .5; }
/* 카드 끌기 실시간 미리보기(2026-10-19) — 원래 카드는 숨기고 놓일 자리에 점선 자리 표시,
끄는 모양은 살짝 기울어진 그림자 카드(setDragImage 용, 화면 밖에 잠깐 붙였다 뗀다). */
.pj-card.is-drag-src { display: none; }
/* 카드 속 이미지(아바타·표지)를 잡고 끌어도 이미지가 아니라 카드가 끌리게 — 이미지 끌기는 "Files" 를 실어 카드 놓기가 거부됐다 */
.pj-card img { -webkit-user-drag: none; user-drag: none; }
.pj-card-ph {
flex: none; box-sizing: border-box; border-radius: var(--pj-card-radius);
border: 2px dashed var(--pj-accent); background: var(--pj-accent-tint);
animation: pj-card-ph-in .16s ease-out;
}
@keyframes pj-card-ph-in { from { opacity: 0; } to { opacity: 1; } }
.pj-card-ghost { position: fixed; left: -10000px; top: 0; padding: 14px; pointer-events: none; }
.pj-card-ghost > .pj-card {
transform: rotate(2.5deg); box-shadow: 0 12px 28px rgba(0, 0, 0, .22); border-color: #c9c9cc;
}
.pj-card.pj-tasknew {
flex: none; min-height: 106px; box-sizing: border-box; border-color: #8b8c8d; cursor: default;
}
@@ -453,6 +468,40 @@ html.pj-side-resizing, html.pj-side-resizing * { cursor: col-resize !important;
.pj-card-sub.pj-sub-drop-before { box-shadow: inset 0 2px var(--pj-accent); }
.pj-card-sub.pj-sub-drop-after { box-shadow: inset 0 -2px var(--pj-accent); }
.pj-card.is-sub-drop { outline: 2px solid var(--pj-accent); outline-offset: -2px; background: var(--pj-accent-tint); }
/* 파일을 카드에 끌어 놓기 = 이 업무에 첨부(2026-10-19) — 점선 + "놓으면 첨부" 안내, 올리는 동안 흐리게 */
.pj-card.is-file-drop { position: relative; outline: 2px dashed var(--pj-accent); outline-offset: -2px; background: var(--pj-accent-tint); }
.pj-card.is-file-drop::after {
content: "놓으면 드라이브에 올리고 설명에 링크"; position: absolute; right: 8px; bottom: 6px; padding: 2px 8px; border-radius: 999px;
background: var(--pj-accent); color: #fff; font-size: 11px; font-weight: 700; pointer-events: none;
}
.pj-card.is-file-drop.is-file-drop-sub::after { content: "놓으면 이 세부 업무 설명에 드라이브 링크"; }
/* 파일 → 구글 드라이브(2026-10-19) — 놓을 곳(설명란·세부 업무 줄) 점선 안내, 올리는 중 표시 */
.pj-card-sub.is-drive-over,
.pj-subtask-row.is-drive-over { outline: 2px dashed var(--pj-accent); outline-offset: -2px; background: var(--pj-accent-tint); border-radius: 6px; }
.pj-subtask-list.is-drive-over { outline: 2px dashed var(--pj-accent); outline-offset: 2px; border-radius: 8px; }
.pj-desc-wrap.is-drive-over { position: relative; outline: 2px dashed var(--pj-accent); outline-offset: 2px; border-radius: 8px; }
.pj-desc-wrap.is-drive-over::after {
content: "놓으면 구글 드라이브에 올리고 이 자리에 링크"; position: absolute; right: 8px; top: 6px; z-index: 5; padding: 2px 8px;
border-radius: 999px; background: var(--pj-accent); color: #fff; font-size: 11px; font-weight: 700; pointer-events: none;
}
.pj-card-sub.is-file-uploading,
.pj-subtask-row.is-file-uploading { animation: pj-file-up 1s ease-in-out infinite alternate; }
.pj-drive-uploading {
display: inline-block; margin: 0 2px; padding: 0 8px; border-radius: 999px; background: var(--pj-accent-tint);
color: var(--pj-accent); font-size: 12px; font-weight: 600; user-select: none;
animation: pj-file-up 1s ease-in-out infinite alternate;
}
.pj-card.is-file-uploading { opacity: .6; animation: pj-file-up 1s ease-in-out infinite alternate; }
@keyframes pj-file-up { from { opacity: .45; } to { opacity: .8; } }
/* 업무 창 아무 곳에 파일 끌어 놓기 — 창 전체 점선 안내(읽기 전용·저장 전 새 업무는 회색 안내) */
.pj-task-modal-card.is-file-over::after {
content: "여기에 놓으면 첨부 파일로 올라갑니다 (설명란·세부 업무에 놓으면 구글 드라이브 링크)"; position: absolute; inset: 8px; z-index: 60; pointer-events: none;
display: flex; align-items: center; justify-content: center; border: 3px dashed var(--pj-accent); border-radius: 12px;
background: rgba(241, 238, 255, .6); color: var(--pj-accent); font-size: 16px; font-weight: 700;
}
.pj-task-modal-card.is-file-over.is-file-blocked::after {
content: "이 업무에는 지금 첨부할 수 없습니다(저장 전·읽기 전용)"; border-color: #9ca3af; color: #6b7280; background: rgba(243, 244, 246, .9);
}
.pj-card.is-done .pj-card-title { color: #9aa1a9; }
.pj-card-title { font-size: var(--pj-text-size); font-weight: 400; color: var(--pj-ink); line-height: var(--pj-text-leading); }
.pj-card-meta { display: flex; align-items: center; gap: 6px; margin-top: 10px; }
@@ -554,6 +603,8 @@ html.pj-side-resizing, html.pj-side-resizing * { cursor: col-resize !important;
.pj-hovertip.is-below { transform: translate(-50%, 0); }
.pj-hovertip.is-below::after { top: auto; bottom: 100%; border-top-color: transparent; border-bottom-color: #1e1f21; }
.pj-hovertip[hidden] { display: none; }
/* 모달 대화창(showModal) 안의 말풍선은 popover(브라우저 맨 위 층)로 띄운다 — 브라우저 기본 popover 모양(가운데 배치·테두리·스크롤)을 지운다 */
.pj-hovertip[popover] { inset: auto; margin: 0; border: 0; overflow: visible; }
@keyframes pj-tip-in { from { opacity: 0; } to { opacity: 1; } }
/* ── 달력 (휴가 모듈과 동일한 월간 그리드 룩) ── */
@@ -2134,6 +2185,8 @@ html.pj-embed .pj-btn-goto-project { display: inline-flex; align-items: center;
/* 설명란 링크 — 클릭하면 새 탭으로 열린다(JS 가 처리). */
.pj-desc-editor a { color: var(--pj-accent-dark, #2f5bb7); text-decoration: underline; cursor: pointer; }
/* 설명란 링크 서식 — 굵게·기울임·밑줄(2026-10-19). 링크는 한 글자처럼(contenteditable=false) 한 번에 지워진다 */
.pj-desc-editor a { font-weight: 700; font-style: italic; text-decoration: underline; text-underline-offset: 2px; }
/* ── 수신함 섹션 (알림 / 나를 태그한 업무) ── */
.pj-inbox-section { margin-bottom: 26px; }
@@ -2647,6 +2700,16 @@ html.pj-goal-selecting, html.pj-goal-selecting * { user-select: none !important;
.pj-meet-area h3, .pj-meet-area.pj-meet-notes h3 { margin: 0 0 6px; font-size: 13px; font-weight: 600; }
.pj-meet-area.pj-meet-notes { margin: 0; } /* 예전 .pj-meet-notes 여백(16px) 덮기 */
.pj-meet-area h3 small { margin-left: 6px; font-size: 11px; font-weight: 400; color: var(--pj-ink-soft); }
/* ①② 한 칸(2026-10-19) — 머리 한 줄(월 계획 제목·숫자 | 결정사항 제목) + 아래 전체 결정사항 내용(크게). 예전 ①② 두 칸 자리를 합친 너비 */
.pj-meet-board > .pj-meet-pn { grid-column: span 2; }
.pj-meet-pn-head { display: flex; align-items: center; justify-content: flex-start; margin-bottom: 6px; }
.pj-meet-area.pj-meet-pn .pj-meet-pn-title { margin: 0; font-size: 13px; font-weight: 700; text-align: left; }
/* 월 계획 숫자 한 줄 — 제목 줄 안 둘째 줄, 주차 탭과 같은 줄 왼쪽(줄바꿈 .pj-meet-title-break 뒤), 잘리지 않게(좁으면 다음 줄로) */
.pj-meet-title-break { flex-basis: 100%; height: 0; }
.pj-meet-title > .pj-meet-kpitop { flex: 1 1 auto; min-width: 0; align-self: flex-end; margin: 0; padding: 0 2px 4px; }
.pj-meet-kpitop .pj-meet-plan-head { margin: 0; flex-wrap: wrap; row-gap: 2px; }
.pj-meet-kpitop .pj-meet-kpiline { flex: 0 1 auto; overflow: visible; flex-wrap: wrap; row-gap: 2px; white-space: normal; }
.pj-meet-area.pj-meet-pn textarea, .pj-meet-area.pj-meet-pn .pj-meet-ro { font-size: 15px; line-height: 1.6; }
.pj-meet-area-body { flex: 1 1 auto; min-height: 0; overflow: auto; }
.pj-meet-area.pj-meet-notes textarea, .pj-meet-area.pj-meet-notes .pj-meet-ro {
flex: 1 1 auto; min-height: 0; max-height: none; height: auto !important; overflow-y: auto; padding: 8px 10px;
@@ -2906,10 +2969,12 @@ a.pj-meet-quick-done:hover { background: #e8f5ee; }
.pj-meet-table {
width: 100%; border-collapse: separate; border-spacing: 0; table-layout: fixed; font-size: var(--pj-text-size);
background: #fff; border: 1px solid #dfe2e6; border-radius: 10px; color: var(--pj-ink); line-height: var(--pj-text-leading);
/* 테두리(2026-10-19 마지막 요청) — 구역(구분) 처음·끝 가로선만 굵은 검정(2px), 나머지 선은 모두 회색(#bfc3c9).
바깥 아래선 = 마지막 구역 끝 굵은 검정, 바깥 위·좌우는 회색 */
background: #fff; border: 1px solid #bfc3c9; border-bottom: 2px solid #000; border-radius: 0; color: var(--pj-ink); line-height: var(--pj-text-leading);
}
.pj-meet-table th, .pj-meet-table td {
box-sizing: border-box; border-right: 1px solid #e6e8eb; border-bottom: 1px solid #e6e8eb; padding: 0; vertical-align: top;
box-sizing: border-box; border-right: 1px solid #bfc3c9; border-bottom: 1px solid #bfc3c9; padding: 0; vertical-align: top;
}
.pj-meet-table tr > :last-child { border-right: none; }
.pj-meet-table thead th {
@@ -2933,9 +2998,19 @@ a.pj-meet-quick-done:hover { background: #e8f5ee; }
.pj-meet-w-sec { width: 80px; }
.pj-meet-w-label { width: 160px; }
.pj-meet-w-amt { width: 122px; }
.pj-meet-sec > tr > th, .pj-meet-sec > tr > td:not(.is-prev) { background: var(--goal-bg, #fff); border-color: rgba(0, 0, 0, .07); }
.pj-meet-sec > tr > th, .pj-meet-sec > tr > td:not(.is-prev) { background: var(--goal-bg, #fff); }
.pj-meet-sec > tr > td.is-prev { background: #fafbfc; }
.pj-meet-sec > tr:first-child > * { border-top: 1px solid rgba(0, 0, 0, .12); }
/* 가로선 — 구역 첫 줄 위 = 굵은 검정 2px(표 머리 바로 아래도 — 머리 아래 회색선은 없앰), 그 밖(항목 사이·하위 줄 사이·세로선) = 회색.
구역 끝에 닿는 칸(.is-sec-end — JS markMeetSecEnds 가 병합(rowspan)까지 따져 단다)은 아래선 없음 → 다음 구역 굵은 선·표 바깥 굵은 선이 대신.
(.is-item-end 는 아직 달리지만 색은 회색 — 같은 날 앞선 "항목 사이 검정" 요청을 이 요청이 바꿈) */
.pj-meet-table thead tr:last-child > th { border-bottom: none; }
.pj-meet-sec > tr:first-child > * { border-top: 2px solid #000; }
.pj-meet-sec > tr > .is-sec-end { border-bottom: none; }
/* 항목 칸 끌어 옮기기 — 잡은 칸은 grab, 끄는 묶음은 연보라 + 왼쪽 보라 선, 끄는 동안 글자 선택 없음 */
.pj-meet-sec th.pj-meet-c-label:has([data-meet-edit]) { cursor: grab; }
html.pj-meet-row-dragging, html.pj-meet-row-dragging * { cursor: grabbing !important; user-select: none !important; }
.pj-meet-table tr.is-meet-dragging > :not(.pj-meet-c-sec) { background-color: var(--pj-accent-tint) !important; }
.pj-meet-table tr.is-meet-dragging > th.pj-meet-c-label { box-shadow: inset 3px 0 0 var(--pj-accent); }
.pj-meet-sec th { padding: 6px 8px; vertical-align: middle; text-align: center; } /* 구역·항목은 항상 세로 가운데 */
th.pj-meet-c-sec { position: relative; font-size: 13px; font-weight: 800; vertical-align: middle; }
.pj-meet-sec-add {
@@ -3036,6 +3111,12 @@ input.pj-meet-amount::placeholder { color: rgba(0, 0, 0, .28); }
.pj-goal-wkpop-diff b.is-over { color: #dc2626; }
.pj-goal-wkpop-diff b.is-even { color: #16a34a; }
.pj-goal-wkpop-acts { display: flex; justify-content: flex-end; gap: 6px; margin-top: 10px; }
/* 주차 두 칸(030, 2026-10-19) — 주차 이름 | 유통·인플 | 카페24·네이버. 머리글 줄은 전체 목표 아래 구분선 밑 */
.pj-goal-wkpop.is-split { width: 430px; }
.pj-goal-wkpop.is-split .pj-goal-wkpop-row:not(.pj-goal-wkpop-month) { display: grid; grid-template-columns: minmax(0, 1fr) 92px 92px; gap: 6px; }
.pj-goal-wkpop.is-split .pj-goal-wkpop-row:not(.pj-goal-wkpop-month) input { width: 100%; box-sizing: border-box; }
.pj-goal-wkpop-colhead { margin: 0 0 2px; font-size: 11.5px; color: var(--pj-ink-soft); }
.pj-goal-wkpop-colhead b { text-align: center; font-weight: 700; }
/* 나를 태그·작업 배정 알림 — 화면 가운데 아래 큰 팝업(body 에 붙음), 닫기 전까지 깜박인다(2026-10-07) */
.pj-alert-pop {
@@ -3131,15 +3212,67 @@ html[data-pj-font="pretendard"] { --pj-font: "Pretendard Variable", var(--pj-sys
html[data-pj-font="nanum-square"] { --pj-font: "NanumSquare", var(--pj-system-font); }
html[data-pj-font="nanum-square-neo"] { --pj-font: "NanumSquareNeo", var(--pj-system-font); }
html[data-pj-font="nanum-square-round"] { --pj-font: "NanumSquareRound", var(--pj-system-font); }
.pj-options-dialog { width: min(440px, calc(100vw - 40px)); box-sizing: border-box; padding: 24px; border: 1px solid #d8dce2; border-radius: 12px; color: var(--pj-ink); font-family: var(--pj-font); box-shadow: 0 12px 40px #0003; }
/* ── Project 옵션 대화창(_options.html) — 데스크톱 프로그램 설정 창처럼 왼쪽 분류 | 오른쪽 설정 ── */
.pj-options-dialog { width: min(720px, calc(100vw - 40px)); max-height: min(600px, calc(100vh - 40px)); box-sizing: border-box; padding: 0; border: 1px solid #d8dce2; border-radius: 12px; color: var(--pj-ink); font-family: var(--pj-font); box-shadow: 0 12px 40px #0003; overflow: hidden; }
.pj-options-dialog[open] { display: flex; }
.pj-options-dialog::backdrop { background: #0005; }
.pj-options-dialog h2 { margin: 0 0 22px; font-size: 20px; font-weight: 500; }
.pj-options-dialog label { display: block; margin-bottom: 8px; }
.pj-options-dialog form { display: flex; flex-direction: column; width: 100%; min-height: 0; }
.pj-options-head { display: flex; align-items: center; justify-content: space-between; padding: 14px 16px 14px 20px; border-bottom: 1px solid var(--pj-border); }
.pj-options-head h2 { display: flex; align-items: center; gap: 8px; margin: 0; font-size: 18px; font-weight: 500; }
.pj-options-head h2 .material-symbols-outlined { font-size: 22px; color: var(--pj-accent); }
.pj-options-x { display: inline-flex; padding: 4px; border: 0; border-radius: 6px; background: none; color: #6d6e6f; cursor: pointer; }
.pj-options-x:hover { background: #f1f2f4; color: var(--pj-ink); }
.pj-options-body { display: flex; flex: 1; min-height: 380px; overflow: hidden; }
.pj-options-nav { flex: 0 0 180px; display: flex; flex-direction: column; gap: 2px; padding: 12px 8px; background: #f7f8fa; border-right: 1px solid var(--pj-border); }
.pj-options-nav button { display: flex; align-items: center; gap: 10px; padding: 8px 12px; border: 0; border-radius: 6px; background: none; color: #3d3f42; font: inherit; font-size: 14px; text-align: left; cursor: pointer; }
.pj-options-nav button .material-symbols-outlined { font-size: 20px; color: #6d6e6f; }
.pj-options-nav button:hover { background: #eceef1; }
.pj-options-nav button.is-active { background: var(--pj-accent-tint); color: var(--pj-accent-dark); font-weight: 600; }
.pj-options-nav button.is-active .material-symbols-outlined { color: var(--pj-accent); }
.pj-options-nav button:focus-visible { outline: 2px solid var(--pj-accent); outline-offset: -2px; }
.pj-options-panes { flex: 1; min-width: 0; padding: 20px 24px; overflow-y: auto; }
.pj-options-pane h3 { display: flex; align-items: center; gap: 10px; margin: 0 0 14px; font-size: 15px; font-weight: 600; }
/* 설정이 어디에 적용되나 — 이 브라우저(회색) · 모든 사용자(보라) */
.pj-options-badge { display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px 2px 6px; border-radius: 999px; background: #f1f2f4; color: #5f6368; font-size: 11.5px; font-weight: 500; }
.pj-options-badge .material-symbols-outlined { font-size: 15px; }
.pj-options-badge.is-global { background: var(--pj-accent-tint); color: var(--pj-accent-dark); }
.pj-options-group { border: 1px solid var(--pj-border); border-radius: 8px; }
.pj-options-row { display: flex; align-items: center; justify-content: space-between; gap: 16px; padding: 14px 16px; }
.pj-options-row + .pj-options-row { border-top: 1px solid var(--pj-border); }
.pj-options-row.is-stack { flex-direction: column; align-items: stretch; gap: 10px; }
label.pj-options-row[for] { cursor: pointer; }
.pj-options-row > label, .pj-options-label { display: flex; flex-direction: column; gap: 3px; font-size: 14px; }
.pj-options-row > label b, .pj-options-label b { font-weight: 500; }
.pj-options-row small, .pj-options-note { font-size: 12px; color: var(--pj-ink-soft); }
.pj-options-dialog select { width: 100%; padding: 9px; border: 1px solid #d8dce2; border-radius: 6px; font: inherit; }
.pj-options-preview { padding: 18px 12px; margin-top: 16px; border: 1px solid #e5e6e8; border-radius: 6px; font-size: 16px; line-height: 1.7; }
.pj-options-dialog p { font-size: 12px; color: var(--pj-ink-soft); }
.pj-options-dialog .pj-options-error { color: #c22b10; }
.pj-options-actions { display: flex; justify-content: flex-end; gap: 8px; margin-top: 22px; }
.pj-options-preview { padding: 16px 12px; border: 1px solid #e5e6e8; border-radius: 6px; background: #fcfcfd; font-size: 16px; line-height: 1.7; }
/* 처음 여는 탭 — 아이콘 카드 5개 중 하나 */
.pj-options-views { display: grid; grid-template-columns: repeat(5, 1fr); gap: 8px; }
.pj-options-views label { position: relative; display: flex; flex-direction: column; align-items: center; gap: 6px; padding: 12px 4px 10px; border: 1px solid #d8dce2; border-radius: 8px; font-size: 13px; cursor: pointer; transition: border-color .12s, background .12s; }
.pj-options-views label .material-symbols-outlined { font-size: 26px; color: #6d6e6f; }
.pj-options-views label:hover { border-color: var(--pj-accent); }
.pj-options-views input { position: absolute; opacity: 0; pointer-events: none; }
.pj-options-views label:has(input:checked) { border-color: var(--pj-accent); background: var(--pj-accent-tint); color: var(--pj-accent-dark); font-weight: 600; box-shadow: 0 0 0 1px var(--pj-accent) inset; }
.pj-options-views label:has(input:checked) .material-symbols-outlined { color: var(--pj-accent); }
.pj-options-views label:has(input:focus-visible) { outline: 2px solid var(--pj-accent); outline-offset: 2px; }
/* 켜기/끄기 스위치 */
.pj-switch { position: relative; flex: none; display: inline-block; width: 40px; height: 22px; }
.pj-switch input { position: absolute; inset: 0; margin: 0; opacity: 0; cursor: pointer; }
.pj-switch span { position: absolute; inset: 0; border-radius: 999px; background: #c9ccd1; transition: background .15s; pointer-events: none; }
.pj-switch span::after { content: ""; position: absolute; top: 3px; left: 3px; width: 16px; height: 16px; border-radius: 50%; background: #fff; box-shadow: 0 1px 2px #0003; transition: transform .15s; }
.pj-switch input:checked + span { background: var(--pj-accent); }
.pj-switch input:checked + span::after { transform: translateX(18px); }
.pj-switch input:focus-visible + span { outline: 2px solid var(--pj-accent); outline-offset: 2px; }
.pj-switch input:disabled + span { opacity: .5; }
.pj-options-foot { display: flex; align-items: center; gap: 8px; padding: 12px 16px; border-top: 1px solid var(--pj-border); background: #fafbfc; }
.pj-options-foot .pj-options-reset { margin-right: auto; }
.pj-options-dialog .pj-options-error { margin: 0 6px 0 0; font-size: 12px; color: #c22b10; }
@media (max-width: 560px) {
.pj-options-body { flex-direction: column; min-height: 0; overflow-y: auto; }
.pj-options-nav { flex: none; flex-direction: row; overflow-x: auto; border-right: 0; border-bottom: 1px solid var(--pj-border); }
.pj-options-nav button { white-space: nowrap; }
.pj-options-views { grid-template-columns: repeat(3, 1fr); }
}
.pj-goal-format { position: fixed; z-index: 1200; display: flex; align-items: center; flex-wrap: wrap; gap: 6px; padding: 4px 6px; max-width: calc(100vw - 16px); box-sizing: border-box; border: 1px solid var(--pj-border); border-radius: 8px; box-shadow: 0 4px 16px #0002; background: #fff; color: var(--pj-ink); font-family: var(--pj-font); font-size: 12px; }
.pj-goal-format[hidden], .pj-goal-color-grid[hidden] { display: none; }
.pj-goal-format-group { display: inline-flex; align-items: center; gap: 2px; }
+702 -56
View File
@@ -2938,11 +2938,14 @@
return out.replace(/\n/g, "<br>");
}
// 에디터 안의 모든 <a> 가 새 탭으로 열리게 맞춘다(서식바 링크 버튼 포함).
// 설명란 링크 — 새 탭 + 글자 한 덩어리(contenteditable=false, 2026-10-19): 커서가 링크 글자 안으로 들어가지 않고
// Backspace·Delete 한 번에 링크 전체가 지워진다(createDescEditor 의 keydown). 저장 HTML 에서는 빠진다(getHtml·서버 정리기).
function normalizeEditorLinks(box) {
if (!box) return;
box.querySelectorAll("a").forEach(function (a) {
a.setAttribute("target", "_blank");
a.setAttribute("rel", "noopener noreferrer");
if (a.getAttribute("contenteditable") !== "false") a.setAttribute("contenteditable", "false");
});
}
@@ -3419,6 +3422,9 @@
// isPAdmin = Admin 이상(남이 만든 섹션도 삭제).
const isPro = root.dataset.isPro === "true";
const isPAdmin = root.dataset.isPadmin === "true";
// 시스템 Project 옵션(서버 project_options, 수퍼관리자·Admin 이 바꾸면 모든 사용자에게) — 보드 카드 표지 켬/끔.
// 옵션 창에서 저장하면 pj-options-change 로 바로 바뀐다(아래).
let boardCover = root.dataset.boardCover !== "0";
const me = (root.dataset.me || "").toLowerCase();
// 섹션 삭제 — Admin 이상은 누구 것이든, 그 밖은 만든 사람만. created_by 없으면 서버가 최종 판정.
function canDelete(createdBy) {
@@ -3575,19 +3581,22 @@
}
let timeline = null;
// 기본 보기는 항상 보드(왼쪽 프로젝트 클릭 등으로 들어오면 보드).
// 기본 보기는 시스템 Project 옵션의 "처음 여는 탭"(서버 project_options → data-default-view, 없으면 보드) —
// 왼쪽 프로젝트 클릭 등으로 들어오면 그 탭.
// 예외: 달력 이전/다음달 이동은 페이지를 통째로 새로고침하므로(?y=&m=),
// 그때만 마지막으로 보던 뷰를 되살린다 — 안 그러면 달력을 넘기다가
// 보드로 튕겨나간다.
// 왼쪽 "전체 보기"(?scope=all)로 들어오면 기본 보기는 대시보드.
// 처음 탭으로 튕겨나간다.
// 왼쪽 "전체 보기"(?scope=all)로 들어오면 기본 보기는 대시보드(옵션과 무관).
const VIEW_KEY = "pj_view";
const VIEWS = ["board", "list", "calendar", "timeline", "dashboard"];
let currentView = "board";
try {
const qs = new URLSearchParams(location.search);
const saved = localStorage.getItem(VIEW_KEY);
if ((qs.has("y") || qs.has("m")) && saved &&
["board", "list", "calendar", "timeline", "dashboard"].indexOf(saved) >= 0) currentView = saved;
const preferred = root.dataset.defaultView; // 시스템 옵션(서버가 넣어 줌)
if ((qs.has("y") || qs.has("m")) && saved && VIEWS.indexOf(saved) >= 0) currentView = saved;
else if (isPro && qs.get("scope") === "all") currentView = "dashboard";
else if (qs.get("embed") !== "1" && VIEWS.indexOf(preferred) >= 0) currentView = preferred; // 업무 창 패널(iframe)은 그대로 보드
} catch (_) {}
// ── 프로젝트 스코프 — 아사나처럼 기본은 "이 프로젝트만", "전체 프로젝트"로
@@ -3624,8 +3633,11 @@
}
// 보드 카드 순서 바꾸기는 "기본 정렬 + 필터 없음"일 때만 — 가려진 카드가 있거나
// 다른 기준으로 정렬돼 있으면 놓은 자리가 실제 순서와 어긋난다(아사나도 같다).
// 보드 카드 순서를 손으로 바꿀 수 있는가 — 정렬이 "기본"일 때. 필터(상태·담당자·마감·우선순위·찾기)는 막지 않는다
// (2026-10-19): 필터 설정은 브라우저(localStorage pj_filter_…)마다 남아, 필터를 켜 둔 컴퓨터에서만 섹션 안 카드가
// 늘 제자리로 돌아가던 버그. 숨은 업무는 제자리에 두고 보이는 카드끼리의 새 순서만 반영한다(orderWithHidden).
function manualOrderAllowed() {
return taskFilter.sort === "manual" && !taskFilterActive(taskFilter);
return taskFilter.sort === "manual";
}
const FB = {
@@ -3706,6 +3718,14 @@
if (!btn) return;
selectView(btn.dataset.view);
});
// Project 옵션 저장 — 보드 표지 켜기/끄기는 보고 있는 보드에 바로 반영(다른 사용자는 다음에 화면을 열 때)
window.addEventListener("pj-options-change", function (e) {
const d = e.detail || {}, changed = d.changed || [], opts = d.options || {};
if (typeof opts.default_view === "string") root.dataset.defaultView = opts.default_view;
if (changed.indexOf("board_cover") < 0 || typeof opts.board_cover !== "boolean") return;
boardCover = opts.board_cover;
if (currentView === "board") renderBoard();
});
// 서버가 그린 기본 탭(보드)과 기억된 탭이 다르면 화면을 맞춰준다.
if (currentView !== "board") {
tabs.querySelectorAll(".pj-tab").forEach(function (t) {
@@ -4732,26 +4752,31 @@
// 보드 드롭(전체보기) — 컬럼 이름(세션명)으로 옮긴다. 업무가 속한 '그
// 프로젝트'의 동일 이름 세션 id 를 찾아 적용(프로젝트마다 세션 id 가 다르다).
function enableDropByName(body, name) {
body.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); body.classList.add("is-over");
// 전체 보기는 프로젝트마다 섹션이 달라 순서를 못 정한다 — 자리 표시는 섹션 맨 끝(제 섹션은 원래 자리)
wireCardPhOver(body, function () { return false; });
// dragenter 도 받아 둔다 — 자리 표시가 마우스 아래로 들어온 직후(다음 dragover 전) 놓아도 놓기가 거부되지 않게
["dragenter", "dragover"].forEach(function (kind) {
body.addEventListener(kind, function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); e.dataTransfer.dropEffect = "move";
});
});
body.addEventListener("dragleave", function () { body.classList.remove("is-over"); });
body.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault();
body.classList.remove("is-over");
const taskId = parseInt(e.dataTransfer.getData("text/plain"), 10);
const t = tasks.find(function (x) { return x.id === taskId; });
if (!t || (t.stage_name || "") === name) return;
if (!t || (t.stage_name || "") === name) { endCardDrag(true); return; }
const plist = stagesByProject[t.project_id] || [];
const target = plist.find(function (s) { return s.name === name; });
if (!target) { alert("'" + (t.project_name || "이 프로젝트") + "' 에는 '" + name + "' 섹션이 없습니다."); return; }
if (!target) { endCardDrag(true); alert("'" + (t.project_name || "이 프로젝트") + "' 에는 '" + name + "' 섹션이 없습니다."); return; }
if (cardDrag) cardDrag.dropped = true;
try {
const res = await api("PUT", "/project/api/tasks/" + taskId, { stage_id: target.id });
mergeTask(res.task);
renderBoard();
} catch (err) { alert("이동 실패: " + err.message); }
endCardDrag(true);
renderBoard();
});
}
@@ -5183,6 +5208,18 @@
// 세션"만 연결(POST .../links)로 바꾼다.
// 드롭 지점(마우스 Y)이 이 컬럼의 카드들 중 어디에 해당하는지 인덱스로.
// 드래그 중인 카드 자신은 계산에서 제외(자기 위치가 기준을 흔들지 않게).
// 섹션 전체 순서(full, 옮기는 업무 뺌)에 옮기는 업무를 넣는다 — 화면에 보이는 카드 순서(visible, 옮기는 업무 포함)에서
// 바로 앞 카드 뒤(없으면 바로 뒤 카드 앞, 둘 다 없으면 맨 끝). 필터로 숨은 업무는 원래 자리 그대로(예전엔 맨 뒤로 밀렸다).
function orderWithHidden(full, visible, movingId) {
const out = full.filter(function (id) { return id !== movingId; });
const i = visible.indexOf(movingId);
const before = i > 0 ? out.indexOf(visible[i - 1]) : -1;
const after = i >= 0 && i + 1 < visible.length ? out.indexOf(visible[i + 1]) : -1;
if (before >= 0) out.splice(before + 1, 0, movingId);
else if (after >= 0) out.splice(after, 0, movingId);
else out.push(movingId);
return out;
}
function cardDropIndex(body, clientY, excludeTaskId) {
const cards = Array.prototype.slice.call(body.querySelectorAll(".pj-card[data-task-id]"))
.filter(function (c) { return String(c.dataset.taskId) !== String(excludeTaskId); });
@@ -5192,52 +5229,195 @@
}
return cards.length;
}
function enableDropByStageId(body, stageId) {
body.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); body.classList.add("is-over");
// ── 카드 끌기 실시간 미리보기(2026-10-19) — 끄는 동안 카드 자리는 비우고(자리 표시
// .pj-card-ph), 마우스가 카드 사이를 지나는 순간 자리 표시가 그 사이로 옮겨 가며 다른 카드가
// 미끄러지듯 비켜난다(FLIP 애니메이션). 놓으면 자리 표시가 있던 곳에 그대로 들어간다 —
// 섹션 안·다른 섹션 모두. 끄는 카드는 살짝 기울어진 그림자 카드로 마우스를 따라간다.
// 필터·정렬 중이거나 전체 보기(섹션 이름 보드)면 순서를 못 정하므로 원래 자리/섹션 맨 끝만.
let cardDrag = null; // { t, card, ph, fromBody, origIdx, dropped }
function phCards(body) {
return Array.prototype.filter.call(body.children, function (c) {
return c.classList.contains("pj-card") && c.dataset.taskId && (!cardDrag || c !== cardDrag.card);
});
}
function phIndex(body) { // 자리 표시 앞에 있는 카드 수 = 놓을 자리
const ph = cardDrag && cardDrag.ph;
if (!ph || ph.parentNode !== body) return -1;
return phCards(body).filter(function (c) { return c.compareDocumentPosition(ph) & Node.DOCUMENT_POSITION_FOLLOWING; }).length;
}
function startCardDrag(e, card, t) {
endCardDrag(true);
const body = card.parentNode;
if (!body || !body.classList.contains("pj-col-body")) return;
// 끄는 모양 — 카드 복제를 살짝 기울여 그림자와 함께(화면 배율 밖 body 에 잠깐 붙였다 뗀다)
try {
const r = card.getBoundingClientRect();
const ghost = document.createElement("div");
ghost.className = "pj-card-ghost";
const clone = card.cloneNode(true);
clone.classList.remove("is-dragging");
clone.style.width = card.offsetWidth + "px";
ghost.appendChild(clone);
if (document.documentElement.classList.contains("pj-ui-scale")) ghost.style.zoom = "0.75";
document.body.appendChild(ghost);
e.dataTransfer.setDragImage(ghost, Math.max(0, e.clientX - r.left) + 14, Math.max(0, e.clientY - r.top) + 14);
setTimeout(function () { ghost.remove(); }, 0);
} catch (_) {}
const ph = document.createElement("div");
ph.className = "pj-card-ph";
ph.style.height = card.offsetHeight + "px";
// (cardDrag 를 정하기 전이라 phCards 에 끄는 카드도 들어 있다 — 그 순번 = 나머지 카드 중 원래 자리)
cardDrag = { t: t, card: card, ph: ph, fromBody: body, origIdx: phCards(body).indexOf(card), dropped: false };
document.documentElement.classList.add("pj-card-dragging");
// 끌기 그림이 찍힌 뒤에 원래 카드를 숨기고 그 자리에 자리 표시(같은 틱에 숨기면 크롬이 끌기를 취소)
const cur = cardDrag;
setTimeout(function () {
if (cardDrag !== cur || !card.isConnected) return;
card.parentNode.insertBefore(ph, card);
card.classList.add("is-drag-src");
}, 0);
}
function endCardDrag(force) {
const d = cardDrag;
if (!d) return;
if (d.dropped && !force) return; // 놓은 뒤 저장 중 — 저장이 끝나면 다시 그리며 정리
cardDrag = null;
document.documentElement.classList.remove("pj-card-dragging");
d.ph.remove();
d.card.classList.remove("is-drag-src", "is-dragging");
document.querySelectorAll(".pj-col-body.is-over").forEach(function (b) { b.classList.remove("is-over"); });
}
// 레이아웃 바꾸기 전후 위치 차이만큼 되돌렸다가 0 으로 — 비켜나는 카드가 미끄러지는 효과.
function flipBoardCards(bodies, mutate) {
const nodes = [];
bodies.forEach(function (b) {
if (!b) return;
Array.prototype.forEach.call(b.children, function (c) {
if ((c.classList.contains("pj-card") || c.classList.contains("pj-card-ph")) && nodes.indexOf(c) < 0) nodes.push(c);
});
});
const first = nodes.map(function (n) { const r = n.getBoundingClientRect(); return [r.left, r.top]; });
mutate();
nodes.forEach(function (n, i) {
if (!n.isConnected || n.classList.contains("is-drag-src")) return;
const r = n.getBoundingClientRect();
const dx = first[i][0] - r.left, dy = first[i][1] - r.top;
if (!dx && !dy) return;
n.style.transition = "none";
n.style.transform = "translate(" + dx + "px," + dy + "px)";
});
requestAnimationFrame(function () {
nodes.forEach(function (n) {
if (!n.style.transform) return;
n.style.transition = "transform .18s cubic-bezier(.2,.7,.3,1)";
n.style.transform = "";
setTimeout(function () { if (!n.style.transform) n.style.transition = ""; }, 220);
});
});
}
// 마우스 Y 가 이 섹션의 몇 번째 카드 사이인지 — 애니메이션 중인 카드는 움직이기 전 자리로 계산(떨림 방지).
function phTargetIndex(body, clientY, ordered) {
const cards = phCards(body);
if (!ordered) return body === cardDrag.fromBody ? Math.min(cardDrag.origIdx, cards.length) : cards.length;
for (let i = 0; i < cards.length; i++) {
const r = cards[i].getBoundingClientRect();
let ty = 0;
if (cards[i].style.transform) { try { ty = new DOMMatrixReadOnly(getComputedStyle(cards[i]).transform).m42; } catch (_) {} }
if (clientY < r.top - ty + r.height / 2) return i;
}
return cards.length;
}
function placeCardPh(body, clientY, ordered) {
if (!cardDrag || !cardDrag.card.classList.contains("is-drag-src")) return;
const idx = phTargetIndex(body, clientY, ordered);
if (phIndex(body) === idx) return;
const ph = cardDrag.ph;
const oldBody = ph.parentNode;
flipBoardCards([oldBody, body], function () {
const cards = phCards(body);
if (idx < cards.length) body.insertBefore(ph, cards[idx]);
else if (cards.length) cards[cards.length - 1].after(ph);
else body.insertBefore(ph, body.querySelector(":scope > .pj-tasknew"));
});
}
function wireCardPhOver(body, ordered) {
body.addEventListener("dragover", function (e) {
if (!cardDrag || !e.dataTransfer.types.includes("text/plain")) return;
placeCardPh(body, e.clientY, ordered());
});
}
function enableDropByStageId(body, stageId) {
wireCardPhOver(body, manualOrderAllowed);
// dragenter 도 받아 둔다 — 자리 표시가 마우스 아래로 들어온 직후(다음 dragover 전) 놓아도 놓기가 거부되지 않게
["dragenter", "dragover"].forEach(function (kind) {
body.addEventListener(kind, function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); e.dataTransfer.dropEffect = "move";
});
});
body.addEventListener("dragleave", function () { body.classList.remove("is-over"); });
body.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault();
body.classList.remove("is-over");
const taskId = parseInt(e.dataTransfer.getData("text/plain"), 10);
const t = tasks.find(function (x) { return x.id === taskId; });
if (!t) return;
const t = (cardDrag && cardDrag.t.id === taskId && cardDrag.t) || tasks.find(function (x) { return x.id === taskId; });
if (!t) { endCardDrag(true); return; }
// 놓을 자리 = 자리 표시 위치(없으면 마우스 위치)
let idx = phIndex(body);
if (idx < 0) idx = cardDropIndex(body, e.clientY, taskId);
// 자리 표시 기준 이 섹션 카드 순서(끈 카드 포함)
const domIds = phCards(body).map(function (c) { return parseInt(c.dataset.taskId, 10); })
.filter(function (id) { return id !== taskId; });
domIds.splice(idx, 0, taskId);
function orderedFor() {
const full = tasks.filter(function (x) {
return x.stage_id === stageId && x.context_project_id === projectId && x.id !== taskId;
}).map(function (x) { return x.id; });
return orderWithHidden(full, domIds, taskId);
}
if (t.stage_id === stageId) {
if (!manualOrderAllowed()) {
showToast("필터·정렬을 쓰는 중에는 카드 순서를 바꿀 수 없습니다. (정렬: 기본, 필터 초기화 후 가능)", "error");
showToast("정렬을 쓰는 중에는 카드 순서를 바꿀 수 없습니다. (필터 바의 정렬을 '기본'으로 바꾼 뒤 가능)", "error");
endCardDrag(true);
return;
}
// 같은 세션 안에서 카드 위치만 이동 — 세션 이동이 아니라 정렬.
const currentOrder = tasks.filter(function (x) { return x.stage_id === stageId; });
const idx = cardDropIndex(body, e.clientY, taskId);
const withoutDragged = currentOrder.filter(function (x) { return x.id !== taskId; });
withoutDragged.splice(idx, 0, t);
const orderedIds = withoutDragged.map(function (x) { return x.id; });
const beforeIds = currentOrder.map(function (x) { return x.id; });
if (beforeIds.join(",") === orderedIds.join(",")) return; // 놓은 자리가 원래 자리와 같으면 아무것도 안 함
const beforeIds = tasks.filter(function (x) { return x.stage_id === stageId && x.context_project_id === projectId; })
.map(function (x) { return x.id; });
const orderedIds = orderedFor();
if (beforeIds.join(",") === orderedIds.join(",")) { endCardDrag(true); return; } // 놓은 자리가 원래 자리와 같으면 아무것도 안 함
if (cardDrag) cardDrag.dropped = true; // 저장하는 동안 놓은 자리 그대로 보인다
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + stageId + "/tasks/order",
{ ordered_ids: orderedIds });
applyStageOrder(stageId, orderedIds);
renderBoard();
} catch (err) { showToast("순서 변경 실패: " + err.message, "error"); }
endCardDrag(true);
renderBoard();
return;
}
if (cardDrag) cardDrag.dropped = true;
try {
if (t.project_id === projectId) {
const res = await api("PUT", "/project/api/tasks/" + taskId, { stage_id: stageId });
mergeTask(res.task);
// 다른 섹션에도 놓은 자리 그대로 — 기본 정렬·필터 없음일 때만 순서 저장(아니면 섹션 맨 끝)
if (manualOrderAllowed()) {
const orderedIds = orderedFor();
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + stageId + "/tasks/order",
{ ordered_ids: orderedIds });
applyStageOrder(stageId, orderedIds);
} catch (err) { showToast("섹션은 옮겼지만 순서 저장 실패: " + err.message, "error"); }
}
} else {
await api("POST", "/project/api/tasks/" + taskId + "/links",
{ project_id: projectId, stage_id: stageId });
t.stage_id = stageId;
t.is_linked = true;
}
renderBoard();
} catch (err) { showToast("이동 실패: " + err.message, "error"); }
endCardDrag(true);
renderBoard();
});
}
@@ -5935,8 +6115,8 @@
const showProjTag = viewScope === "all" || t.project_id !== projectId;
// 카드 윗부분(배지·제목·담당자/마감일/세부 작업 줄)은 .pj-card-head 로 묶는다 —
// 세부 작업을 펼쳐 컬럼을 스크롤하면 이 부분이 컬럼 맨 위에 고정된다(CSS sticky).
// 설명에 이미지가 있으면 첫 이미지를 카드 위에(아사나 카드 표지)
const cover = cardCoverSrc(t.description);
// 설명에 이미지가 있으면 첫 이미지를 카드 위에(아사나 카드 표지) — Project 옵션 "카드 표지 이미지"로 끌 수 있다
const cover = boardCover ? cardCoverSrc(t.description) : "";
card.classList.toggle("has-cover", !!cover);
card.innerHTML =
(cover ? '<div class="pj-card-cover"><img src="' + escapeHtml(cover) + '" alt="" loading="lazy" draggable="false"></div>' : "") +
@@ -6058,9 +6238,11 @@
e.dataTransfer.setData("text/plain", String(t.id));
// 왼쪽 프로젝트 목록에 놓으면 다른 프로젝트로 옮기기(원 소속 업무만 — 연결로 보이는 카드는 원 소속에서 옮긴다)
if (t.context_project_id === t.project_id || !t.is_linked) e.dataTransfer.setData(TASK_DRAG_TYPE, String(t.id));
e.dataTransfer.effectAllowed = "move";
card.classList.add("is-dragging");
startCardDrag(e, card, t);
});
card.addEventListener("dragend", function () { card.classList.remove("is-dragging"); });
card.addEventListener("dragend", function () { card.classList.remove("is-dragging"); endCardDrag(); });
// 세부 업무 줄을 이 카드에 놓으면 이 업무의 세부 업무로 옮긴다.
// 원래 상위 업무 카드 위에서는 받지 않는다(제자리).
card.addEventListener("dragover", function (e) {
@@ -6087,6 +6269,57 @@
e.preventDefault();
showContextMenu(e.clientX, e.clientY, taskContextItems(t));
});
// 파일을 카드에 끌어 놓으면 구글 드라이브에 올리고 그 업무 설명에 "파일 이름.확장자" 링크(2026-10-19 — 예전엔 첨부).
// 펼친 세부 업무 줄에 놓으면 그 세부 업무 설명에. 카드 끌기(text/plain)·세부 업무 끌기와는 종류("Files")로 구분
let fileDepth = 0;
function fileSubRow(e) {
const r = e.target && e.target.closest ? e.target.closest(".pj-card-sub[data-sub-id]") : null;
return r && card.contains(r) ? r : null;
}
function markFileSub(row) {
card.querySelectorAll(".pj-card-sub.is-drive-over").forEach(function (x) { if (x !== row) x.classList.remove("is-drive-over"); });
if (row) row.classList.add("is-drive-over");
card.classList.toggle("is-file-drop-sub", !!row);
}
card.addEventListener("dragenter", function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
fileDepth++;
card.classList.add("is-file-drop");
markFileSub(fileSubRow(e));
});
card.addEventListener("dragover", function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
e.stopPropagation();
e.dataTransfer.dropEffect = "copy";
markFileSub(fileSubRow(e));
});
card.addEventListener("dragleave", function (e) {
if (!dragHasFiles(e)) return;
if (--fileDepth <= 0) { fileDepth = 0; card.classList.remove("is-file-drop"); markFileSub(null); }
});
card.addEventListener("drop", async function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
e.stopPropagation();
const row = fileSubRow(e);
const files = Array.prototype.slice.call(e.dataTransfer.files || []);
fileDepth = 0;
card.classList.remove("is-file-drop");
markFileSub(null);
if (!files.length) return;
const target = row || card;
target.classList.add("is-file-uploading");
try {
if (row) {
const st = row.querySelector(".pj-card-sub-title");
await dropDriveFilesOnTask(parseInt(row.dataset.subId, 10), files, st ? st.textContent.trim() : "");
} else {
await dropDriveFilesOnTask(t.id, files, t.title || "");
}
} finally { target.classList.remove("is-file-uploading"); }
});
}
return card;
}
@@ -7604,18 +7837,168 @@
});
} catch (e) { ul.innerHTML = "<li class='pj-empty-sm'>불러오기 실패</li>"; }
}
// 업무에 파일 올리기(여러 개는 하나씩 차례로) — [파일 추가]·업무 창에 끌어 놓기·보드 카드에 끌어 놓기 공용.
// 반환 { ok: 올린 수, errors: ["파일 이름: 이유"] }
async function uploadTaskFiles(taskId, files) {
const out = { ok: 0, errors: [] };
for (const f of Array.prototype.slice.call(files || [])) {
const fd = new FormData();
fd.append("file", f);
try {
const res = await fetch("/project/api/tasks/" + taskId + "/attachments", { method: "POST", body: fd });
if (!res.ok) { let m = res.statusText; try { m = (await res.json()).detail; } catch (_) {} throw new Error(m); }
out.ok++;
} catch (e) { out.errors.push(f.name + ": " + e.message); }
}
return out;
}
function reportUpload(out, where) {
if (out.ok) showToast((where ? "‘" + where + "’에 " : "") + "파일 " + out.ok + "개를 첨부했습니다.");
if (out.errors.length) showToast("업로드 실패 — " + out.errors.join(" / "), "error");
}
// ── 업무 파일 → 구글 드라이브(2026-10-19) — 드라이브 `프로젝트/섹션/업무/세부 업무` 폴더에 올리고 설명란에
// "파일 이름.확장자" 링크. 설명에서 링크를 지우면 서버가 그 파일을 드라이브 휴지통으로 보낸다.
// append=true → 서버가 그 업무 설명 끝에 링크를 붙인다(보드 카드·세부 업무 줄 — 설명란을 열어 두지 않은 업무).
async function uploadDriveFile(taskId, file, append) {
const fd = new FormData();
fd.append("file", file);
if (append) fd.append("append", "true");
const res = await fetch("/project/api/tasks/" + taskId + "/drive-files", { method: "POST", body: fd });
if (!res.ok) { let m = res.statusText; try { m = (await res.json()).detail; } catch (_) {} throw new Error(m || ("HTTP " + res.status)); }
const data = await res.json();
if (data.append_failed) throw new Error("드라이브에는 올렸지만 설명에 링크를 못 붙였습니다 — " + data.file.url);
return { url: data.file.url, name: data.file.name, task: data.task || null };
}
// 여러 파일을 차례로 올려 그 업무 설명 끝에 붙인다 → { ok, errors, task(마지막으로 바뀐 업무) }
async function appendDriveFiles(taskId, files) {
const out = { ok: 0, errors: [], task: null };
for (const f of Array.prototype.slice.call(files || [])) {
try { const r = await uploadDriveFile(taskId, f, true); out.ok++; if (r.task) out.task = r.task; }
catch (e) { out.errors.push(f.name + ": " + e.message); }
}
return out;
}
function reportDrive(out, where) {
if (out.ok) showToast((where ? "‘" + where + "’ " : "") + "설명에 구글 드라이브 파일 링크 " + out.ok + "개를 넣었습니다.");
if (out.stale) showToast("파일은 구글 드라이브에 올라갔지만 업무 창이 바뀌어 설명에 링크를 넣지 못했습니다.", "error");
if (out.errors.length) showToast("드라이브 업로드 실패 — " + out.errors.join(" / "), "error");
}
// 보드 카드·업무 창 세부 업무 줄 → 그 업무 설명에 링크. 지금 업무 창(설명란)에 열려 있는 업무면 서버가 아니라
// 편집기 맨 끝에 넣는다(서버가 붙인 뒤 창의 옛 설명이 저장돼 링크가 지워지고 파일이 휴지통으로 가지 않게).
async function dropDriveFilesOnTask(taskId, files, where) {
if (descEditor && !taskModal.hidden && !taskReadOnly && String(currentTaskId) === String(taskId)) {
const out = await descEditor.insertDriveFiles(files, null, null, function (f) { return uploadDriveFile(taskId, f, false); });
reportDrive(out, where);
return out;
}
const out = await appendDriveFiles(taskId, files);
if (out.task) { try { mergeTask(out.task); } catch (_) {} }
reportDrive(out, where);
return out;
}
// 끌고 있는 것이 "파일"인가(카드 끌기·글자 끌기와 구분). 화면 안 카드·세부 업무 끌기 중이면 아니다 —
// 카드 속 이미지(아바타 등)를 잡고 끌면 브라우저가 "Files" 를 같이 실어, 파일 받기 칸이 카드 끌기를 가로채
// 놓을 때 카드가 제자리로 돌아가던 경우를 막는다(2026-10-19).
function dragHasFiles(e) {
if (cardDrag || dragSub) return false;
return !!(e.dataTransfer && Array.prototype.indexOf.call(e.dataTransfer.types || [], "Files") >= 0);
}
const attachInput = el("pj-attach-input");
if (attachInput) attachInput.addEventListener("change", async function () {
if (!currentTaskId || !attachInput.files.length) return;
const fd = new FormData();
fd.append("file", attachInput.files[0]);
try {
const res = await fetch("/project/api/tasks/" + currentTaskId + "/attachments", { method: "POST", body: fd });
if (!res.ok) { let m = res.statusText; try { m = (await res.json()).detail; } catch (_) {} throw new Error(m); }
attachInput.value = "";
loadAttachments(currentTaskId);
} catch (e) { alert("업로드 실패: " + e.message); }
const out = await uploadTaskFiles(currentTaskId, attachInput.files);
attachInput.value = "";
if (out.errors.length) alert("업로드 실패: " + out.errors.join("\n"));
loadAttachments(currentTaskId);
});
// ── 업무 창에 파일 끌어 놓기 — 놓는 자리에 따라(2026-10-19):
// · 설명란 → 구글 드라이브에 올리고 놓은 자리에 "파일 이름.확장자" 링크(설명란 위 점선 안내)
// · 세부 업무 목록의 줄 → 그 세부 업무 설명 끝에 드라이브 링크(줄 점선 안내), 목록 빈 곳 → 이 업무 설명 끝에
// · 그 밖의 곳 → 예전처럼 [첨부 파일](창 전체 점선 안내)
// 아직 저장 전인 새 업무·읽기 전용이면 안내만.
(function wireTaskFileDrop() {
const card = taskModal && taskModal.querySelector(".pj-task-modal-card");
if (!card) return;
const descBox = el("pj-t-desc");
const descWrap = descBox ? descBox.parentElement : null;
const subList = el("pj-subtask-list");
let depth = 0, hot = null;
function blocked() { return !currentTaskId || !canManage || taskReadOnly; }
// 놓는 자리 → { kind: "desc" | "sub" | "subs" | "attach", el, id }
function zoneOf(target) {
const t = target && target.nodeType === 1 ? target : target && target.parentElement;
if (!t) return { kind: "attach", el: null };
if (descWrap && descWrap.contains(t)) return { kind: "desc", el: descWrap };
const row = subList && t.closest ? t.closest(".pj-subtask-row") : null;
if (row && subList.contains(row) && row.dataset.id) return { kind: "sub", el: row, id: row.dataset.id };
if (subList && subList.contains(t)) return { kind: "subs", el: subList };
return { kind: "attach", el: null };
}
function mark(z) {
if (hot && (!z || hot !== z.el)) { hot.classList.remove("is-drive-over"); hot = null; }
const drive = z && z.kind !== "attach";
card.classList.toggle("is-file-over", !!z && (!drive || blocked()));
card.classList.toggle("is-file-blocked", !!z && blocked());
if (drive && !blocked() && z.el) { z.el.classList.add("is-drive-over"); hot = z.el; }
}
const clear = function () { depth = 0; mark(null); card.classList.remove("is-file-over", "is-file-blocked"); };
card.addEventListener("dragenter", function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
depth++;
mark(zoneOf(e.target));
});
card.addEventListener("dragover", function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
e.stopPropagation();
e.dataTransfer.dropEffect = blocked() ? "none" : "copy";
mark(zoneOf(e.target));
});
card.addEventListener("dragleave", function (e) {
if (!dragHasFiles(e)) return;
if (--depth <= 0) clear();
});
card.addEventListener("drop", async function (e) {
if (!dragHasFiles(e)) return;
e.preventDefault();
e.stopPropagation();
const z = zoneOf(e.target);
clear();
if (!canManage || taskReadOnly) { showToast("이 업무에는 파일을 넣을 수 없습니다(읽기 전용).", "error"); return; }
if (!currentTaskId) { showToast("업무 이름을 먼저 넣어 업무를 만든 뒤 파일을 끌어 놓으세요.", "error"); return; }
const taskId = currentTaskId;
const files = Array.prototype.slice.call(e.dataTransfer.files || []);
if (!files.length) return;
if (z.kind === "desc" && descEditor) {
const x = e.clientX, y = e.clientY;
const out = await descEditor.insertDriveFiles(files, x, y, function (f) { return uploadDriveFile(taskId, f, false); });
reportDrive(out, "");
return;
}
if (z.kind === "sub") {
const name = z.el.querySelector(".pj-subtask-title") || {};
const title = (name.value || name.textContent || "").trim();
z.el.classList.add("is-file-uploading");
const out = await appendDriveFiles(parseInt(z.id, 10), files);
z.el.classList.remove("is-file-uploading");
reportDrive(out, title);
return;
}
if (z.kind === "subs") { await dropDriveFilesOnTask(taskId, files, ""); return; }
const out = await uploadTaskFiles(taskId, files);
reportUpload(out, "");
if (currentTaskId === taskId) loadAttachments(taskId);
});
window.addEventListener("dragend", clear);
})();
// 파일을 받는 곳(업무 창·보드 카드) 밖에 놓쳐도 브라우저가 그 파일을 열어 화면을 떠나지 않게 — 받는 곳은 위에서 stopPropagation
document.addEventListener("dragover", function (e) {
if (!dragHasFiles(e) || e.defaultPrevented) return;
e.preventDefault();
e.dataTransfer.dropEffect = "none";
});
document.addEventListener("drop", function (e) { if (dragHasFiles(e) && !e.defaultPrevented) e.preventDefault(); });
// ── 댓글 ──
// 댓글 목록(아사나식) — 댓글·완료 이력을 시간순으로, 답글은 원 댓글 아래 들여쓰기.
@@ -8475,6 +8858,49 @@
e.preventDefault();
openImageWindow(e.target);
});
// ── 링크 = 한 글자처럼(2026-10-19) — 붙여넣기·링크 버튼·드라이브 링크 등으로 새 링크가 생기면 바로 잠그고,
// 커서 바로 앞(Backspace)/뒤(Delete)가 링크면 링크 전체를 한 번에 지운다(execCommand 라 Ctrl+Z 로 되돌리기 가능).
box.addEventListener("input", function () {
if (box.querySelector("a:not([contenteditable])")) normalizeEditorLinks(box);
});
function linkNear(range, backward) {
let node = range.startContainer, off = range.startOffset;
const inside = node.nodeType === 1 ? node.closest("a") : node.parentElement && node.parentElement.closest("a");
if (inside && box.contains(inside)) return inside;
let cand = null;
if (node.nodeType === 3) {
// 지우는 방향에 글자가 남아 있으면(ZWSP 제외) 평소처럼 한 글자
const rest = backward ? node.nodeValue.slice(0, off) : node.nodeValue.slice(off);
if (rest.replace(/\u200b/g, "")) return null;
cand = backward ? node.previousSibling : node.nextSibling;
} else {
cand = backward ? node.childNodes[off - 1] : node.childNodes[off];
}
// 빈 글자 노드는 건너뛴다
while (cand && cand.nodeType === 3 && !cand.nodeValue.replace(/\u200b/g, "")) cand = backward ? cand.previousSibling : cand.nextSibling;
if (!cand || cand.nodeType !== 1) return null;
if (cand.tagName === "A") return cand;
// <b><a>..</a></b> 처럼 서식 안에 든 링크 — 맞닿은 쪽 끝이 링크면
const edge = backward ? cand.lastElementChild : cand.firstElementChild;
const edgeText = backward ? cand.lastChild : cand.firstChild;
return edge && edge.tagName === "A" && edge === edgeText ? edge : null;
}
box.addEventListener("keydown", function (e) {
if ((e.key !== "Backspace" && e.key !== "Delete") || e.isComposing || e.altKey) return;
if (box.getAttribute("contenteditable") === "false") return;
const sel = window.getSelection();
if (!sel || !sel.rangeCount || !sel.isCollapsed || !box.contains(sel.anchorNode)) return;
const a = linkNear(sel.getRangeAt(0), e.key === "Backspace");
if (!a) return;
e.preventDefault();
const r = document.createRange();
r.selectNode(a);
sel.removeAllRanges();
sel.addRange(r);
let ok = false;
try { ok = document.execCommand("delete"); } catch (_) { ok = false; }
if (!ok || a.isConnected) { a.remove(); box.dispatchEvent(new Event("input", { bubbles: true })); }
});
box.addEventListener("click", function (e) {
if (e.target.tagName === "IMG") selectImg(e.target);
else selectImg(null);
@@ -8591,9 +9017,9 @@
let pendingUploads = 0;
let idleWaiters = [];
let editorGen = 0;
function beginUpload() {
function beginUpload(label) {
pendingUploads++;
if (hint) hint.textContent = "이미지 업로드 중…";
if (hint) hint.textContent = label || "이미지 업로드 중…";
}
function endUpload() {
pendingUploads = Math.max(0, pendingUploads - 1);
@@ -8670,15 +9096,73 @@
imgInput.value = "";
});
// ── 파일 끌어 놓기 → 구글 드라이브(2026-10-19) — 놓은 자리에 "올리는 중" 표시를 두고, 올라가면 그 자리를
// "파일 이름.확장자" 링크(새 탭)로 바꾼다. 올리는 동안은 저장을 미룬다(isUploading). upload(file) → Promise<{url, name}>.
// x·y 가 없으면 설명 맨 끝에. 반환 { ok, errors: ["파일: 이유"], stale: 올렸지만 창이 바뀌어 못 넣음 }
function caretRangeAt(x, y) {
let r = null;
try {
if (document.caretRangeFromPoint) r = document.caretRangeFromPoint(x, y);
else if (document.caretPositionFromPoint) {
const p = document.caretPositionFromPoint(x, y);
if (p) { r = document.createRange(); r.setStart(p.offsetNode, p.offset); r.collapse(true); }
}
} catch (_) { r = null; }
return r && box.contains(r.startContainer) ? r : null;
}
async function insertDriveFiles(files, x, y, upload) {
const list = Array.prototype.slice.call(files || []);
const out = { ok: 0, errors: [], stale: false };
if (!list.length || box.getAttribute("contenteditable") === "false") return out;
const myGen = editorGen;
let at = x != null && y != null ? caretRangeAt(x, y) : null;
if (!at) { at = document.createRange(); at.selectNodeContents(box); at.collapse(false); }
const mark = document.createElement("span");
mark.className = "pj-drive-uploading";
mark.setAttribute("contenteditable", "false");
mark.textContent = "구글 드라이브에 올리는 중… (" + list.length + "개)";
at.insertNode(mark);
beginUpload("파일을 구글 드라이브에 올리는 중…");
const links = [];
try {
for (const f of list) {
try { links.push(await upload(f)); out.ok++; }
catch (e) { out.errors.push(f.name + ": " + e.message); }
}
} finally {
if (myGen !== editorGen || !mark.isConnected) {
out.stale = links.length > 0;
mark.remove();
} else {
const frag = document.createDocumentFragment();
links.forEach(function (l, i) {
if (i) frag.appendChild(document.createElement("br"));
const a = document.createElement("a");
a.href = l.url; a.target = "_blank"; a.rel = "noopener noreferrer";
a.textContent = l.name;
frag.appendChild(a);
});
if (links.length) frag.appendChild(document.createTextNode(" "));
mark.replaceWith(frag);
lastRange = null;
box.dispatchEvent(new Event("input", { bubbles: true }));
}
endUpload();
}
return out;
}
return {
setTaskId: setTaskId,
insertDriveFiles: insertDriveFiles,
setHtml: function (html) {
selectImg(null); lastRange = null;
box.innerHTML = html || "";
normalizeEditorLinks(box);
normalizeChecklists(); // 예전 방식(<input type=checkbox>) 체크리스트 → 글머리식
},
getHtml: function () { return box.innerHTML; },
// 링크 잠금 표시(contenteditable)는 화면 전용 — 저장·비교 값에서는 뺀다
getHtml: function () { return box.innerHTML.replace(/(<a\s[^>]*?) contenteditable="false"/g, "$1"); },
isUploading: function () { return pendingUploads > 0; },
whenIdle: whenIdle,
setOnImageRemoved: function (fn) { onImageRemoved = fn; },
@@ -9611,6 +10095,8 @@
async function syncOnce() {
// 회의록 패널을 보는 동안은 이전 프로젝트 화면의 자동 갱신이 왼쪽 메뉴를 다시 만들지 않게 한다.
if (document.querySelector(".pj-meeting-panel-host")) return;
// 보드 카드를 끄는 중에는 다시 그리지 않는다(자리 표시·끄는 카드가 사라짐) — 다음 주기에 반영
if (document.documentElement.classList.contains("pj-card-dragging")) return;
if (syncing || observed === null || observed === applied) return;
syncing = true;
const target = observed;
@@ -9805,7 +10291,25 @@
function initHoverTips() {
let tipEl = null;
let shown = false;
function show(text, x, y) {
// 모달 대화창(dialog.showModal — Project 옵션 등)은 브라우저 맨 위 층(top layer)에 떠서 body 의 말풍선이
// z-index 와 상관없이 그 뒤에 가려진다. 그 안에서는 말풍선을 popover 로 띄워 같은 층, 대화창보다 위에 둔다.
function inModal(target) {
const dlg = target.closest("dialog[open]");
if (!dlg) return false;
try { return dlg.matches(":modal"); } catch (_) { return true; }
}
function topLayer(on) {
if (typeof tipEl.showPopover !== "function") return; // popover 미지원 브라우저 — 예전처럼
const open = tipEl.hasAttribute("popover") && tipEl.matches(":popover-open");
if (on) {
if (!tipEl.hasAttribute("popover")) tipEl.setAttribute("popover", "manual");
if (!open) tipEl.showPopover();
} else if (tipEl.hasAttribute("popover")) {
if (open) tipEl.hidePopover();
tipEl.removeAttribute("popover");
}
}
function show(text, x, y, modal) {
if (!tipEl) {
tipEl = document.createElement("div");
tipEl.className = "pj-hovertip";
@@ -9813,6 +10317,7 @@
}
tipEl.textContent = text;
tipEl.hidden = false;
topLayer(!!modal);
// 화면 가장자리 보정 — 좌우로 넘치면 말풍선만 안쪽으로 밀고 꼬리는
// 커서를 계속 가리키게(--pj-tip-shift).
// 늘 커서 **위**에 — 마우스 화살표(핫스팟에서 아래로 약 20px)에 가려지지 않게. 화면 맨 위(회의록 머리 버튼 등)라
@@ -9829,7 +10334,7 @@
tipEl.style.left = cx + "px";
tipEl.style.top = (below ? y + 28 : roomy ? y - 10 : y - 2) + "px";
}
function hide() { shown = false; if (tipEl) tipEl.hidden = true; }
function hide() { shown = false; if (tipEl) { topLayer(false); tipEl.hidden = true; } }
document.addEventListener("mouseover", function (e) {
const el = e.target.closest ? e.target.closest("[title]") : null;
if (!el) return;
@@ -9841,7 +10346,7 @@
const target = e.target.closest ? e.target.closest("[data-tip]") : null;
if (!target || !target.dataset.tip) { if (shown) hide(); return; }
shown = true;
show(target.dataset.tip, e.clientX, e.clientY);
show(target.dataset.tip, e.clientX, e.clientY, inModal(target));
});
// 누르거나 스크롤하면 숨긴다 — 클릭으로 요소가 다시 그려지면 말풍선만
// 허공에 남는 일이 없게.
@@ -10296,6 +10801,8 @@
// 아래에 주차별 목표, 맨 아래 주차 합계와 차이(월 목표 − 주차 합계). 주차 합계가 월 목표가 되지 않는다.
// 관리자는 입력·저장, 보기만 하는 사람은 값 보기. 주차는 서버(store.month_weeks)가 정한다.
const WEEKS = window.PJ_GOAL_WEEKS || null;
// 주차 입력 두 칸(030, 2026-10-19) — 왼쪽 유통·인플(dist) · 오른쪽 카페24·네이버(mall). 머리글은 전체 목표 아래 구분선 밑에
const WEEK_SPLIT = !!window.PJ_GOAL_WEEK_SPLIT;
let weekPop = null;
function closeWeekPop() {
if (!weekPop) return;
@@ -10312,18 +10819,24 @@
const unit = window.PJ_GOAL_UNIT || "";
const edit = isPro && cell.tagName === "INPUT";
weekPop = document.createElement("div");
weekPop.className = "pj-goal-wkpop";
weekPop.className = "pj-goal-wkpop" + (WEEK_SPLIT ? " is-split" : "");
weekPop.innerHTML = '<div class="pj-goal-wkpop-head">' + mo + "월 주차별 매출 목표" +
(unit ? " <small>(" + escapeHtml(unit) + ")</small>" : "") + "</div>" +
'<label class="pj-goal-wkpop-row pj-goal-wkpop-month"><span>' + mo + "월 전체 목표</span>" +
'<input type="text" inputmode="decimal" autocomplete="off" data-month-total="1" value="' +
escapeHtml((cell.tagName === "INPUT" ? cell.value : cell.textContent).trim()) + '"' +
(edit ? "" : " readonly") + "></label>" +
(WEEK_SPLIT ? '<div class="pj-goal-wkpop-row pj-goal-wkpop-colhead"><span></span><b>유통·인플</b><b>카페24·네이버</b></div>' : "") +
list.map(function (w) {
return '<label class="pj-goal-wkpop-row"><span>' + w.n + "주차 <em>" + escapeHtml(w.label) + "</em>" +
(w.days ? ' <i class="pj-goal-wkpop-days">' + w.days + "일</i>" : "") + "</span>" +
'<input type="text" inputmode="decimal" autocomplete="off" data-start="' + w.start + '" value="' +
escapeHtml(w.value || "") + '"' + (edit ? "" : " readonly") + "></label>";
const name = '<span>' + w.n + "주차 <em>" + escapeHtml(w.label) + "</em>" +
(w.days ? ' <i class="pj-goal-wkpop-days">' + w.days + "일</i>" : "") + "</span>";
const box = function (part, val, aria) {
return '<input type="text" inputmode="decimal" autocomplete="off" data-start="' + w.start + '"' +
(part ? ' data-part="' + part + '" aria-label="' + w.n + "주차 " + aria + '"' : "") + ' value="' +
escapeHtml(val || "") + '"' + (edit ? "" : " readonly") + ">";
};
if (WEEK_SPLIT) return '<div class="pj-goal-wkpop-row">' + name + box("dist", w.dist, "유통·인플") + box("mall", w.mall, "카페24·네이버") + "</div>";
return '<label class="pj-goal-wkpop-row">' + name + box("", w.value, "") + "</label>";
}).join("") +
'<div class="pj-goal-wkpop-sum"><span>주차 합계</span><b data-sum="weeks"></b></div>' +
'<div class="pj-goal-wkpop-sum pj-goal-wkpop-diff"><span>차이 <small>(월 목표 − 주차 합계)</small></span><b data-sum="diff"></b></div>' +
@@ -10352,12 +10865,18 @@
paintSum();
async function save(btn) {
const weeks = {};
inputs.forEach(function (i) { weeks[i.dataset.start] = i.value; });
inputs.forEach(function (i) {
if (i.dataset.part) { (weeks[i.dataset.start] = weeks[i.dataset.start] || {})[i.dataset.part] = i.value; }
else weeks[i.dataset.start] = i.value;
});
btn.disabled = true;
try {
const res = await api("PUT", "/project/api/goals/" + year + "/week-targets/" + mo,
{ month: monthInput.value, weeks: weeks });
list.forEach(function (w) { if (res.weeks && w.start in res.weeks) w.value = res.weeks[w.start]; });
list.forEach(function (w) {
if (res.weeks && w.start in res.weeks) w.value = res.weeks[w.start];
if (res.parts && w.start in res.parts) { w.dist = res.parts[w.start].dist; w.mall = res.parts[w.start].mall; }
});
cell.value = res.label || "";
recompute();
flashSaved(cell.parentElement);
@@ -12348,6 +12867,133 @@
showContextMenu(x, y, items.concat(cellGrid ? [null].concat(cellGrid.widthItems(tr.querySelector("th.pj-meet-c-label"))) : []));
}
// ── 항목 칸 끌어 옮기기(2026-10-19) — 항목 칸을 잡고 위아래로 끌면 그 묶음(같은 항목 칸으로 이어 붙은 줄 + 걸친 세로 병합)이
// 마우스를 따라 같은 구역의 묶음 사이로 실시간으로 옮겨 가고, 다른 줄은 미끄러지듯 비켜난다. 놓으면 move-to 저장 후
// 표를 다시 그린다(실패하면 서버 순서로 되돌림). Esc = 취소. 살짝 누르기만 하면(5px 미만) 예전처럼 이름 수정.
// 칸 아래선 종류(CSS) — 구역 끝에 닿는 칸(마지막 줄 + 거기까지 내려오는 병합 칸) .is-sec-end = 선 없음(구역 경계 굵은 선이 대신),
// 다음 줄이 새 항목(항목 칸이 있는 줄)이면 .is-item-end = 검정, 나머지(같은 항목 안 하위 줄 사이)는 회색.
function markMeetSecEnds() {
table.querySelectorAll("tbody.pj-meet-sec").forEach(function (tbody) {
const rows = Array.from(tbody.rows), n = rows.length;
const itemStart = rows.map(function (tr) { return tr.dataset.labelCont !== "1" && !!tr.querySelector("th.pj-meet-c-label"); });
rows.forEach(function (tr, k) {
Array.prototype.forEach.call(tr.cells, function (c) {
const next = k + (c.rowSpan || 1); // 이 칸 바로 아래 줄
c.classList.toggle("is-sec-end", next >= n);
c.classList.toggle("is-item-end", next < n && itemStart[next]);
});
});
});
}
markMeetSecEnds();
table.addEventListener("pj-meet-rows", markMeetSecEnds); // refreshMeeting 이 표를 다시 그린 뒤
if (canEdit) {
let press = null, rowDrag = null, noClickUntil = 0;
const meetUnits = function (tbody) { // 묶음 = 항목 칸 첫 줄부터(이어 붙은 줄·병합에 가려진 줄은 앞 묶음에)
const rows = Array.from(tbody.rows), covered = new Set(), out = [];
rows.forEach(function (tr, k) {
tr.querySelectorAll("td[data-meet-item]").forEach(function (td) {
for (let n = 1; n < (td.rowSpan || 1); n++) covered.add(k + n);
});
});
rows.forEach(function (tr, k) {
const start = !out.length || (tr.dataset.labelCont !== "1" && tr.querySelector("th.pj-meet-c-label") && !covered.has(k));
if (start) out.push([tr]); else out[out.length - 1].push(tr);
});
return out;
};
const applyUnits = function (order) { // 줄을 이 순서로 다시 끼우고 FLIP(칸 단위 — 구분 칸은 첫 줄에 고정)
const d = rowDrag, cells = [];
d.tbody.querySelectorAll("tr > th, tr > td").forEach(function (c) {
if (c !== d.secTh) cells.push([c, c.getBoundingClientRect().top]);
});
order.forEach(function (u) { u.forEach(function (tr) { d.tbody.appendChild(tr); }); });
const first = d.tbody.rows[0];
if (d.secTh && d.secTh.parentElement !== first) first.insertBefore(d.secTh, first.firstChild);
d.units = order;
markMeetSecEnds();
if (!Element.prototype.animate) return;
cells.forEach(function (p) {
const dy = p[1] - p[0].getBoundingClientRect().top;
if (Math.abs(dy) > 0.5) {
p[0].animate([{ transform: "translateY(" + dy + "px)" }, { transform: "none" }],
{ duration: 170, easing: "cubic-bezier(.2,.7,.3,1)" });
}
});
};
const endRowDrag = function (cancel) {
const d = rowDrag;
rowDrag = null;
press = null;
if (!d) return null;
if (cancel && d.tbody.isConnected) { rowDrag = d; applyUnits(d.start); rowDrag = null; }
d.me.forEach(function (tr) { tr.classList.remove("is-meet-dragging"); });
document.documentElement.classList.remove("pj-meet-row-dragging");
noClickUntil = Date.now() + 350;
return d;
};
table.addEventListener("mousedown", function (e) {
if (e.button !== 0 || rowDrag) return;
const th = e.target.closest("tbody.pj-meet-sec th.pj-meet-c-label");
if (!th || e.target.closest("button, .is-editing, .pj-meet-colresize")) return;
press = { th: th, x: e.clientX, y: e.clientY };
});
document.addEventListener("mousemove", function (e) {
if (!press) return;
if (!rowDrag) {
if (Math.abs(e.clientY - press.y) < 5 || !press.th.isConnected) return;
const tr = press.th.parentElement, tbody = tr.closest("tbody");
const units = meetUnits(tbody);
const me = units.find(function (u) { return u.indexOf(tr) >= 0; });
if (!me || units.length < 2) { press = null; return; }
rowDrag = { tbody: tbody, units: units, start: units.slice(), me: me, secTh: tbody.querySelector("th.pj-meet-c-sec") };
me.forEach(function (r) { r.classList.add("is-meet-dragging"); });
document.documentElement.classList.add("pj-meet-row-dragging");
try { window.getSelection().removeAllRanges(); } catch (_) {}
}
e.preventDefault();
const d = rowDrag;
if (!d.tbody.isConnected) { endRowDrag(false); return; } // 그 사이 표를 다시 그림
const others = d.units.filter(function (u) { return u !== d.me; });
let idx = others.length;
for (let i = 0; i < others.length; i++) {
const top = others[i][0].getBoundingClientRect().top;
const bottom = others[i][others[i].length - 1].getBoundingClientRect().bottom;
if (e.clientY < (top + bottom) / 2) { idx = i; break; }
}
const order = others.slice();
order.splice(idx, 0, d.me);
if (order.every(function (u, k) { return u === d.units[k]; })) return;
applyUnits(order);
});
document.addEventListener("mouseup", function () {
const d = endRowDrag(false);
if (!d || !d.tbody.isConnected) return;
const k = d.units.indexOf(d.me);
if (k === d.start.indexOf(d.me)) return; // 제자리
const next = d.units[k + 1];
const moveId = d.me[0].dataset.item, before = next ? parseInt(next[0].dataset.item, 10) : null;
run(async function () {
try {
await api("POST", itemUrl(moveId) + "/move-to", { before_item_id: before });
} catch (err) {
showToast("옮기지 못했습니다: " + err.message, "error");
await refreshMeeting(); // 서버 순서로 되돌림
return false;
}
return true;
});
});
document.addEventListener("keydown", function (e) {
if (e.key === "Escape" && rowDrag) { e.preventDefault(); e.stopPropagation(); endRowDrag(true); }
}, true);
window.addEventListener("blur", function () { if (rowDrag) endRowDrag(true); else press = null; });
// 끌기를 끝낸 바로 뒤 클릭은 이름 수정으로 넘기지 않는다
table.addEventListener("click", function (e) {
if (Date.now() < noClickUntil) { e.preventDefault(); e.stopImmediatePropagation(); }
}, true);
}
// ── 줄 구조가 바뀐 뒤(줄 추가·삭제·이동·항목 칸 나누기·구역 이동·셀 병합) 새로고침 없이 표의 구역 부분만 서버에서 다시 받아
// 그 자리에서 바꿔 끼운다(연간 목표 refreshTable 과 같은 방식) — 지운 줄은 흐려지며 사라지고, 남은 줄은 예전 자리에서
// 새 자리로 미끄러지고(FLIP), 새 줄은 위에서 내려오며 잠깐 강조. 동작 줄이기 설정이면 애니메이션 없이.
+1
View File
@@ -34,6 +34,7 @@ MODULE_KEYS: tuple[str, ...] = (
"cafe24",
"performance",
"asset",
"inout",
"expense_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-shell.css?v=20260615b" />
<link rel="stylesheet" href="/static/erp-attach-viewer.css" />
<link rel="stylesheet" href="/static/erp-dialog.css?v=20260930a" />
<link rel="stylesheet" href="/static/erp-dialog.css?v=20261017a" />
<link rel="stylesheet" href="/static/erp-notice.css?v=20261015a" />
<link rel="stylesheet" href="/static/erp-overdue.css?v=20261013a" />
{% block head_extra %}{% endblock %}
@@ -189,7 +189,7 @@
{# 공용 확인/경고 창. defer 를 쓰지 않는다 — 아래 {% block scripts %} 의
인라인 스크립트가 곧바로 erpConfirm/erpAlert 을 쓸 수 있어야 한다. #}
<script src="/static/erp-dialog.js?v=20260930a"></script>
<script src="/static/erp-dialog.js?v=20261017a"></script>
<script src="/static/erp-attach-viewer.js" defer></script>
{# 긴급 공지 — 로그인한 모든 화면 가운데(받는 사람이 [확인] 전까지). app/modules/notice #}
{% if user %}<script src="/static/erp-notice.js?v=20261015a" defer></script>{% endif %}
+1 -1
View File
@@ -420,7 +420,7 @@ cafe24_oauth_tokens 저장
| 대상 | 우리가 남기는 것 | 지연 판정 | 구현 |
| --- | --- | --- | --- |
| 상세설명 HTML | MANUAL/SCHEDULED revision (+ 적용 직전 BACKUP) | 카페24 값이 유예시간 안의 **revision 중 하나와 같으면** 지연(pending) → 마지막 쓰기를 표시하고 그 지문을 쓴다. 마지막 쓰기와 같으면 synced. 우리가 모르는 값이면 external(관리자에서 직접 고침) → 카페24 값 표시 | `store.resolve_description`, `routes_products.resolve_description`, DB `revision_digests`(md5) |
| 상품명·가격·이미지·진열/판매 | PUT 응답을 `cafe24_products.last_write_snapshot.product` 에 저장 | GET 의 `updated_date` 가 스냅샷의 `updated_date` 보다 **이전**이면 지연 → 스냅샷 값으로 덮어씀. 카페24 자신의 시각끼리 비교하므로 서버 시계와 무관 | `store.overlay_recent_write`, `routes_products.load_product` |
| 상품명·가격·이미지·진열/판매 | PUT 응답을 `cafe24_products.last_write_snapshot.product` 에 저장 | GET 의 `updated_date` 가 스냅샷의 `updated_date` 보다 **이전**이면 지연 → 스냅샷 값으로 덮어씀. **같은 시각인데 값이 다르면**(진열/판매만 바꾼 PUT 은 `updated_date` 를 안 올릴 수 있음)도 지연. **이후**면 관리자 수정 → 카페24 값. 카페24 자신의 시각끼리 비교하므로 서버 시계와 무관. **목록**도 같은 보정(`get_recent_product_snapshots` 한 번 조회) — 안 하면 진열/판매 변경 뒤 목록·필터가 예전 값으로 보이고 캐시도 예전 값으로 덮인다 | `store.overlay_recent_write`, `store.overlay_product_rows`, `routes_products.load_product`·목록, 예약 미리보기 |
| 옵션 | PUT/POST 응답을 `…snapshot.options` 에 저장 | 유예시간 안이면 스냅샷 우선 | `routes_product_info._apply_options_snapshot` |
| 품목 | 보낸 값(+응답)을 `…snapshot.variants` 에 코드별 누적 | 유예시간 안이면 해당 코드의 필드만 덮어씀 | `routes_product_info._apply_variant_snapshot` |
+1
View File
@@ -12,6 +12,7 @@
| `malaysia_stock_db` | 말레이시아 창고 재고관리 — 창고/아이템/세트 BOM/입출고 이력/일일 재고조사 |
| `cafe24_db` | 카페24 연동 — OAuth 토큰/상품 캐시/상세페이지 버전/예약/감사·API 로그 |
| `performance_db` | 실적(쇼핑몰 통합 매출) — 쇼핑몰 설정/수수료율 이력/API 인증정보(암호문)/연결 상태/매출 사건/동기화 기록 |
| `inout_db` | 입출고 관리 — 공장/발주 담당·입고 담당/발주서·발주 품목/입고·입고 품목/상품 정보(단가·무게·은 함유량, 004)/모듈 설정(물류센터 이메일)·입고 요청 메일 기록(005) (2026-10-16, 앱 계정 `inout_app`, `INOUT_DB_URL`, 초기화 `scripts/sql/inout_db_init.sql`, 상세 `docs/INOUT_MODULE.md`) |
---
+108
View File
@@ -125,6 +125,17 @@ docker exec postgres-db psql -U postgres -d project_db -c "SELECT to_regclass('g
설정이 없거나 권한이 모자라면 버튼을 눌렀을 때 사유가 안내되고(503), 회의록 다른 기능은 그대로 동작한다.
## Project 업무 파일 → 구글 드라이브 설정 (2026-10-19)
업무 설명란·보드 카드·세부 업무 줄에 파일을 끌어 놓으면 구글 드라이브 `PROJECT_DRIVE_FOLDER_ID`(기본 `1Zdak2FtACRJ6peOnA9zD22hsbbsTixJG`)
아래 `프로젝트/섹션/업무/세부 업무` 폴더에 올리고 설명에 링크를 넣는다(`app/integrations/google_drive.py`). DB 변경 없음.
인증은 위 회의록 보드와 같은 Google 설정(Drive 권한)을 쓴다.
- 그 폴더에 **편집 권한**이 있는 계정이어야 한다 — OAuth 토큰이면 토큰을 발급한 계정, 서비스 계정이면 서비스 계정 이메일을 폴더에 편집자로 추가.
서비스 계정은 저장 용량이 없어 **내 드라이브 폴더에는 못 올린다**(공유 드라이브 폴더 필요) — 그 경우 화면에 사유가 뜬다.
- 링크를 본 사람이 파일을 열려면 그 폴더가 직원들에게 공유돼 있어야 한다(드라이브 폴더 공유 설정).
- 설명에서 링크를 지우면 그 파일을 드라이브 휴지통으로(30일 뒤 드라이브가 지움). 이 기능으로 올린 파일만(appProperties `dbxTaskId`).
## 주간 회의록 항목 칸 묶음 마이그레이션 (027)
027은 `goal_meeting_items.label_cont` 열만 추가한다(기본 false, 기존 값 그대로, 다시 실행 가능). 미적용이면 "주요 업무" 칸의
@@ -150,6 +161,20 @@ docker exec postgres-db psql -U postgres -d project_db -c "SELECT COUNT(*) FROM
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d project_db < scripts/sql/project_db_028_followers_exclude_assignee.sql
```
## Project 옵션(시스템 전체 설정) 마이그레이션 (029)
029는 `project_options` 테이블만 추가한다(키 하나 = 행 하나, 기존 값 변경 없음, 다시 실행 가능). 수퍼관리자·Admin 이 Project 옵션 창에서
바꾸는 "처음 여는 탭"·"보드 카드 표지"를 모든 사용자에게 적용하는 저장소다. 행이 없으면 기본값(보드·표지 켬).
미적용이면 화면은 기본값으로 열리고, 옵션 저장만 503 안내(폰트는 브라우저 저장이라 그대로 동작).
되돌리기 = `DROP TABLE project_options;`(사용자 확인 후 — 저장한 시스템 설정만 사라지고 기본값으로).
```bash
cd /opt/www/main
docker exec postgres-db pg_dump -U postgres project_db > ~/project_db_before_029_$(date +%Y%m%d%H%M).sql
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d project_db < scripts/sql/project_db_029_project_options.sql
docker exec postgres-db psql -U postgres -d project_db -c "SELECT key, value, updated_by, updated_at FROM project_options;"
```
## 실적 수동 입력·열 순서 마이그레이션 (performance_db 002)
002는 `perf_marketplaces.manual_input` 열(기본 꺼짐) + `perf_manual_sales` 표를 추가하고, 쇼핑몰 순서(`sort_order`)를
@@ -250,6 +275,88 @@ docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d project_db < s
docker exec postgres-db psql -U postgres -d project_db -c "SELECT to_regclass('goal_meeting_tasks') AS t;"
```
## 입출고 관리 DB 생성 (inout_db, 2026-10-16)
새 DB 라 기존 DB·데이터는 건드리지 않는다(초기화 SQL 은 멱등, DROP·TRUNCATE 없음).
**비밀번호를 DSN 에 그대로 넣지 않는다** — `@`·`:`·`/`·`#`·`%` 같은 문자가 있으면 주소가 깨져 앱이 DB 를 못 찾고
(`failed to resolve host '…@postgres-db'`) 화면은 30초 뒤 500(PoolTimeout)이 된다(2026-10-16 실제 발생). 아래처럼 URL 인코딩해서 넣는다.
```bash
cd /opt/www/main && git pull
docker exec postgres-db psql -U postgres -lqt | cut -d| -f1 | grep -w inout_db || echo "inout_db 없음 — 새로 만든다"
read -s -p "inout_app password: " APP_PWD; echo
docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/inout_db_init.sql
ENC=$(APP_PWD="$APP_PWD" python3 -c "import os,urllib.parse;print(urllib.parse.quote(os.environ['APP_PWD'],safe=''))")
# .env 끝에 줄바꿈이 없으면 앞 줄에 붙으므로 printf 로 새 줄부터, 이미 있으면 그 줄을 바꾼다
grep -q "^INOUT_DB_URL=" .env && sed -i "s|^INOUT_DB_URL=.*|INOUT_DB_URL=postgresql://inout_app:${ENC}@postgres-db:5432/inout_db|" .env \
|| printf '\nINOUT_DB_URL=postgresql://inout_app:%s@postgres-db:5432/inout_db\n' "$ENC" >> .env
docker compose up --build -d --force-recreate web
docker exec dbx-main python -c "import os,psycopg; psycopg.connect(os.environ['INOUT_DB_URL']).execute('select 1 from inout_roles limit 1'); print('DB OK')"
curl -s http://127.0.0.1:8080/inout/health # {"status":"ok"} — DSN 이 있다는 뜻일 뿐, 실제 연결 확인은 위 DB OK
```
그다음 ERP 관리자 화면에서 쓸 사람에게 **입출고 관리** 권한 → 입출고 관리 → 옵션에서 공장·발주 담당·입고 담당 지정.
백업: 매일 `docker exec postgres-db pg_dump -U postgres inout_db > /var/backups/postgres/inout_db_$(date +%F).sql`.
## 연간 목표 주차별 매출 목표 두 칸 마이그레이션 (project_db 030)
030은 `goal_week_targets` 에 `value_dist`(유통·인플)·`value_mall`(카페24·네이버) 열만 추가한다(다시 실행 가능, 기존 값 변경 없음, 새 환경변수 없음).
`value`(주차 합계)는 그대로 쓰므로 회의록 누적 목표는 바뀌지 않는다. 미적용이면 주차 입력 창이 예전처럼 한 칸.
```bash
cd /opt/www/main && git pull && docker exec postgres-db pg_dump -U postgres project_db > ~/project_db_before_030_$(date +%Y%m%d%H%M).sql && docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d project_db < scripts/sql/project_db_030_week_target_split.sql && docker compose up --build -d --no-deps web
```
## 입출고 관리 물류센터 이메일·입고 요청 메일 마이그레이션 (inout_db 005)
005는 표 2개만 추가한다 — `inout_settings`(모듈 설정: 물류센터 담당자 이메일·입고 요청 메일 참조, 참조 기본값 `king@dbxcorp.co.kr, bj@dbxcorp.co.kr` 한 줄 넣음)·
`inout_receipt_mails`(입고 요청 메일 보낸 기록, 입고를 지우면 함께). 다시 실행 가능, 기존 데이터 변경 없음, 새 환경변수 없음(Gmail 은 003 과 같은 연결).
미적용이어도 입고·발주는 그대로 — 입고 요청 메일 미리보기·발송은 되지만(받는 사람 직접 입력) 옵션 → 물류센터 저장과 보낸 기록만 안 됨.
적용 뒤 옵션(톱니) → **물류센터** 탭에 물류센터 담당자 이메일을 넣는다. 입고 담당도 처음 한 번 [Gmail 연결]이 필요하다.
```bash
cd /opt/www/main && git pull && docker exec postgres-db pg_dump -U postgres inout_db > ~/inout_db_before_005_$(date +%Y%m%d%H%M).sql && docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d inout_db < scripts/sql/inout_db_005_receipt_mail.sql && docker compose up --build -d --no-deps web
```
## 입출고 관리 상품 정보 마이그레이션 (inout_db 004)
004는 표 2개(`inout_products` 상품 정보 — 단가·무게(개당 g)·은 함유량(%), `inout_products_excluded` 지운 단품)와
`inout_order_lines` 의 `unit_price`·`weight_g`·`silver_pct` 열(발주할 때 값 사본)을 추가한다. 다시 실행 가능, 기존 데이터 변경 없음, 새 환경변수 없음.
적용 뒤 옵션(톱니) → 상품 정보 → [단품 불러오기] 를 한 번 누르면 그때부터 발주서 제품은 그 목록에서 고른다.
```bash
cd /opt/www/main && git pull
docker exec postgres-db pg_dump -U postgres inout_db > ~/inout_db_before_004_$(date +%Y%m%d%H%M).sql
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d inout_db < scripts/sql/inout_db_004_products.sql
docker compose up --build -d web
```
## 입출고 관리 발주 메일·입고증 사진 마이그레이션 (inout_db 003)
003은 공장 이메일 열, Gmail 연결(토큰 암호문)·발주 메일 기록·입고증 사진 표만 추가한다(다시 실행 가능, 기존 값 변경 없음).
미적용이어도 발주·입고는 그대로(사진·메일만 안내). 발주 메일은 **구글 클라우드 준비(관리자 1회)**가 필요하다 — `docs/INOUT_MODULE.md` 6-1:
Gmail API 사용 · OAuth 동의 화면에 `…/auth/gmail.send` 범위 · 로그인용 OAuth 클라이언트에 리디렉션 URI `{PUBLIC_BASE_URL}/inout/gmail/callback`.
새 환경변수 없음(`APP_ENCRYPTION_KEY`·`GOOGLE_CLIENT_ID/SECRET`·`PUBLIC_BASE_URL` 재사용).
```bash
cd /opt/www/main
docker exec postgres-db pg_dump -U postgres inout_db > ~/inout_db_before_003_$(date +%Y%m%d%H%M).sql
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d inout_db < scripts/sql/inout_db_003_mail_photos.sql
grep -c "^APP_ENCRYPTION_KEY=" .env # 1 이어야 Gmail 연결 저장 가능
```
## 입출고 관리 공장 담당자 마이그레이션 (inout_db 002)
002는 `inout_factories.manager`(담당자) 열만 추가한다(다시 실행 가능). 예전 "담당자·연락처" 한 칸에 숫자 없이 이름만 있던 값은 담당자로 옮긴다.
미적용이면 공장 저장만 안내(발주·입고는 그대로).
```bash
cd /opt/www/main
docker exec postgres-db pg_dump -U postgres inout_db > ~/inout_db_before_002_$(date +%Y%m%d%H%M).sql
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d inout_db < scripts/sql/inout_db_002_factory_manager.sql
docker exec postgres-db psql -U postgres -d inout_db -c "SELECT name, manager, contact FROM inout_factories ORDER BY id;"
```
## 긴급 공지 마이그레이션 (024)
024는 `urgent_notices`·`urgent_notice_targets`·`urgent_notice_acks`·`urgent_notice_images` 테이블만 추가한다(기존 값 그대로, 다시 실행 가능).
@@ -356,6 +463,7 @@ docker compose down # 컨테이너 제거 (볼륨 유지)
| `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) |
| `INOUT_DB_URL` | 입출고 관리 DB DSN (예: `postgresql://inout_app:<pwd>@postgres-db:5432/inout_db`). 미설정 시 입출고 모듈 비활성(설정 필요 안내). 권한키 `inout`. 제품은 `ITEMCODE_DB_URL`(단품) 재사용 |
---
+219
View File
@@ -0,0 +1,219 @@
# 입출고 관리(inout) 모듈
> `app/modules/inout/` · DB `inout_db` · URL `/inout/` · 권한키 `inout` · 2026-10-16 신설
본사가 공장에 **제품 제작 발주**를 넣고, 공장 물건이 **물류에 입고**될 때마다 입고 수량을 입력해서
발주한 제품이 다 들어왔는지, **미입고**(덜 들어옴)·**초과 입고**(더 들어옴)가 있는지 관리한다.
## 1. 참고한 상용 프로그램
| 프로그램 | 가져온 것 |
|---|---|
| 이카운트 ERP | 입고(구매입력)를 **발주서를 불러와서** 처리(발주번호 + 품목코드가 기준), **발주 대비 미입고 현황**(거래처별·품목별) |
| Odoo | 한 발주를 **여러 번 나눠 입고**, 덜 들어온 잔량은 "나중에 받기" 또는 **"더 안 받음(종결)"** 선택, 초과 입고는 확인 후 허용 |
## 2. 흐름과 상태
```
발주(open) ──입고 일부──▶ 부분입고(partial) ──남은 것 다 입고──▶ 입고완료(done)
│ │ └─발주보다 많이──▶ 초과입고(over)
│ └─[잔량 종결]──▶ 종결(closed) ─[종결 풀기]─▶ 원래 상태
└─[발주 취소](입고 기록 없을 때만)──▶ 취소(cancelled)
```
- 상태는 **저장하지 않고** 품목별 누적 입고로 계산한다(`store.order_status`, `store.line_status`) — 어긋날 수 없다.
- 품목 상태: 미입고 / 부분입고 / 입고완료 / 초과입고. 발주서는 하나라도 남으면 부분입고(초과가 섞여 있어도).
- **모든 품목이 입고완료 또는 초과입고**(발주서 done·over)면 목록·발주서 머리에 초록 **"✓ 전체 입고 완료"**, 초과가 있으면 옆에 빨강 "초과 포함"
(`_macros.html order_badge`, 2026-10-17 요청). 품목 줄의 초과입고 배지는 그대로 빨강.
- **날짜 서식은 모두 `yyyy.mm.dd(요일)`** — 예 `2026.10.17(토)`, 시각이 있으면 `2026.10.17(토) 15:14`(화면 `_macros.html ymd·ymdhm`,
메일·JSON `store.fmt_date·fmt_datetime`, 2026-10-17 요청). 날짜 입력 칸(달력)은 브라우저 모양 그대로.
- **미입고 현황**(`/inout/pending`)은 종결·취소가 아닌 발주의 남은 수량만 — 제품별 합계, 발주별(입고 예정일 순, 지난 것 빨강), 초과 입고 목록.
- **초과 입고**: 입고 저장 때 발주를 넘는 품목이 있으면 저장하지 않고 확인 화면(409, 넣은 숫자 유지) → [초과 입고로 저장](`confirm_over=1`).
판단은 DB 트랜잭션 안에서 발주서 행을 잠그고(`FOR UPDATE`) 누적 입고를 다시 읽어 한다 — 동시에 입고해도 확인을 건너뛰지 않음.
Enter 키는 숨은 기본 버튼(일반 저장)으로 가게 해 확인 없이 초과가 저장되지 않게 했다.
- **[남은 수량 모두 채우기] 되돌리기**(2026-10-19 요청): 누르면 빈 칸만 남은 수량으로 채우고 버튼이 [채운 수량 되돌리기](초록)로 바뀐다 —
한 번 더 누르면 채우기 직전 값으로 모두 되돌림(채운 뒤 손으로 고친 칸도). 채울 칸이 없으면 그대로.
- **전체 입고 완료 뒤 입고 막기**(2026-10-19 요청): 모든 품목이 입고완료·초과(발주서 done·over)면 품목 머리에 "✓ 전체 입고 완료 — 더 입고할 수 없습니다",
이번 입고 칸·입고일·메모·사진·[남은 수량 모두 채우기]·[입고 저장]·숨은 기본 버튼을 `disabled` + 흐리게(`.io-receipt-bar.is-locked`).
서버도 `_add_receipt` 에서 발주서를 잠근 뒤 모든 품목 누적 입고 ≥ 발주면 ValueError(초과 확인을 해도) — 두 창에서 동시에 넣어도 막힘.
잘못 넣은 입고는 입고 기록에서 지우면 다시 입고할 수 있다. 입고 기록의 사진 더하기·입고 요청 메일·사방넷 파일은 그대로.
- 발주서 고치기: 입고된 품목은 **뺄 수 없다**(입고 기록이 사라지므로) — 수량은 바꿀 수 있다(입고보다 줄이면 초과로 보임).
- 입고 기록 지우기(입고 담당): 잘못 넣은 1건을 지우면 그만큼 다시 미입고.
- 발주번호: `PO-YYMMDD-NN`(발주일 기준 그날 순번, advisory lock 으로 동시 생성해도 겹치지 않음). 순번은 숫자로 비교한다 — 100번째부터 세 자리(`-100`).
- 시각(입력·보낸·종결 시각 등)은 DB 서버 시간대와 무관하게 **한국 시각** — 연결마다 TIMESTAMPTZ 를 KST 로 읽는다(`db._KstTimestamptzLoader`).
## 3. 권한·담당자
| 누구 | 할 수 있는 것 |
|---|---|
| 모듈 권한 `inout` | 발주 목록·발주서·미입고 현황 조회 |
| **발주 담당**(옵션에서 지정) | 발주서 작성·고치기·잔량 종결/풀기·취소 |
| **입고 담당**(옵션에서 지정) | 입고 수량 입력·입고 기록 지우기. 발주 담당이 아니면 발주서 품목은 **제품 이름·발주 수량**(+ 이번 입고 칸)만 보인다 — 코드·입고·미입고·상태·단가·금액 숨김, 입고 기록 칩도 이름(2026-10-16 요청) |
| **수퍼관리자**(`SUPER_ADMIN_EMAIL`) | 위 전부 + 발주 목록 줄 끝 🗑 **발주 삭제**(`POST /inout/orders/{id}/delete`) — 확인 후 품목·입고 기록·입고증 사진·발주 메일 기록까지 완전히 지움(CASCADE, 되돌릴 수 없음), 서버 로그에 남김, 보던 목록(거르기)으로 돌아감(2026-10-17) |
| ERP 관리자(`role=admin`) | 위 전부 + **옵션**(공장 목록·담당자·상품 정보) — 상단 오른쪽 **톱니** → 팝업. 입고 담당·발주 담당은 옵션을 못 본다 |
담당자 후보 = ERP 관리자 화면에서 `inout` 권한을 받은 사용자. 권한이 빠졌는데 담당으로 남은 사람도 옵션에 보여서 뺄 수 있다.
담당은 `inout_roles(email, role)` — role `order`(발주)·`receive`(입고).
## 4. 제품 = 코드표 단품
발주 품목은 `itemcode_db.single_items`(단품)에서만 고른다(세트 아님) — `itemcode.py SingleItemReader`(읽기 전용, `ITEMCODE_DB_URL` 재사용,
cupang·malaysia 와 같은 DSN). 화면에서 코드·이름으로 검색(`GET /inout/api/items?q=`, 코드 앞부분 일치 먼저 30개),
저장할 때 서버가 다시 코드표에 있는지 확인(`lookup`) — 없으면 "코드표 단품에 없는 제품". 발주 줄에는 코드·**발주 당시 이름** 사본을 둔다.
이미 발주서에 있던 코드는 나중에 코드표에서 빠져도 그대로 고칠 수 있다. 코드표 연결이 안 되면 새 제품을 넣는 저장만 막힌다(안내 문구).
**옵션 → 상품 정보에 단품을 한 번이라도 불러오면** 그때부터 발주서 제품은 그 목록에서만 고른다(지운 단품 제외, 단가 함께) — 6-3.
## 5. 화면
| 주소 | 내용 |
|---|---|
| `/inout/` | 발주 목록 — 상태(진행 중·완료·종결·취소·전체)·공장·발주일 기간·검색(발주번호·제품 코드·이름), 진행률 막대, 지연 표시 |
| `/inout/pending` | 미입고 현황 — 요약 숫자, 제품별 합계, 발주별, 초과 입고 |
| `/inout/orders/new`, `/{id}/edit` | 발주서 폼 — 공장·발주일·입고 예정일·메모, 제품 줄(검색 드롭다운·수량·**단가·금액**·줄 메모), 합계(수량·종·금액) |
| `/inout/orders/{id}` | 발주서 — 품목별 발주·(발주 담당) **단가·금액·PP(g/개)·은(Ag)** ·입고·미입고·상태 + 합계 줄(금액·PP kg·은 g), **이번 입고** 칸(입고 담당) + [남은 수량 모두 채우기], 입고 기록, 종결·취소. 입고 담당만이면 이름·발주 수량만 |
| 톱니 → 옵션 팝업 | 관리자만. 탭 **담당자**(발주·입고 체크) · **공장**(이름·담당자·연락처·메모·순서·사용, 발주 기록 없을 때만 지우기) · **상품 정보**(6-3) · **물류센터**(6-4). 내용은 `GET /inout/settings?panel=1`, 저장은 팝업 안에서(`X-Inout-Options: 1` → JSON, 같은 탭 그대로 다시 그림), 바뀐 게 있으면 닫을 때 화면 새로고침. 예전 주소 `/inout/settings` = 목록으로 가서 팝업(`?options=1`) |
화면은 서버 폼(POST → 303 + `?msg=` 안내). `static/inout.js` 는 입력 보조만(제품 검색 드롭다운 — `position: fixed` 로 body 에 붙여
표 가로 스크롤에 잘리지 않음, 줄 추가·삭제·합계, 남은 수량 채우기, 버튼별 확인 `data-erp-confirm-btn`).
공용 스타일과 겹치는 것 — 이 모듈 안에서만 바로잡는다(공용 파일은 그대로):
`.erp-page` 가 content-box 라 넓은 표에서 48px 넘침 → `.erp-page:has(> .io) { box-sizing: border-box }`;
`.erp-input` 이 min-width 240px + content-box 라 좁은 칸에서 옆 칸을 덮음, `.erp-table-wrap` 이 카드 모양(그림자·둥근 모서리)이라 카드 안에서 상자가 겹쳐 보임
→ `.io`·`.io-dlg` 안은 border-box·최소폭 없음·카드 안 표는 평평하게(2026-10-16 옵션 화면 겹침). 공장 표는 진짜 `<table>` + 입력칸 `form="…"` 속성(줄마다 표 밖 폼)으로 열을 맞춘다.
## 6. DB (`inout_db`, `scripts/sql/inout_db_init.sql`)
| 표 | 내용 |
|---|---|
| `inout_factories` | 공장 — 이름(대소문자 무시 유일)·담당자(`manager`, 002)·연락처(`contact`)·이메일(`email`, 003)·메모·사용·순서 |
| `inout_gmail_tokens` | 사람별 Gmail 연결 — 갱신 토큰 **암호문**만(003) |
| `inout_order_mails` | 발주 메일 보낸 기록(003) |
| `inout_receipt_photos` | 입고증 사진(bytea, 003) |
| `inout_roles` | 담당자 — (email, role: order/receive) |
| `inout_orders` | 발주서 — 번호·공장·발주일·입고 예정일·메모·종결(시각·사람·사유)·취소 |
| `inout_order_lines` | 발주 품목 — 단품 코드·이름 사본·수량·줄 메모, 발주서 안에서 코드 유일. 004: 발주할 때의 `unit_price`·`weight_g`·`silver_pct` 사본 |
| `inout_products` | 상품 정보(004) — 코드표에서 불러온 단품 + 단가(원)·무게(개당 g = PP량)·은(Ag) 함유량(%) |
| `inout_products_excluded` | 상품 정보에서 지운 단품(004) — 다음 불러오기에서 빠진다 |
| `inout_receipts` | 입고 1건(한 번 들어온 것) — 입고일·메모·입력자 |
| `inout_receipt_lines` | 입고 품목별 수량 |
| `inout_settings` | 모듈 설정(005) — `logistics_emails`(물류센터 담당자 이메일)·`receipt_mail_cc`(입고 요청 메일 참조) |
| `inout_receipt_mails` | 입고 요청 메일 보낸 기록(005, 입고 1건마다, 입고 지우면 CASCADE) |
마이그레이션 `inout_db_002_factory_manager.sql`(2026-10-16): `manager` 열 추가, 예전 한 칸에 숫자 없이 이름만 있던 값은 담당자로 옮김(숫자가 있으면 연락처로 둠).
002 미적용이어도 발주서 화면은 열리고(담당자 = `to_jsonb(f)->>'manager'`), 공장 저장만 "002 필요" 안내.
앱 계정 `inout_app` 은 SELECT/INSERT/UPDATE/DELETE + 시퀀스만. 초기화는 멱등(DROP·TRUNCATE 없음). 백업 권장: 매일 `pg_dump inout_db`.
## 6-1. 발주 메일 — 발주 담당자 본인 Gmail(2026-10-16, 마이그레이션 003)
- **받는 사람** = 옵션 → 공장 **이메일**(`inout_factories.email`, 여러 개는 쉼표). 발주서 화면에서 바꾸거나 참조를 더할 수 있다.
- **입고 담당 발주 알림**(2026-10-19 요청): [메일 발송]으로 공장 메일이 나가면 **같은 Gmail** 로 입고 담당(옵션 → 담당자 `inout_roles` receive, ERP 관리자는 자동 포함 안 함)에게
별도 메일을 자동 발송 — 제목 = 발주 메일과 같음, 본문 = 발주번호·발주일 + 표(제품 코드·제품명·수량, 합계)만(단가·무게·은 없음, `store.order_notice_mail`).
다시 보내기 때도 함께 간다. 알림 실패·입고 담당 없음은 공장 메일을 막지 않고 결과 문구에만("입고 담당 n명에게 발주 알림 메일도 보냈습니다" / 실패 이유),
기록은 공장 메일 한 건(`inout_order_mails`). 미리보기 창에 "메일 발송 시 입고 담당(…)에게 발주 알림 메일이 따로 자동 발송됩니다" 안내(`notice_to`).
- **참조 기본값**(2026-10-19 요청) = `king@dbxcorp.co.kr` — 미리보기 참조 칸에 미리 들어간다. 옵션 → 공장 탭 위 **발주 메일 참조**에서 바꾼다
(`POST /inout/settings/order-mail`, `inout_settings` 키 `order_mail_cc` — 행이 없으면 `store.SETTING_DEFAULTS` 값, 저장은 005 필요).
- **흐름**: 새 발주서를 저장하면 발주서 화면이 `?mail=1` 로 열려 **메일 미리보기 팝업**이 바로 뜬다(받는 사람·제목·본문).
사람이 **[메일 발송]**을 눌러야만 보낸다(자동 발송 없음). 머리 **[발주 메일 보내기 / 다시 보내기]**로 언제든 다시 연다.
- **본문**(`store.order_mail`) = 인사(공장 담당자 이름) · 발주번호·발주일·입고 예정일·품목 수·총수량·요청 사항(메모) 표 ·
품목 표(No·제품 코드·제품명·수량·비고, 합계) · 보낸 사람. HTML + 글 본문(둘 다), 값은 모두 escape. 제목 `[발주] {번호} · {공장} · {첫 품목} 외 n종`.
- **보내는 계정** = 누른 사람(발주 담당)의 Gmail — Gmail API `users.messages.send`(`gmail.py`).
사람마다 처음 한 번 **[Gmail 연결]**: 구글 동의 화면(로그인과 같은 OAuth 클라이언트, 범위 `openid email gmail.send` 만, `hd=` 회사 도메인,
`login_hint` = ERP 계정) → `/inout/gmail/callback` 에서 **고른 구글 계정 = ERP 로그인 계정**인지(다르면 거절), gmail.send 허락·갱신 토큰 확인 →
갱신 토큰을 `APP_ENCRYPTION_KEY`(실적 모듈과 같은 마스터 키, AES-256-GCM, AAD `inout:gmail:{email}`)로 암호화해 `inout_gmail_tokens`.
원문·접근 토큰은 저장·출력하지 않는다. 연결 끊기 = 구글 권한 취소(revoke) + 토큰 삭제.
- **기록**: `inout_order_mails`(보낸 사람·받는 사람·참조·제목·Gmail id·시각) — 머리 "발주 메일: 보냄 MM-DD HH:MM … · 모두 n번".
이미 보낸 발주서는 `resend: true` 를 같이 보내야 한다(409 → 화면이 "다시 보낼까요?" 확인) — 실수로 두 번 안 가게.
- **오류**: 구글이 연결을 끊었으면(invalid_grant·권한 없음) 토큰을 지우고 "다시 연결" 안내, Gmail API 꺼짐은 관리자 안내, 그 밖은 구글 문구.
- **권한**: 미리보기·발송·연결 = 발주 담당(관리자 포함). 취소된 발주서는 보낼 수 없다.
### 구글 클라우드 준비(관리자 1회 — 로그인에 쓰는 OAuth 클라이언트가 있는 프로젝트)
1. **API 및 서비스 → 라이브러리 → Gmail API → 사용**.
2. **OAuth 동의 화면 → 범위(데이터 액세스) → 범위 추가**: `https://www.googleapis.com/auth/gmail.send`
(사용자 유형이 **내부**(Workspace)면 구글 심사 없이 바로 쓸 수 있다).
3. **사용자 인증 정보 → 로그인용 OAuth 2.0 클라이언트 → 승인된 리디렉션 URI 추가**: `{PUBLIC_BASE_URL}/inout/gmail/callback`
(예: `https://dbx.no1king.freeddns.org/inout/gmail/callback`).
4. 서버 `.env` 에 `APP_ENCRYPTION_KEY`(실적 모듈과 같은 키)·`GOOGLE_CLIENT_ID/SECRET`·`PUBLIC_BASE_URL` 이 있어야 한다(새 변수 없음).
## 6-2. 입고증 사진(2026-10-16, 마이그레이션 003)
- 입고 담당이 **입고 저장 때** [입고증 업로드](2026-10-19 이름 변경 — 예전 "사진 고르기·찍기", 여러 장, 휴대폰은 카메라) — 브라우저가 긴 변 2000px JPEG 로 줄여 올린다
(4032×3024 7.9MB → 2000×1500 약 0.8MB, 줄인 게 더 크면 원본, HEIC·GIF 는 그대로). 입고 한 건에 **10장**, 한 장 **10MB**까지.
- 서버는 파일 머리로 종류를 판단(`store.sniff_image` — JPG·PNG·WEBP·GIF·HEIC, SVG·PDF 등 거절)하고 **입고와 한 트랜잭션**으로
`inout_receipt_photos`(bytea — 백업에 함께)에 넣는다 — 사진이 틀리면 입고도 저장 안 함, 초과 확인에 막혀도 사진 저장 안 함.
- 초과 입고는 **브라우저가 먼저 확인**한다(저장 전 확인 창 → `confirm_over=1`) — 서버 확인 화면으로 돌아가면 고른 파일이 사라지기 때문.
그래도 서버까지 가서 막히면(동시 입고 등) "사진은 다시 첨부" 안내.
- 입고 기록 **입고증** 칸 = 썸네일(누르면 크게 보기 — ←/→ 넘기기, [원본], [지우기](입고 담당)) + **[+]** 로 나중에 더하기.
입고 기록을 지우면 사진도 함께 지워진다(CASCADE).
- 보기 `GET /inout/photos/{id}` — 모듈 권한자, `X-Content-Type-Options: nosniff`·CSP sandbox, HEIC 는 내려받기(브라우저가 못 보여 줌).
## 6-3. 상품 정보 — 단가·무게(PP)·은 함유량(2026-10-16, 마이그레이션 004)
- 옵션 팝업 세 번째 탭 **상품 정보**(관리자만). **[단품 불러오기]** = 코드표(`itemcode_db.single_items`) 단품 전체 → `inout_products`
(`itemcode.list_all`, `POST /inout/settings/products/import`).
- 새 단품은 추가, **값(단가·무게·은 함유량 중 하나라도)을 넣은 상품은 그대로**(이름도), 값이 없는 상품은 이름만 최신으로.
- **지운 단품**(제외 목록 `inout_products_excluded`)은 건너뛴다. 코드표에서 빠진 단품을 지우지는 않는다.
- 표: 코드·제품명·**단가(원)**·**무게·PP(g/개)**·**은 함유량(%)**·은(g/개) = 무게 × % ÷ 100(자동, 화면에서 바로 계산).
찾기 칸, 바뀐 줄은 노랗게 + **[변경 저장 (n)]**(`POST …/products/save`, 바뀐 줄만, 하나라도 틀리면 아무것도 저장 안 함),
저장 안 하고 닫거나 다시 불러오면 확인. 빈칸 = 미입력. 단가 소수 둘째·무게 둘째·함유량 넷째 자리까지(넘치면 사사오입), 함유량 0~100%.
- 사용자 확인(2026-10-16): 요청의 "PP함유량" = **은(Ag) 함유량(%)**, "PP량" = 무게(**개당 g**).
- 줄 오른쪽 ✕ = 지우기(`…/products/{code}/exclude`) — 목록·발주서 고르기에서 빠지고 제외 목록에 남는다. 아래 **제외 목록**에서 [되살리기](`…/restore`, 값은 빈칸).
지난 발주서는 그대로.
- **발주서**: 상품 정보가 하나라도 있으면 제품 검색·저장 확인이 상품 정보 기준(없는 코드 = "상품 정보에 없는 단품", 그 전에는 코드표).
저장할 때 **그때 값의 사본**을 발주 품목에 남긴다(`_insert_line`) — 나중에 단가를 바꿔도 지난 발주서·메일은 그대로.
고치기에서 새로 넣은 줄만 지금 값, 원래 있던 줄은 사본 유지. 004 전 발주서는 단가 칸이 "-".
- **금액** = 수량 × 단가(`store.line_amount`), 합계는 단가 있는 줄만(없는 줄 수 표시), PP 총량(kg) = Σ 무게 × 수량, 은 총량(g) = Σ 무게 × % × 수량
(`store.order_totals`, 개당 은 g 를 반올림하기 전 값으로 곱함).
- **발주 메일 본문**(6-1)에 발주 금액·전체 무게·PP 사용량·은(Ag) 총량 줄과 품목 표 **단가(원)·금액(원)·전체 무게(kg)·PP 사용량(kg)·은(Ag) 함유량(% (kg))**, 합계 줄.
- 2026-10-19 사용자 요청으로 바꿈(예전 = PP(g/개)·개당 은 g): **전체 무게** = 개당 무게 × 수량(kg) · **PP 사용량** = 전체 무게 − 은 무게(은 함유량 바로 왼쪽 열) ·
**은 함유량** 괄호 = 전체 무게 × %(kg, 소수 넷째까지). 예: 5,000개 × 51g = 255kg, 은 30% (76.5kg), PP 사용량 178.5kg.
합계 줄 PP 사용량 = 무게·은 함유량이 다 있는 줄만(`order_totals` `pp_use_kg`).
첫 요약 표(발주번호·발주일·입고 예정일·품목·발주 금액·전체 무게·PP 사용량·은 총량)는 **항목·값 두 쌍씩 한 줄 = 4열 × 4행**(같은 날 요청, 예전 2열 × 8행),
칸 수가 홀수면 마지막 쌍은 빈 칸, **요청 사항**(메모, 길 수 있음)은 맨 아래 한 줄 전체(`colspan=3`).
받은 메일에서 이 표 칸이 크게 늘어나 보여(같은 날) 칸마다 `font-size:14px;line-height:20px;height:20px;padding:4px 10px` 로 못 박고(요청 사항 칸은 높이 고정 없음),
두 표 사이는 표 margin 대신 높이 18px 빈 줄(`<div style="height:18px;line-height:18px;font-size:1px">`) — 메일 프로그램이 표 margin 을 무시하기도 해서. 글 본문(HTML 못 보는 메일 프로그램용)도 같은 값. 발주서 화면 표는 그대로.
- 004 미적용이면 탭에 "마이그레이션 004 필요" 안내, 발주서는 예전처럼 코드표에서(`products_ready`).
## 6-4. 입고 요청 메일 — 물류센터 전산 등록 부탁(2026-10-19, 마이그레이션 005)
- **왜**(사용자 요청): 물류에 들어온 입고를 물류센터 입고 담당자가 전산에 등록하도록, 입고 담당이 입고를 저장하면 메일로 알린다.
- **옵션 → 물류센터 탭**(관리자): 물류센터 담당자 이메일(받는 사람, 여러 개 쉼표)·입고 요청 메일 참조(기본 `king@dbxcorp.co.kr, bj@dbxcorp.co.kr` — 005 가 넣음).
`POST /inout/settings/logistics`, 주소 검사(`store.clean_emails`), `inout_settings` 키·값. 005 미적용이면 탭에 안내·저장 버튼 꺼짐.
- **흐름**: 입고 담당이 [입고 저장] → `/inout/orders/{id}?rmail={입고 id}` 로 돌아오며 **미리보기 팝업이 바로 뜬다**(발주 메일과 같은 창 모양, `inout.js initMail` 공용).
사람이 **[메일 발송]**을 눌러야 보낸다. 입고 기록 표의 **입고 요청 메일** 칸 = 마지막 보낸 시각·사람 + [보내기 / 다시 보내기](입고 담당).
이미 보낸 입고는 `resend: true` 확인(409 → "다시 보낼까요?").
- **보내는 계정** = 누른 사람(입고 담당)의 Gmail — 발주 메일과 같은 연결(`inout_gmail_tokens`). Gmail 연결(`/inout/gmail/connect·callback`) 권한을
발주 담당만 → **발주 담당 또는 입고 담당**으로 넓혔다(`_require(…, "mail")`). 연결 후 돌아오는 곳 = 그 입고의 메일 창(`?rmail=`).
- **제목** `[입고 요청] 2026년 10월 19일(월) 입고 요청 합니다.` — 입고일, 월·일 두 자리(`store.receipt_mail_subject`).
- **본문**(`store.receipt_mail`) = 인사 · "입고된 아래 리스트 상품을 전산 등록 부탁드립니다." · 입고일·발주번호·공장 한 줄 ·
표 **상품 이름 · 상품 코드 · 입고 수량 · 비고**(비고 = 그 발주 품목의 줄 메모) + 합계 · 입고 메모 · **맨 아래 입고 인증 사진** · 입고 담당.
HTML + 글 본문, 값은 모두 escape.
- **사진 = 본문 안 이미지(첨부 아님)**: 보낼 때 `gmail.build_message(inline_images=)` 가 HTML 쪽을 `multipart/related` 로 만들고 사진을
`Content-ID` + `Content-Disposition: inline`(파일 이름 없음)으로 붙인다 → `<img src="cid:inout-photo-{id}@dbx">`. Gmail·Outlook 은 본문 안에 그린다
(data: URI 는 Gmail 이 막아서 쓰지 않음). 크기는 서버가 **가로 최대 600px, 세로는 비율대로** JPEG(품질 85)로 다시 만든다(`store.mail_images` —
Pillow, EXIF 회전 반영, 투명 PNG 는 흰 바탕, 큰 JPEG 는 draft 로 빨리 읽음). img 에도 width·height 를 적는다. HEIC 등 서버가 못 여는 사진은 빼고
"본문에 넣지 못한 사진 n장" 안내(입고 기록 사진은 그대로). 10장 × 600px ≈ 1MB 안팎이라 Gmail API 요청 크기 걱정 없음.
- **미리보기**(`GET …/receipts/{rid}/mail`)는 cid 를 data: 로 바꾼 HTML(`store.inline_preview_html`)을 sandbox iframe 에 — 보내는 메일은 cid 그대로.
- **권한**: 미리보기·발송 = 입고 담당(관리자 포함). 발주 담당만인 사람은 403.
- **005 미적용**: 미리보기·발송은 되고(받는 사람은 직접 입력, 참조는 기본값), 보낸 기록·옵션 저장만 안 됨(창에 안내).
## 6-5. 사방넷 입고 파일(2026-10-19, 마이그레이션 없음)
- 입고 기록 표 **입고 요청 메일 · 사방넷** 칸의 **[사방넷 입고 파일]**(엑셀 초록 버튼, 발주 담당·입고 담당) → 그 입고 1건의 엑셀(`GET …/receipts/{rid}/sabangnet.xlsx`).
- 시트 1행 = 제목 **상품코드 · 가용수량 · 불용수량**(굵게·회색 바탕), 2행부터 입고 품목마다
A = 코드표(itemcode_db `single_items.sabangnet_code`, `itemcode.SingleItemReader.sabangnet_codes`) 사방넷 코드,
B = 입고 수량, **C = 상품 이름**(사용자 요청 — 불용수량 칸이지만 수량이 아니라 이름). A·C 는 글자 서식(`@`, 앞자리 0 보존), 열 너비는 내용 길이로.
- 사방넷 코드가 빈 단품이 하나라도 있으면 파일을 만들지 않고 발주서로 돌아가 "코드표에 사방넷 코드가 없는 상품: …"(빈 상품코드로 사방넷에 올리는 실수 방지),
코드표 연결이 안 되면 그 이유를 안내. 파일 이름 `사방넷_입고_YYYYMMDD_{발주번호}.xlsx`(입고일). `store.sabangnet_rows·sabangnet_xlsx·sabangnet_filename`.
## 7. 테스트
```bash
python -m pytest tests/test_inout_store.py tests/test_inout_mail_photo.py tests/test_inout_receipt_mail.py tests/test_inout_web.py # DB 없이(상태·검사·메일 본문·Gmail·사진·입고 요청 메일)
INOUT_TEST_DB_URL=postgresql://inout_app:<pw>@127.0.0.1:5432/inout_db \
python -m pytest tests/test_inout_db.py tests/test_inout_web.py # 로컬 테스트 DB(초기화 SQL 적용, 앱 계정 — 권한도 확인)
```
DB 테스트: 분할 입고·완료, 초과 확인, 미입고·종결·풀기·취소, 고치기(입고 품목 보호), 입고 지우기, 동시 발주번호, 담당자·공장,
시각 KST, 상품 정보(불러오기 유지·이름 갱신·제외·되살리기, 발주 품목 값 사본 — 끝나면 테스트 단품을 지워 목록을 처음 상태로).
화면 흐름 테스트: 옵션 → 발주 담당 발주(코드표 아닌 제품 거부) → 입고 담당 분할·초과 확인 → 미입고 현황 → 종결, 권한별 403,
상품 정보(관리자만·저장 검사·다시 불러와도 값 유지·지우기) → 단가로 발주 → 금액·PP·은 화면·메일 → 입고 담당은 이름·발주 수량만.
+73 -2
View File
@@ -40,6 +40,13 @@
**카페24 관리자 "일별 매출내역"과 같은 기준**으로 센다(처음의 품목 결제금액 방식은 배송비가 빠지고 환불 날짜 기준이 달라
화면과 맞지 않아 교체).
> **2026-10-19 규칙 변경 — 적립금 제외**(사용자 요청): 매출(SALE) = 결제합계 **− 적립금 사용**(`initial_order_amount.points_spent_amount`),
> 환불 = 실제 환불액 + 예치금 환불(**적립금으로 돌려준 `used_points` 는 뺌** — 결제에서 뺐으니 앞뒤를 맞춤, 사용자 선택).
> 그래서 카페24 열은 이제 카페24 일별 매출내역의 결제합계·환불합계보다 적립금만큼 작다(아래 표·대조 설명은 그 전 기준).
> 사건 raw 에 `points`(결제 = 사용 적립금, 환불 = −돌려준 적립금)·`points_excluded: true`. 주문 내역 창에 **적립금 사용** 칸 + 합계
> (맨 아래 = 결제 쪽 합, 환불이 있으면 "환불 −n" 따로). 사용자 확인값: 10/18 적립금 사용 16,820원.
> 규칙을 바꾸기 전에 받은 날은 [과거 매출 가져오기]로 다시 받아야 바뀐다(최근 10일은 자동 업데이트가 다시 받음).
| 사건 | 조회 | 금액·날짜 |
|---|---|---|
| SALE(결제합계) | `GET /admin/orders` `date_type=pay_date`, `embed=items`, `paid=T` | +(실결제금액 + 적립금 + 예치금 + 네이버포인트), `initial_order_amount` + 주문 `naver_point`(결제 당시 금액 — 환불을 따로 빼므로 취소 후 금액 X), 결제일. 주문 1건 = 사건 1건(`{order_id}-PAY`) |
@@ -122,6 +129,23 @@
할인 = `productDiscountAmount` 합. 결제 뒤 취소·반품(`CANCELED`·`RETURNED`)도 포함, 입금대기·미입금 취소만 뺀다
→ 지난 날짜 매출이 나중에 줄지 않는다. `replace_range`.
- 환불(판매금액(순))은 아직 사건으로 만들지 않는다 — 필요하면 클레임 완료일 기준 CANCEL/RETURN 을 추가.
- **2026-10-19 규칙 변경**(사용자 요청 — "판매금액에 배송비는 추가하고 환불 금액은 빼 주세요", 환불은 환불된 날):
SALE 금액 = 판매금액(총) **+ 배송비**(상품주문 `deliveryFeeAmount − deliveryDiscountAmount` 합, 주문마다 0 미만이면 0),
raw `{goods, ship}`. 환불 = 같은 조회를 `rangeType=CLAIM_COMPLETED_DATETIME` 으로 하루씩 다시 불러(매출 업데이트는 하루 2번 조회 —
진행 막대 단위 "일 조회") 그날 클레임이 끝난 상품주문 중 **CANCELED·RETURNED**(교환·미입금 취소 제외)마다
CANCEL/RETURN `naver:{productOrderId}-RF`, 금액 = −`totalPaymentAmount`(상품 결제금액, 배송비 환불은 넣지 않음), 날짜 = 환불(클레임 완료)일,
raw `{refund}`. 그래서 네이버 열 = 판매금액(총) + 배송비 − 환불금액(환불일). 주문 내역 창에 **배송비·환불금액** 칸 + 합계.
사용자 확인값: 10/18 배송비 87,500원·환불 66,100원 — 배포 뒤 10/18 주문 내역 맨 아래 합계와 비교해 맞는지 확인할 것
(환불이 다르면 배송비 환불·클레임 종류 포함 여부를 실데이터로 조정). `replace_range` 라 다시 받으면 그 기간 환불도 교체.
네이버는 조회 시작일 180일 제한이 있어 그보다 오래된 날은 다시 받을 수 없다(예전 규칙 그대로 남음).
- **배송비 대조(2026-10-19)**: 10/18 실데이터 — 상품주문 53건(주문 30건), `deliveryFeeAmount` 합 157,500(3,500×45)·`deliveryDiscountAmount` 합
119,000(3,500×34)·`sectionDeliveryFee` 0 → 지금 규칙(상품주문마다 배송비 − 할인) 38,500, 판매분석 배송비는 87,500(3,500×25).
배송비·할인이 상품주문마다 반복돼 주문/배송 묶음 단위로 세야 하는 것으로 보여, 진단 `GET /api/marketplaces/naver/reconcile?date=` 응답에
`ship_check`(상품주문·주문·배송 묶음(packageNumber) 단위 후보 합계 + 주문별 상품주문 배송비·할인·상태)를 추가.
**확정(같은 날)**: `per_package.max_fee` = `per_order.max_fee` = **87,500** = 판매분석 배송비(배송비 있는 묶음 25개 × 3,500).
→ 네이버는 배송비·할인을 상품주문마다 반복해 적고, 판매분석 '배송비'는 **배송 묶음마다 deliveryFeeAmount 한 번, 배송비 할인(조건부 무료 등)은 빼지 않은 값**.
규칙을 그렇게 바꿈(`group_orders` — 묶음 `packageNumber`, 없으면 주문). 붙여 준 10/18 상품주문 53건을 새 규칙에 넣어 87,500 확인.
주의: 할인된 배송비도 들어가므로 손님이 실제로 낸 배송비(38,500)보다 크다 — 판매분석 기준을 따른 것.
- 설정 화면 **"쇼핑몰 원본 데이터 확인"**(네이버 선택): 결제일 기준 상품주문 전체의 항목별 합계, 상태별 합계, 날짜별
매출·그중 결제 뒤 취소/반품(참고)·배송비(참고). 개인정보(주문자·수령인·주소·연락처·메모)는 값 없이 이름만.
@@ -352,6 +376,18 @@
## 7. 화면
- **2026-10-19 변경**
- **설정 진단 카드 삭제** — "쇼핑몰 원본 데이터 확인"·"카페24 매출 대조"·"일별 한 번에 비교" 카드와 그 화면 스크립트를 뺐다
(사용자 요청 — 쇼핑몰별 규칙 대조가 끝나 더 안 씀). 서버 API `GET /api/marketplaces/{code}/reconcile`·`daily-check` 와
어댑터 `reconcile`은 다시 대조가 필요할 때를 위해 남겼다(화면 진입점 없음). 아래 절의 "원본 데이터 확인"·"매출 대조" 설명은 그 당시 기록.
- **보기 설정 · 매출 단위** — 설정 화면 "보기 설정" 카드(모듈 권한자 누구나): 원·천원·백만원. 이 브라우저 쿠키 `perf_unit`(1년, path `/performance`)에 두고
매출 실적 화면을 서버가 그 단위로 그린다(`dashboard.amount_text` — 천원 = 정수 반올림, 백만원 = 소수 한 자리, `router._unit_ctx` → 템플릿 `amt`·`money`).
표·월/연 누적 카드 머리에 "단위: 천원", KPI·연 누적은 "3,835천원". 수동 입력은 늘 원 단위로 넣는다(입력 직후 칸은 JS `unitWon`). 광고비 탭·그래프 말풍선은 원 그대로.
- **매출 칸 아래 광고비(ROAS%)** — 일자별 × 쇼핑몰 표의 매출 칸마다 그 쇼핑몰 광고비와 ROAS 를 광고비 색(`--perf-ad`) 작은 줄로(`dashboard._ad_lines`).
값은 광고비 탭과 같다(`ad_spend.channel_roas` — 구글·메타·네이버는 보고서 ROAS, 나머지는 그 쇼핑몰 매출 ÷ 광고비). 쇼핑몰 → 채널(`sales_ad_channels`):
카페24 = **구글·메타 두 줄**("구글 100,000(413%)"), 네이버 = 네이버 광고, 쿠팡 = 쿠팡(윙), 그 밖은 같은 코드 채널. 일 합계 칸 = 보이는 쇼핑몰 광고비 합(ROAS = 그 쇼핑몰들 매출 합 ÷ 광고비 합),
주간합계·기간 합계 행도 그 기간 값. 광고비가 없는 칸은 줄 없음, 광고비 표(005) 미적용·조회 실패면 줄 없이 매출만. 총매출·수수료·차감 매출 전환과 무관하게 늘 보인다.
- **탭**(2026-10-13): 왼쪽 위 큰 탭 둘 — [매출 실적](검정, `/performance/`) · [광고비](주황, `/performance/ads`) — 아이콘 + 고른 탭 색으로 구분,
설정은 맨 오른쪽 톱니 아이콘(프로젝트 모듈과 같은 Material Symbols `settings`, `/performance/settings`). `_tabs.html`.
- **광고비** `/performance/ads?period=…`(기본 이번달) — 매출 실적과 같은 기간 이동(오늘/이번주/이번달/올해/직접선택)·표(일자 × 채널,
@@ -378,7 +414,7 @@
머리글 이름 그대로 `metrics`(JSONB). 광고 계정 이름·ID 는 넣지 않음. 직접 입력으로 광고비를 고쳐도 ROAS·상세는 그대로.
- **네이버 머리글 클릭** → 지금 보는 기간의 일자별 보고서 표(`GET /api/ad-spend/naver/details?from=&to=`, `ad_spend.detail_table`):
열 = 파일 머리글 순서, 맨 아래 합계(숫자 항목은 합, 클릭률 = 클릭수 ÷ 노출수, 광고수익률 = 총비용 가중 평균). `DETAIL_CHANNELS`.
- **구글 = 구글 광고 API**(2026-10-15, 마이그레이션 007) — 아래 "광고 API 연동". 메타는 아직 직접 입력.
- **구글 = 구글 광고 API**(2026-10-15, 마이그레이션 007)·**메타 = 메타 마케팅 API**(2026-10-16, 새 마이그레이션 없음) — 아래 "광고 API 연동".
- **광고 API 연동**(2026-10-15) — 구조: `ad_sources/`(채널 하나 = 파일 하나 + `registry.py` 한 줄, 쇼핑몰 어댑터와 같은 입력칸·연결 테스트 모양,
돌려주는 것은 날짜별 `AdDay`(금액·ROAS·항목)) + `ad_sync.py`(가져오기·저장·상태, 같은 채널 동시 실행 차단).
- **인증정보**: 실적 설정 → **광고 API 연동** 카드 [설정](관리자). 쇼핑몰과 같은 마스터 키·AES-256-GCM, 표만 따로
@@ -397,6 +433,38 @@
ROAS = 전환 가치 ÷ 비용(부가세 별도) × 100(소수 둘째, 구글 화면 값 그대로), 항목에 광고비(부가세 포함)·비용(부가세 별도) 둘 다,
항목 `metrics` = 비용·노출수·클릭수·클릭률(%)·전환수·전환 가치·ROAS(%) → 구글 머리글 클릭 = 일자별 표(`DETAIL_CHANNELS`).
통화가 KRW 가 아니면 저장 안 함. 구글 오류 코드는 고칠 곳 안내를 붙여 보여 줌(`_HINTS`: 권한 없음·토큰 미승인 등), 404 = API 버전 종료 안내.
- **메타 광고**(`ad_sources/meta_ads.py`, 2026-10-16): 입력 = 광고 계정 ID(여러 개 — 줄바꿈·쉼표, `act_` 있어도 됨, 30개까지, 비밀 아님 여러 줄) ·
액세스 토큰(비밀 — `ads_read` 권한, 비즈니스 설정 → 시스템 사용자 토큰 권장(만료 없음), 토큰 주인을 각 광고 계정에 배정) ·
앱 시크릿(비밀, 선택 — 앱에서 "API 호출에 앱 시크릿 필요"를 켰을 때만, `appsecret_proof` = HMAC-SHA256(토큰)) · API 버전(기본 `v26.0`).
조회 = `GET graph.facebook.com/{버전}/act_{계정}/insights` `level=account`·`time_increment=1`·`time_range`, 계정마다 `paging.next` 따라감
(다음 쪽 주소가 graph.facebook.com 이 아니면 중단 — 토큰을 다른 곳에 보내지 않음). 토큰은 메타 문서대로 `access_token` 매개변수
(주소에 들어가므로 오류 문구에 주소를 넣지 않고, httpx INFO 요청 로그는 켜지 않는다). 여러 계정은 날짜별로 더함, 날짜는 광고 계정 시간대.
기여(어트리뷰션)는 메타가 광고 관리자 설정을 따른다(2025-06 부터 API 기여 매개변수 무시) — 광고 관리자 화면 값과 같음.
금액 = 지출 금액(`spend`) 그대로 원 반올림 — **메타 지출 금액은 이미 부가세 포함**(2026-10-16 사용자 확인, × 1.1 은 구글만), ROAS = 구매 전환값 ÷ 지출 금액 × 100
(= 광고 관리자 "구매 ROAS"). 구매 전환값·구매수 = `action_values`·`actions` 에서 `omni_purchase` → `purchase` → 픽셀 구매 순서로 처음 있는 것 하나
(메타가 같은 구매를 여러 종류에 같은 값으로 겹쳐 주므로 더하지 않음). 항목 `metrics` = 지출 금액(부가세 포함 = 광고비)·노출수·클릭수·
클릭률(%)·링크 클릭·구매수·구매 전환값·ROAS(%) → 메타 머리글 클릭 = 일자별 표(`DETAIL_CHANNELS`).
**외화 계정**(2026-10-16, 사용자 요청 — USD 계정 1314634672357695): 원화가 아닌 계정은 지출 금액·구매 전환값을 **그날 환율로 원화 환산**한 뒤
다른 계정과 더한다(`fx.py` `krw_rates` — Frankfurter v2 `https://api.frankfurter.dev/v2/rates?base=USD&quotes=KRW&from=&to=`, API 키 없음,
여러 중앙은행 고시 환율 종합(blended)이라 주말 포함 매일 있음, 서울외국환중개 매매기준율과는 조금 다를 수 있음). 그날 값이 없으면 앞 10일 안 가장 가까운 날 값,
그래도 없거나 환율 서버 장애면 그 회차는 저장하지 않음(일부만 환산 금지, 오류 안내). 통화마다 기간 한 번 요청, 2일 이상 지난 날 환율은 프로세스 안 캐시.
광고비 = 지출 × 환율(메타 지출은 부가세 포함), ROAS 는 비율이라 환율과 무관. 계정 탭에 `지출 금액(USD)`·`적용 환율(원)`(합계 줄 = 광고비 가중 평균).
오류 코드 안내(`_HINTS`): 190 = 토큰 만료·무효(상태 "Token 만료"), 200·10 = 권한(ads_read·계정 배정),
100·803 = 계정 ID, 4·17·613·80000·80004 = 호출 한도, 2635 = 버전 종료. 연결 테스트 = 계정마다 이름·통화·시간대·상태.
**권한 오류 진단**(2026-10-16, 실제로 `(#200) Ad account owner has NOT grant ads_management or ads_read permission` 발생): 연결 테스트가
권한 오류를 받으면 메타에 ① `debug_token`(같은 토큰 — 앱·만료·`scopes`·`granular_scopes.target_ids`, 안 되면 `me/permissions`)
② `me/adaccounts`(이 토큰으로 보이는 계정)를 물어 원인 하나를 짚는다(`_diagnose`): ads_read 없음 → 토큰 재발급 /
입력한 계정이 안 보임 → 시스템 사용자 [자산 할당]에서 광고 계정 배정 후 토큰 재발급 / 권한이 다른 계정에만 → 대상 포함해 재발급 /
다 맞음 → 앱 쪽(비즈니스에 앱 연결·Marketing API 제품·제한 액세스면 토큰 주인이 앱 관리자·개발자인지). 진단 조회 실패는 무시(덧붙이는 정보).
**상세보기 계정별 탭**(2026-10-16): 메타 머리글 상세보기 = [합계 | 계정…] 탭. 가져올 때 그날 메타 행 `metrics` 에 계정별 값을
예약 키 `_accounts`(`ad_sources.base.ACCOUNTS_KEY` — `{계정 ID: {name, amount, roas, metrics}}`, 이름 = insights `account_name`)로 함께 저장
(새 마이그레이션 없음). `ad_spend.detail_table` 은 `_` 로 시작하는 키를 표 열·합계·화면 값에서 뺀다. `ad_spend.detail_tabs` = 합계 탭 +
계정 탭(그 계정이 광고를 낸 날만, 이름 = 가장 최근 날 이름, 순서 = 기간 광고비 큰 계정부터) + `accounts_missing`(계정별 값 없이 광고비만 있는 날 —
계정별 저장 전에 가져온 날, 다시 불러오면 생김, 화면 안내). 계정마다 따로 반올림해 계정 광고비 합이 합계와 1원 다를 수 있다.
계정별 값이 없는 채널(네이버·구글)은 `tabs: []` → 예전 그대로 표 하나.
광고비 탭 불러오기에서 난 권한 오류엔 "[연결 테스트]가 원인을 진단" 안내를 붙인다(`_DIAG_HINT`).
연결 테스트 문구는 **[진단]을 맨 앞에**, 메타 원문은 짧게(긴 안내 주소 뺌) 뒤에. 광고 연동 오류 문구 길이 한도는 `ad_sync.AD_MESSAGE_MAX`(1200자,
비밀값 가린 뒤) — 예전엔 공용 기본 300자에서 잘려 진단이 "[진…" 으로 끊겼다.
- **저장**(`db.replace_ad_api_range`, 한 트랜잭션): API 가 준 날은 `source='api'` 로 덮어씀(직접 입력·업로드 값이 있던 날도),
기간 안에서 API 가 안 준 날(광고 없음)은 **예전 API 값만** 지움 — 직접 입력·업로드 값은 그대로. 화면 초록 숫자 = API 값.
- **언제**: 광고비 탭 **[구글 광고 불러오기]**(설정된 연동만 보임, 지금 보는 기간 → 오늘까지, 모듈 권한자 92일·관리자 366일,
@@ -408,7 +476,7 @@
[총매출|수수료|수수료 차감 매출] 전환(서버가 세 값을 다 그리고 CSS 로 전환, 선택은 localStorage), 일별 추이·쇼핑몰 비중(SVG),
월 누적(비중), 연간 누적(월별, 지나지 않은 달 빈칸). 금액 클릭 → 주문 상세(`GET /api/events`, 31일 이내).
- **설정** `/performance/settings` — 사용/매출 집계 토글, 수수료율(적용 시작일·이력), API 설정 창, 연결 상태
(정상/미설정/인증 실패/Token 만료/API 오류/연동 준비 중/사용 중지, 마지막 테스트·동기화, 최근 오류), **광고 API 연동**(구글 광고 —
(정상/미설정/인증 실패/Token 만료/API 오류/연동 준비 중/사용 중지, 마지막 테스트·동기화, 최근 오류), **광고 API 연동**(구글 광고·메타 광고 —
설정·연결 테스트·연결 상태·마지막 가져오기, 관리자), 마스터 키 상태·재암호화, 테스트 데이터 생성/삭제(`is_sample`).
## 8. 테스트
@@ -421,3 +489,6 @@ python -m app.modules.performance.tests.test_performance # 또는 pytest
동기화 격리·가리기·중복 방지·매출 기준일, 모의 데이터를 DB/네트워크 없이 검증한다.
`tests/test_google_ads.py` — 구글 광고 입력 검사, 토큰 교환·머리글·GAQL 기간·버전, 금액 반올림·ROAS·항목 변환, 오류 안내(권한·버전·통화·키),
광고 인증정보 AAD 이름 공간, 가져오기 저장·상태·비밀값 가림·동시 실행 차단, 불러오기 API(오늘까지 자름·92일 권한·미설정)를 가짜 구글 서버로 검증.
`tests/test_meta_ads.py` — 메타 광고 입력 검사(계정 ID 여러 개·토큰·버전), 요청 매개변수(기간·level·appsecret_proof·버전), 여러 계정 날짜별 합산·
쪽 넘김(메타 밖 주소 거부), 구매 값 겹침 처리·광고비 = 지출 그대로(× 1.1 없음)·ROAS·항목, 외화 환율·366일, 오류 코드 안내·토큰 미노출, 연결 테스트 문구,
실제 fetch_days → AdSyncService 저장·상태·토큰 가림을 가짜 메타 서버로 검증.
+61
View File
@@ -25,6 +25,21 @@
`project.css`의 `--pj-font`만 변경하므로 다른 ERP 화면은 영향을 받지 않으며 아이콘·코드 고정폭 폰트는 유지한다.
폰트는 `static/vendor/project-fonts/`에 원본·저작권/OFL을 함께 보관하고 `project-fonts.css`에서 선언한다(외부 CDN 없음).
저장 시 400/700 글꼴 로딩을 확인하고, 실패하면 이전 설정과 열린 창을 유지해 재시도할 수 있다.
2026-10-16 설정 창 개편 — 왼쪽 분류(일반·프로젝트 화면·보드·관리자) | 오른쪽 설정, 아래 [기본값으로]·취소·저장(한꺼번에 저장).
- **일반(폰트)** — 모두에게 보이고 **이 브라우저에만** 저장(`localStorage.pj_font`).
- **프로젝트 화면·보드** — 수퍼관리자·Admin(템플릿 `pj_admin` = `access.is_project_admin`)에게만 보이고, **서버에 저장해 모든 사용자에게 적용**
(`project_db.project_options`, 마이그레이션 029, 키 하나 = 행 하나, 값 JSONB). 키: `default_view`(왼쪽에서 프로젝트를 열 때 첫 탭
board/list/calendar/timeline/dashboard, 기본 board) · `board_cover`(보드 카드 표지 = 설명의 첫 이미지, 기본 켬).
허용 키·값·기본값은 `store.PROJECT_OPTION_DEFAULTS`·`normalize_project_options`(읽기 — 이상한 값은 기본값)·`validate_project_options`(쓰기 — 400) 한 곳.
API: `GET /project/api/options`(모듈 권한자 누구나, `can_edit`) · `PUT /project/api/options`(Admin 이상, 보낸 키만, 029 미적용 503).
프로젝트 화면(`/project/p/{id}`)은 서버가 `pj_options` → 루트 `data-default-view`·`data-board-cover` 로 넣고 `project.js` 가 쓴다
(읽기 실패·029 미적용이면 기본값 — 화면은 늘 열린다). 달력 월 이동 `?y=&m=` 은 마지막 뷰 `pj_view` 복원, `?scope=all` 은 대시보드, `?embed=1` 은 보드 그대로.
창은 열 때 서버 최신값을 읽고(못 읽으면 시스템 칸 잠금·폰트만 저장), 저장은 바뀐 키만 PUT → 성공해야 폰트도 적용(실패 시 창 유지·사유 표시).
저장하면 `pj-options-change` 이벤트로 보던 보드에 바로 반영, 다른 사용자는 다음에 화면을 열 때부터.
- **관리자(긴급 공지)** — 수퍼관리자만(`user.is_super_admin` — 공지 화면이 수퍼관리자 전용).
- 각 분류 제목 옆 배지로 적용 범위 표시(이 브라우저에만 / 모든 사용자에게). 새 옵션도 이 창의 분류·패널로 추가한다.
- 모달 대화창(`showModal`) 안의 말풍선은 공용 말풍선이 popover(top layer)로 띄운다(`initHoverTips` — 안 그러면 대화창 뒤에 가려짐).
테스트: `tests/test_project_options_api.py`, jsdom `project_ui.test.js`(렌더 `project_admin_render.html`·`project_super_render.html`).
**멤버 이름 표기** — 이메일 아이디의 첫 글자만 대문자(king → King). JS 는 `idOf(email)`/`capName(s)`,
템플릿은 `{{ nm[:1]|upper }}{{ nm[1:] }}` 로 화면에 그릴 때만 바꾼다(API `id`·DB 값은 그대로 — 멘션·검색은 이메일 기준).
**프로젝트 색상·아이콘(아사나식)** — 색상표는 32색(`store.COLOR_PALETTE`, 8칸×4줄 — 위 2줄은 아사나 프로젝트 16색, 아래 2줄은 같은 열의 진한 색. 진한 칸은 체크를 흰색 `.is-dark`. 새 프로젝트
@@ -1369,6 +1384,52 @@ Windows 트레이 프로그램 **DBX 알림**(`desktop/notifier/`, C# .NET Frame
- 검증: `tests/test_project_module.py::test_review_meeting_apply_is_one_transaction`(실제 PostgreSQL — 테스트 전용 트리거로 연결 실패 주입,
풀 1개, 줄 바뀜 409), 기존 `test_review_meeting_quick_tasks_shared`(동시 4건), `tests/js/goals_meeting_ui.test.js` [2g9].
## 6-23. 보드 카드 끌기 실시간 미리보기 · 회의록 항목 칸 끌어 옮기기 · 회의록 표 검정 테두리 (2026-10-19, 마이그레이션 없음)
- **보드 카드 끌기**(`project.js` `startCardDrag`·`placeCardPh`·`flipBoardCards`·`endCardDrag`) — 네이티브 HTML5 DnD 그대로(왼쪽 프로젝트 목록 이동 6-18·세부 업무 끌기와 같은 이벤트).
- dragstart: 카드 복제를 `.pj-card-ghost`(body 에 잠깐, 화면 배율이면 zoom .75) 안에서 2.5° 기울여 `setDragImage`. 다음 틱에 원래 카드를 `.is-drag-src`(display none)로 숨기고
그 자리에 같은 높이의 점선 자리 표시 `.pj-card-ph`(같은 틱에 숨기면 크롬이 끌기를 취소).
- dragover(섹션 body): 마우스 Y 가 카드 중간선 위/아래 어디인지(애니메이션 중인 카드는 transform 을 빼고 계산 — 떨림 방지)로 자리 표시를 옮기고, 옮기기 전후 위치 차이로
FLIP(transform .18s) — 다른 카드가 미끄러지듯 비켜난다. 섹션을 넘어가도 같음. 순서를 못 정하는 경우(필터·정렬 중, 전체 보기 섹션 이름 보드)는 제 섹션 = 원래 자리, 다른 섹션 = 맨 끝.
- drop: 자리 표시 위치 = 놓을 자리. 같은 섹션 = `PUT stages/{id}/tasks/order`, 다른 섹션 = `PUT tasks/{id} {stage_id}` 뒤 그 섹션 `tasks/order`(기본 정렬·필터 없음일 때만,
화면 카드 순서 + 화면에 없는 그 섹션 업무는 뒤). 멀티호밍 연결 업무는 예전처럼 links 만(순서 저장 없음). 저장하는 동안 놓은 모양 유지(`dropped`) → 끝나면 `renderBoard`.
- 섹션 밖에 놓거나 취소하면 dragend 가 자리 표시를 지우고 카드를 원래 자리에 다시 보인다. 끄는 동안 `html.pj-card-dragging` — 실시간 동기화(`syncOnce`)가 보드를 다시 그리지 않는다(다음 주기 반영).
- **body 는 dragenter 도 preventDefault** — 자리 표시가 마우스 아래로 들어온 직후(다음 dragover 전) 놓으면 drop 이 거부되던 문제(Playwright 실제 크롬으로 재현).
- **회의록 항목 칸 끌어 옮기기** — 항목(`th.pj-meet-c-label`)을 마우스로 5px 이상 끌면 시작(그보다 짧으면 이름 수정 클릭 그대로, 끈 뒤 클릭은 막음).
- 묶음 = 항목 칸 첫 줄부터 이어 붙은 줄(`data-label-cont`)·주요 업무 세로 병합에 가려진 줄까지(서버 `move_meeting_group` 과 같은 경계). 묶음이 둘 이상인 구역만.
- 끄는 동안 그 묶음 tr 을 다른 묶음 중간선 기준으로 바로 옮겨 끼우고(구분 칸 `th.pj-meet-c-sec` 은 늘 구역 첫 줄로 옮김), 칸 단위 FLIP(`Element.animate` .17s). 끄는 줄은 연보라 + 왼쪽 보라 선.
- 놓으면 `POST /api/goals/meeting-items/{id}/move-to {before_item_id: 다음 묶음 첫 줄 | null = 구역 맨 끝}` → `refreshMeeting`. 실패하면 안내 후 서버 순서로 다시 그림. Esc = 원래 순서로.
- `db.move_meeting_group`: 같은 주 잠금(`_locked_meeting_items`, 회의 완료면 409)·묶음째·같은 구역만(다른 구역 400)·묶음 사이 자리(`before` 가 묶음 첫 줄이 아님) 409·제자리면 그대로. 권한은 줄 순서와 같음(누구나, 완료 전).
- **회의록 표 테두리** — `.pj-meet-table` 바깥·칸 테두리 `#000`(예전 연회색), 모서리 둥글림 0. 같은 날 추가 요청으로 **구역(구분) 처음·끝 가로선 = 굵은 검정 2px**(표 폭 전체 — 구역 첫 줄 칸 `border-top`, 표 바깥 아래선 2px),
구역 안 가로선은 **항목과 항목 사이 = 검정**(`.is-item-end` — 칸 바로 아래 줄이 항목 칸이 있는 새 항목 줄), **같은 항목 안 하위 줄 사이 = 회색 `#bfc3c9`**(세로선은 검정 그대로, 같은 날 세 번째 요청). 칸은 오른쪽·아래 선만 그리므로 구역 끝에 닿는 칸(마지막 줄 + 거기까지 내려오는 구분·항목·병합 칸)은
`markMeetSecEnds`(초기·`pj-meet-rows`·끌기 중 순서 바뀔 때)가 `.is-sec-end` 를 달아 아래선을 지운다 — 회색선과 굵은 선이 겹치지 않게. 표 머리 바로 아래 첫 구역은 머리 아래선 1px + 1px.
## 6-24. 파일 끌어 놓기로 첨부 — 업무 창·보드 카드 (2026-10-19, 마이그레이션 없음)
- **업무 창**: `.pj-task-modal-card` 에 dragenter/over/leave/drop(종류 `Files` 일 때만). 들어오면 창 전체 점선 안내(`.is-file-over::after`),
저장 전 새 업무(`currentTaskId` 없음)·읽기 전용·관리 권한 없음이면 회색 안내(`.is-file-blocked`, dropEffect none). 놓으면 `uploadTaskFiles(id, files)` —
기존 `POST /project/api/tasks/{id}/attachments`(`file` 하나씩, 여러 개는 차례로) → 토스트 + `loadAttachments`. 설명칸(contenteditable)에 놓아도
글에 끼우지 않고 첨부(창에서 preventDefault). [파일 추가]도 같은 함수(여러 개 선택 가능).
- **보드 카드**(`taskCard`, 관리 권한): 같은 방식으로 그 업무에 첨부 — 카드 점선 + "놓으면 이 업무에 첨부", 올리는 동안 흐리게. 카드 끌기(`text/plain`)·
세부 업무 끌기(`application/x-pj-subtask`)와는 dataTransfer 종류로 구분해 서로 안 섞인다. 그 업무 창이 열려 있으면 목록도 바로 다시 받음.
- 받는 곳 밖에 파일을 놓쳤을 때 브라우저가 파일을 열어 화면을 떠나지 않게 document dragover(dropEffect none)·drop 에서 막는다(받는 곳은 stopPropagation).
## 6-25. 회의록 머리 한 칸(월 계획 숫자 + 결정사항) · 회의록 표 회색 선 · 주차 목표 두 칸 (2026-10-19, 마이그레이션 030)
- **회의록 머리**: 예전 ① 월 계획(머리 줄 숫자 + 아래 그 달 계획 글) ② 결정 사항 두 칸을 한 칸 `.pj-meet-pn`(보드 두 열 너비)으로 —
카드 안 = `결정사항 : …` 제목(왼쪽) + 결정 사항 입력란(15px). `N월 계획` + 숫자 4개(월 목표·누적 목표·누적 실적·목표 대비)는 같은 날 요청으로
카드 위 빈 공간 한 줄 `.pj-meet-kpitop` 으로 옮겼다가, 다시 같은 날 **제목 줄 안 주차 탭과 같은 줄 왼쪽**으로(`.pj-meet-title-break` 로 줄을 바꾼 뒤 kpitop + 주차 탭,
아래쪽 맞춤, 잘리지 않게 — 좁으면 주차 탭이 다음 줄로). ※ `.pj-meet-kpibar` 는 예전 숫자 상자(4칸 격자) CSS 이름이라 겹치지 않게 다른 이름.
월 계획 상세 글(`month_plan`)은 화면에서 뺐다(라우터 계산은 남음). 입력란 id(`pj-meet-notes`)·저장 그대로.
- **회의록 표 테두리**: 구역(구분) 처음·끝 가로선만 굵은 검정 2px(`tr:first-child` 위 + 표 바깥 아래), 나머지 선은 모두 회색 `#bfc3c9`
(세로선·항목 사이·하위 줄 사이·바깥 위·좌우). 표 머리 마지막 줄 아래선은 없앰(첫 구역 굵은 선이 대신). `markMeetSecEnds` 의 `.is-sec-end` 는 그대로 쓰고
`.is-item-end` 는 달리지만 색은 회색.
- **주차별 매출 목표 두 칸**(마이그레이션 030 `project_db_030_week_target_split.sql`): `goal_week_targets.value_dist`(유통·인플)·`value_mall`(카페24·네이버) 추가,
`value` = 두 칸 합계로 계속 저장 → 회의록 누적 목표(`goal_week_targets()`)는 그대로. 입력 창(`.pj-goal-wkpop.is-split`)은 전체 목표 아래 구분선 밑에 머리글 줄
`유통·인플 | 카페24·네이버`, 주차마다 두 칸, 주차 합계 = 모든 칸 합. API `PUT /api/goals/{y}/week-targets/{m}` 의 weeks 값 = 숫자(예전) 또는 `{dist, mall}`
(둘 다 비면 그 주차 지움, 030 미적용인데 두 칸이 오면 503). 030 전에 한 칸으로 넣은 주차는 합계를 유통·인플 칸에 미리 넣어 보여 준다(저장하면 그대로 나뉨).
`db.week_split_enabled`·`goal_week_target_parts`. 030 미적용이면 예전 한 칸 화면.
## 7. 추후 단계
작업 라벨(태그 분류) · 반복 작업 · 템플릿 · 작업 의존성.
+2
View File
@@ -21,6 +21,7 @@
| 쿠팡 밀크런 | 쿠팡 출고 일정 관리 (`app/modules/cupang/`) — 월간 달력 / 출고 묶음(헤더+라인) / 상자 입수량 자동계산 / 로켓 매출 관리 / 엑셀 내보내기. 상품은 `itemcode_db` 읽기 전용 참조 |
| 휴가 (준비중) | 연차/반차/특별휴가 신청·잔여일수 관리 |
| 말레이시아 재고 | 말레이시아 창고 재고관리 (`app/modules/malaysia/`) — 낱개 입출고/조정, 세트 BOM, 일일 재고조사(세트 분해 자동 반영), 현재고 현황. 상품명은 `itemcode_db` 읽기 전용 참조 |
| 입출고 관리 | 본사 → 공장 제품 제작 발주, 물류 입고(여러 번 나눠), 발주 대비 미입고·초과 입고 관리 (`app/modules/inout/`, `inout_db`) — 발주 담당·입고 담당·공장은 모듈 옵션에서 지정, 제품은 `itemcode_db` 단품 읽기 전용. `docs/INOUT_MODULE.md` |
| 긴급 공지 | 수퍼관리자가 정한 시각에 전체/고른 사람의 ERP 화면 정가운데에 띄우는 공지(`app/modules/notice/`, project_db 024) — [확인] 전까지 다시 뜸, 확인 현황. `docs/NOTICE_MODULE.md` |
| 실적 | 쇼핑몰 통합 매출 (`app/modules/performance/`) — 쇼핑몰별 어댑터로 수집 → `performance_db` 저장 → 일자×쇼핑몰 표·KPI·월/연 누적·그래프. 수수료율 이력, API 인증정보는 설정 화면 입력 + AES-256-GCM 암호화 저장. 1단계는 모의 데이터·구조까지(실제 API 는 쇼핑몰별로 순차 연동). `docs/PERFORMANCE_MODULE.md` |
@@ -36,6 +37,7 @@
| `expense` / `vacation` / `cupang` / `malaysia` / `performance` | 접근 | 내부 모듈 진입 (`performance` 설정 화면·API 는 추가로 `admin` 필요) |
| `expense_approver` | 결재 | 개인경비 승인/반려/정산 |
| `asset` | 접근 | 자산관리 조회·등록·수정·배정·반납·보고서 |
| `inout` | 접근 | 입출고 관리 조회. 발주·입고 입력은 모듈 옵션의 발주 담당·입고 담당(ERP 관리자는 둘 다 + 옵션) |
| `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) |
`admin` 역할은 모든 권한 자동 부여. 신규 사용자는 관리자 페이지(`/admin`)에서 이메일만으로 등록 가능.
@@ -0,0 +1,23 @@
-- =====================================================================
-- inout_db 마이그레이션 002 — 공장 담당자·연락처 분리(2026-10-16)
-- =====================================================================
-- 멱등(idempotent). 열 추가만, 삭제 없음. 운영: /opt/www/main 에서 기존 inout_db 에 적용(백업 먼저).
--
-- 왜(사용자 요청): 공장 옵션의 "담당자·연락처" 한 칸을 담당자 / 연락처 두 칸으로.
-- inout_factories.manager(담당자) 를 추가하고 contact 는 연락처만 담는다.
-- 예전 한 칸에 숫자 없이 이름만 들어 있던 값(예: "이석준")은 담당자로 옮긴다 — 숫자가 있으면 연락처로 보고 그대로 둔다.
-- (manager 가 비어 있는 행만 — 다시 실행해도 같다.)
-- 되돌리기: 백업에서 inout_factories 만 복원(열은 남아도 앱은 동작).
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
ALTER TABLE inout_factories ADD COLUMN IF NOT EXISTS manager TEXT NOT NULL DEFAULT '';
COMMENT ON COLUMN inout_factories.manager IS '공장 담당자 이름(연락처는 contact)';
UPDATE inout_factories
SET manager = contact, contact = ''
WHERE manager = '' AND contact <> '' AND contact !~ '[0-9]';
COMMIT;
SELECT 'inout_db 002 factory manager ready' AS status;
+63
View File
@@ -0,0 +1,63 @@
-- =====================================================================
-- inout_db 마이그레이션 003 — 공장 이메일 · 발주 메일(Gmail) · 입고증 사진(2026-10-16)
-- =====================================================================
-- 멱등(idempotent). 열·표 추가만, 기존 값 변경·삭제 없음. 운영: /opt/www/main 에서 기존 inout_db 에 적용(백업 먼저).
--
-- 왜(사용자 요청):
-- ① 옵션에서 공장 담당자 이메일 입력 → 발주서를 저장한 뒤 발주 내용 요약을 발주 담당자 본인 Gmail 로 공장에 보낸다
-- (보내기는 사람이 [메일 발송]을 눌러야 함). Gmail 은 사람마다 한 번 [Gmail 연결](OAuth, gmail.send 범위만)
-- → 갱신 토큰을 APP_ENCRYPTION_KEY 로 암호화해 저장(원문은 DB 에 없음). 보낸 기록을 남긴다.
-- ② 입고 등록 때 공장이 보낸 입고증 사진 첨부 — 사진은 DB(bytea)에(백업에 함께 들어가고 디스크 정리가 없음).
-- 되돌리기: 백업에서 복원(새 표·열만 생기므로 남아 있어도 이전 앱은 동작).
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
-- ① 공장 이메일(여러 개면 쉼표로)
ALTER TABLE inout_factories ADD COLUMN IF NOT EXISTS email TEXT NOT NULL DEFAULT '';
COMMENT ON COLUMN inout_factories.email IS '발주 메일 받는 주소(여러 개는 쉼표)';
-- ② 사람별 Gmail 연결 — 갱신 토큰 암호문만(v{키버전}:… AES-256-GCM, AAD = inout:gmail:{email})
CREATE TABLE IF NOT EXISTS inout_gmail_tokens (
email TEXT PRIMARY KEY,
refresh_token_enc TEXT NOT NULL,
scopes TEXT NOT NULL DEFAULT '',
connected_at TIMESTAMPTZ NOT NULL DEFAULT now(),
last_used_at TIMESTAMPTZ NULL,
last_error TEXT NOT NULL DEFAULT ''
);
COMMENT ON TABLE inout_gmail_tokens IS '입출고 — 발주 메일 보낼 Gmail 연결(사람별, 토큰은 암호문)';
-- ③ 발주 메일 보낸 기록
CREATE TABLE IF NOT EXISTS inout_order_mails (
id BIGSERIAL PRIMARY KEY,
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
sent_by TEXT NOT NULL,
to_addrs TEXT NOT NULL,
cc_addrs TEXT NOT NULL DEFAULT '',
subject TEXT NOT NULL,
gmail_id TEXT NOT NULL DEFAULT '',
sent_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_order_mails_order ON inout_order_mails (order_id, sent_at);
COMMENT ON TABLE inout_order_mails IS '입출고 — 발주 메일 보낸 기록';
-- ④ 입고증 사진
CREATE TABLE IF NOT EXISTS inout_receipt_photos (
id BIGSERIAL PRIMARY KEY,
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
filename TEXT NOT NULL DEFAULT '',
content_type TEXT NOT NULL,
size_bytes INTEGER NOT NULL CHECK (size_bytes > 0),
data BYTEA NOT NULL,
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_receipt_photos_receipt ON inout_receipt_photos (receipt_id, id);
COMMENT ON TABLE inout_receipt_photos IS '입출고 — 입고증 사진(공장 → 물류)';
GRANT SELECT, INSERT, UPDATE, DELETE ON inout_gmail_tokens, inout_order_mails, inout_receipt_photos TO inout_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO inout_app;
COMMIT;
SELECT 'inout_db 003 mail photos ready' AS status;
+44
View File
@@ -0,0 +1,44 @@
-- =====================================================================
-- inout_db 마이그레이션 004 — 상품 정보(단가·무게·은 함유량) · 제외 목록 · 발주 품목 값 사본(2026-10-16)
-- =====================================================================
-- 멱등(idempotent). 표·열 추가만, 기존 값 변경·삭제 없음. 운영: /opt/www/main 에서 기존 inout_db 에 적용(백업 먼저).
--
-- 왜(사용자 요청):
-- 옵션 → 상품 정보: 코드표(itemcode_db.single_items) 단품을 불러와 단가·무게(개당 g = PP량)·은(Ag) 함유량(%)을 직접 입력.
-- 값을 넣은 상품은 다시 불러와도 그대로, 필요 없는 단품은 지우면 제외 목록에 남아 다음 불러오기에서 빠진다.
-- 발주 메일 본문에 금액(수량 × 단가)·PP량·은 함유량 — 발주 품목에는 그때의 값 사본(나중에 단가를 바꿔도 지난 발주는 그대로).
-- 은 함량(g/개) = 무게 × 은 함유량(%) ÷ 100 — 저장하지 않고 계산한다.
-- 되돌리기: 백업에서 복원(새 표·열만 생기므로 남아 있어도 이전 앱은 동작).
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
CREATE TABLE IF NOT EXISTS inout_products (
item_code TEXT PRIMARY KEY CHECK (char_length(item_code) BETWEEN 1 AND 64),
item_name TEXT NOT NULL DEFAULT '',
unit_price NUMERIC(14,2) NULL CHECK (unit_price IS NULL OR unit_price >= 0), -- 단가(원)
weight_g NUMERIC(12,2) NULL CHECK (weight_g IS NULL OR weight_g >= 0), -- 무게(개당 g, PP량)
silver_pct NUMERIC(9,4) NULL CHECK (silver_pct IS NULL OR (silver_pct >= 0 AND silver_pct <= 100)), -- 은(Ag) 함유량 %
imported_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_products IS '입출고 — 상품 정보(코드표 단품 + 단가·무게·은 함유량 수기 입력)';
CREATE TABLE IF NOT EXISTS inout_products_excluded (
item_code TEXT PRIMARY KEY,
item_name TEXT NOT NULL DEFAULT '',
excluded_by TEXT NOT NULL DEFAULT '',
excluded_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_products_excluded IS '입출고 — 상품 정보에서 지운 단품(다음 불러오기에서 뺌)';
-- 발주 품목 — 발주 당시 값 사본(없으면 NULL)
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS unit_price NUMERIC(14,2) NULL;
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS weight_g NUMERIC(12,2) NULL;
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS silver_pct NUMERIC(9,4) NULL;
GRANT SELECT, INSERT, UPDATE, DELETE ON inout_products, inout_products_excluded TO inout_app;
COMMIT;
SELECT 'inout_db 004 products ready' AS status;
+45
View File
@@ -0,0 +1,45 @@
-- =====================================================================
-- inout_db 마이그레이션 005 — 물류센터 담당자 이메일 · 입고 요청 메일(2026-10-19)
-- =====================================================================
-- 멱등(idempotent). 표 추가만, 기존 값 변경·삭제 없음. 운영: /opt/www/main 에서 기존 inout_db 에 적용(백업 먼저).
--
-- 왜(사용자 요청):
-- ① 옵션에서 물류센터 입고 담당자 이메일을 등록한다(+ 입고 요청 메일 참조 기본값 — king@·bj@dbxcorp.co.kr).
-- ② 입고 담당이 입고를 저장하면 미리보기를 보고 [메일 발송]을 눌러 물류센터에 "입고 요청"(전산 등록 부탁) 메일을
-- 입고 담당 본인 Gmail 로 보낸다(발주 메일과 같은 Gmail 연결). 본문 = 입고 상품 표 + 입고증 사진(본문 안 이미지).
-- 보낸 기록을 남긴다(다시 보낼 때 확인).
-- 되돌리기: 백업에서 복원(새 표만 생기므로 남아 있어도 이전 앱은 동작).
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
-- ① 모듈 설정(키·값) — logistics_emails(물류센터 입고 담당 이메일, 쉼표) · receipt_mail_cc(입고 요청 메일 참조)
CREATE TABLE IF NOT EXISTS inout_settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL DEFAULT '',
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_settings IS '입출고 — 모듈 설정(물류센터 이메일 등)';
INSERT INTO inout_settings (key, value) VALUES ('receipt_mail_cc', 'king@dbxcorp.co.kr, bj@dbxcorp.co.kr')
ON CONFLICT (key) DO NOTHING;
-- ② 입고 요청 메일 보낸 기록(입고 1건마다)
CREATE TABLE IF NOT EXISTS inout_receipt_mails (
id BIGSERIAL PRIMARY KEY,
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
sent_by TEXT NOT NULL,
to_addrs TEXT NOT NULL,
cc_addrs TEXT NOT NULL DEFAULT '',
subject TEXT NOT NULL,
gmail_id TEXT NOT NULL DEFAULT '',
sent_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_receipt_mails_receipt ON inout_receipt_mails (receipt_id, sent_at);
COMMENT ON TABLE inout_receipt_mails IS '입출고 — 입고 요청 메일(물류센터) 보낸 기록';
GRANT SELECT, INSERT, UPDATE, DELETE ON inout_settings, inout_receipt_mails TO inout_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO inout_app;
COMMIT;
SELECT 'inout_db 005 receipt mail ready' AS status;
+256
View File
@@ -0,0 +1,256 @@
-- =====================================================================
-- inout_db 초기화 스크립트 (PostgreSQL) — 입출고 관리 모듈(2026-10-16)
-- =====================================================================
-- 본사 → 공장 제품 제작 발주, 공장 → 물류 입고(여러 번 나눠 입고) 기록, 발주 대비 미입고·초과 관리.
-- 멱등(idempotent): 여러 번 실행해도 안전. 기존 데이터를 삭제하지 않는다. DROP/TRUNCATE 없음.
--
-- 실행 방법 (운영 PostgreSQL 컨테이너명: postgres-db, 백업 먼저):
--
-- 1) DB / 역할 / 테이블 생성 (superuser 로 1회)
-- read -s -p "inout_app password: " APP_PWD; echo
-- docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/inout_db_init.sql
--
-- 2) main-app .env 에 연결 정보 등록
-- INOUT_DB_URL=postgresql://inout_app:<APP_PWD>@postgres-db:5432/inout_db
--
-- 3) main-app 재기동
-- cd /opt/www/main && docker compose up -d --build web
--
-- 제품(단품)은 itemcode_db.single_items 를 읽기 전용으로 고른다(ITEMCODE_DB_URL 재사용) — 여기엔 코드·이름 사본만 둔다.
-- =====================================================================
\set ON_ERROR_STOP on
SELECT 'CREATE DATABASE inout_db ENCODING ''UTF8'' TEMPLATE template0'
WHERE NOT EXISTS (SELECT 1 FROM pg_database WHERE datname = 'inout_db')
\gexec
SELECT 'CREATE ROLE inout_app LOGIN PASSWORD ' || quote_literal(:'app_password')
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'inout_app')
\gexec
SELECT 'ALTER ROLE inout_app WITH LOGIN PASSWORD ' || quote_literal(:'app_password')
\gexec
GRANT CONNECT ON DATABASE inout_db TO inout_app;
\connect inout_db
CREATE OR REPLACE FUNCTION inout_set_updated_at() RETURNS trigger AS $$
BEGIN
NEW.updated_at := now();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- ════════════════════════════════════════════════════════════
-- 1) 공장(발주처) — 옵션에서 추가·수정, 쓰지 않으면 숨김(발주 기록이 있으면 지우지 않는다)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_factories (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL CHECK (char_length(name) BETWEEN 1 AND 100),
manager TEXT NOT NULL DEFAULT '', -- 담당자 이름(002)
contact TEXT NOT NULL DEFAULT '', -- 연락처
memo TEXT NOT NULL DEFAULT '',
is_active 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()
);
CREATE UNIQUE INDEX IF NOT EXISTS uq_inout_factories_name ON inout_factories (lower(name));
ALTER TABLE inout_factories ADD COLUMN IF NOT EXISTS manager TEXT NOT NULL DEFAULT ''; -- 002 이전에 만든 DB 도 같게
DROP TRIGGER IF EXISTS trg_inout_factories_updated ON inout_factories;
CREATE TRIGGER trg_inout_factories_updated BEFORE UPDATE ON inout_factories
FOR EACH ROW EXECUTE FUNCTION inout_set_updated_at();
COMMENT ON TABLE inout_factories IS '입출고 — 공장(발주처) 목록';
-- ════════════════════════════════════════════════════════════
-- 2) 담당자 — 옵션에서 지정. order = 발주 담당(발주서 작성·수정·종결), receive = 입고 담당(입고 수량 입력)
-- ERP 관리자는 지정 없이도 둘 다 할 수 있다(앱에서 판단).
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_roles (
email TEXT NOT NULL,
role TEXT NOT NULL CHECK (role IN ('order', 'receive')),
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
PRIMARY KEY (email, role)
);
COMMENT ON TABLE inout_roles IS '입출고 — 발주 담당(order)·입고 담당(receive)';
-- ════════════════════════════════════════════════════════════
-- 3) 발주서(헤더) — 상태는 줄의 입고 합계로 앱이 계산(closed_at = 잔량 종결, cancelled_at = 취소)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_orders (
id BIGSERIAL PRIMARY KEY,
order_no TEXT NOT NULL UNIQUE, -- PO-YYMMDD-NN (발주일 기준 순번)
factory_id INTEGER NOT NULL REFERENCES inout_factories(id),
order_date DATE NOT NULL,
due_date DATE NULL, -- 입고 예정일(납기)
memo TEXT NOT NULL DEFAULT '',
closed_at TIMESTAMPTZ NULL, -- 종결: 남은 미입고를 더 기다리지 않음
closed_by TEXT NOT NULL DEFAULT '',
close_reason TEXT NOT NULL DEFAULT '',
cancelled_at TIMESTAMPTZ NULL, -- 취소(입고 기록이 없을 때만)
cancelled_by TEXT NOT NULL DEFAULT '',
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_orders_date ON inout_orders (order_date DESC, id DESC);
CREATE INDEX IF NOT EXISTS idx_inout_orders_factory ON inout_orders (factory_id);
DROP TRIGGER IF EXISTS trg_inout_orders_updated ON inout_orders;
CREATE TRIGGER trg_inout_orders_updated BEFORE UPDATE ON inout_orders
FOR EACH ROW EXECUTE FUNCTION inout_set_updated_at();
COMMENT ON TABLE inout_orders IS '입출고 — 공장 제품 제작 발주서';
-- 발주 품목 — 제품은 itemcode_db.single_items(단품)의 코드·이름 사본(발주 당시 이름)
CREATE TABLE IF NOT EXISTS inout_order_lines (
id BIGSERIAL PRIMARY KEY,
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
line_no INTEGER NOT NULL,
item_code TEXT NOT NULL CHECK (char_length(item_code) BETWEEN 1 AND 64),
item_name TEXT NOT NULL DEFAULT '',
qty INTEGER NOT NULL CHECK (qty > 0),
memo TEXT NOT NULL DEFAULT '',
UNIQUE (order_id, item_code)
);
CREATE INDEX IF NOT EXISTS idx_inout_order_lines_item ON inout_order_lines (item_code);
COMMENT ON TABLE inout_order_lines IS '입출고 — 발주 품목(단품 코드·발주 수량)';
-- ════════════════════════════════════════════════════════════
-- 4) 입고 — 한 번 들어온 것(날짜) = 입고 1건, 그 안에 품목별 수량. 한 발주에 여러 번 나눠 입고 가능.
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_receipts (
id BIGSERIAL PRIMARY KEY,
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
receipt_date DATE NOT NULL,
memo TEXT NOT NULL DEFAULT '',
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_receipts_order ON inout_receipts (order_id, receipt_date);
CREATE TABLE IF NOT EXISTS inout_receipt_lines (
id BIGSERIAL PRIMARY KEY,
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
order_line_id BIGINT NOT NULL REFERENCES inout_order_lines(id) ON DELETE CASCADE,
qty INTEGER NOT NULL CHECK (qty > 0),
UNIQUE (receipt_id, order_line_id)
);
CREATE INDEX IF NOT EXISTS idx_inout_receipt_lines_line ON inout_receipt_lines (order_line_id);
COMMENT ON TABLE inout_receipts IS '입출고 — 물류 입고(한 번 들어온 것)';
COMMENT ON TABLE inout_receipt_lines IS '입출고 — 입고 품목별 수량';
-- ════════════════════════════════════════════════════════════
-- 5) 공장 이메일 · Gmail 연결 · 발주 메일 기록 · 입고증 사진 (= 마이그레이션 003, 새로 만들 때도 같게)
-- ════════════════════════════════════════════════════════════
-- ① 공장 이메일(여러 개면 쉼표로)
ALTER TABLE inout_factories ADD COLUMN IF NOT EXISTS email TEXT NOT NULL DEFAULT '';
COMMENT ON COLUMN inout_factories.email IS '발주 메일 받는 주소(여러 개는 쉼표)';
-- ② 사람별 Gmail 연결 — 갱신 토큰 암호문만(v{키버전}:… AES-256-GCM, AAD = inout:gmail:{email})
CREATE TABLE IF NOT EXISTS inout_gmail_tokens (
email TEXT PRIMARY KEY,
refresh_token_enc TEXT NOT NULL,
scopes TEXT NOT NULL DEFAULT '',
connected_at TIMESTAMPTZ NOT NULL DEFAULT now(),
last_used_at TIMESTAMPTZ NULL,
last_error TEXT NOT NULL DEFAULT ''
);
COMMENT ON TABLE inout_gmail_tokens IS '입출고 — 발주 메일 보낼 Gmail 연결(사람별, 토큰은 암호문)';
-- ③ 발주 메일 보낸 기록
CREATE TABLE IF NOT EXISTS inout_order_mails (
id BIGSERIAL PRIMARY KEY,
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
sent_by TEXT NOT NULL,
to_addrs TEXT NOT NULL,
cc_addrs TEXT NOT NULL DEFAULT '',
subject TEXT NOT NULL,
gmail_id TEXT NOT NULL DEFAULT '',
sent_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_order_mails_order ON inout_order_mails (order_id, sent_at);
COMMENT ON TABLE inout_order_mails IS '입출고 — 발주 메일 보낸 기록';
-- ④ 입고증 사진
CREATE TABLE IF NOT EXISTS inout_receipt_photos (
id BIGSERIAL PRIMARY KEY,
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
filename TEXT NOT NULL DEFAULT '',
content_type TEXT NOT NULL,
size_bytes INTEGER NOT NULL CHECK (size_bytes > 0),
data BYTEA NOT NULL,
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_receipt_photos_receipt ON inout_receipt_photos (receipt_id, id);
COMMENT ON TABLE inout_receipt_photos IS '입출고 — 입고증 사진(공장 → 물류)';
-- ════════════════════════════════════════════════════════════
-- 6) 상품 정보 · 제외 목록 · 발주 품목 값 사본 (= 마이그레이션 004)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_products (
item_code TEXT PRIMARY KEY CHECK (char_length(item_code) BETWEEN 1 AND 64),
item_name TEXT NOT NULL DEFAULT '',
unit_price NUMERIC(14,2) NULL CHECK (unit_price IS NULL OR unit_price >= 0), -- 단가(원)
weight_g NUMERIC(12,2) NULL CHECK (weight_g IS NULL OR weight_g >= 0), -- 무게(개당 g, PP량)
silver_pct NUMERIC(9,4) NULL CHECK (silver_pct IS NULL OR (silver_pct >= 0 AND silver_pct <= 100)), -- 은(Ag) 함유량 %
imported_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_products IS '입출고 — 상품 정보(코드표 단품 + 단가·무게·은 함유량 수기 입력)';
CREATE TABLE IF NOT EXISTS inout_products_excluded (
item_code TEXT PRIMARY KEY,
item_name TEXT NOT NULL DEFAULT '',
excluded_by TEXT NOT NULL DEFAULT '',
excluded_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_products_excluded IS '입출고 — 상품 정보에서 지운 단품(다음 불러오기에서 뺌)';
-- 발주 품목 — 발주 당시 값 사본(없으면 NULL)
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS unit_price NUMERIC(14,2) NULL;
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS weight_g NUMERIC(12,2) NULL;
ALTER TABLE inout_order_lines ADD COLUMN IF NOT EXISTS silver_pct NUMERIC(9,4) NULL;
-- ════════════════════════════════════════════════════════════
-- 7) 모듈 설정(물류센터 이메일·입고 요청 메일 참조) · 입고 요청 메일 기록 (= 마이그레이션 005)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS inout_settings (
key TEXT PRIMARY KEY,
value TEXT NOT NULL DEFAULT '',
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE inout_settings IS '입출고 — 모듈 설정(물류센터 이메일 등)';
INSERT INTO inout_settings (key, value) VALUES ('receipt_mail_cc', 'king@dbxcorp.co.kr, bj@dbxcorp.co.kr')
ON CONFLICT (key) DO NOTHING;
CREATE TABLE IF NOT EXISTS inout_receipt_mails (
id BIGSERIAL PRIMARY KEY,
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
sent_by TEXT NOT NULL,
to_addrs TEXT NOT NULL,
cc_addrs TEXT NOT NULL DEFAULT '',
subject TEXT NOT NULL,
gmail_id TEXT NOT NULL DEFAULT '',
sent_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
CREATE INDEX IF NOT EXISTS idx_inout_receipt_mails_receipt ON inout_receipt_mails (receipt_id, sent_at);
COMMENT ON TABLE inout_receipt_mails IS '입출고 — 입고 요청 메일(물류센터) 보낸 기록';
-- ════════════════════════════════════════════════════════════
-- 권한 — 앱 계정은 읽기·쓰기만(스키마 변경 없음)
-- ════════════════════════════════════════════════════════════
GRANT USAGE ON SCHEMA public TO inout_app;
GRANT SELECT, INSERT, UPDATE, DELETE ON
inout_factories, inout_roles, inout_orders, inout_order_lines, inout_receipts, inout_receipt_lines,
inout_gmail_tokens, inout_order_mails, inout_receipt_photos, inout_products, inout_products_excluded,
inout_settings, inout_receipt_mails
TO inout_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO inout_app;
SELECT 'inout_db ready' AS status;
@@ -0,0 +1,23 @@
-- =====================================================================
-- project_db 마이그레이션 029 — Project 옵션(시스템 전체 설정)
-- =====================================================================
-- 멱등(idempotent). 테이블만 추가한다(기존 값 변경·삭제 없음). 운영: /opt/www/main 에서 기존 project_db 에 적용.
--
-- 왜(2026-10-16 사용자 요청): Project 옵션 창에서 "일반"(폰트)은 브라우저별(localStorage) 그대로 두고,
-- 수퍼관리자·Admin 이 바꾸는 "프로젝트 화면"(처음 여는 탭)·"보드"(카드 표지 이미지)는 모든 사용자에게 반영한다.
-- 키 하나 = 설정 하나(값은 JSONB). 허용 키·값 검사와 기본값은 앱(store.normalize_project_options) 한 곳에서 한다.
-- 행이 없으면 기본값(처음 여는 탭 = 보드, 카드 표지 = 켬) — 이 파일은 기본 행을 넣지 않는다.
-- 미적용이면: 화면은 기본값으로 동작하고, 옵션 저장만 503 안내.
-- 되돌리기: DROP TABLE project_options; (사용자 확인 후 — 저장한 시스템 설정만 사라지고 기본값으로 돌아감)
-- =====================================================================
BEGIN;
CREATE TABLE IF NOT EXISTS project_options (
key TEXT PRIMARY KEY CHECK (char_length(key) BETWEEN 1 AND 64),
value JSONB NOT NULL,
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE project_options IS 'Project 옵션 — 시스템 전체 설정(수퍼관리자·Admin 수정, 모든 사용자에게 적용). 키: default_view, board_cover';
COMMIT;
@@ -0,0 +1,29 @@
-- =====================================================================
-- project_db 마이그레이션 030 — 주차별 매출 목표를 두 칸으로(유통·인플 / 카페24·네이버) (2026-10-19)
-- =====================================================================
-- 멱등(idempotent). 열 추가만, 기존 값 변경·삭제 없음. 운영: /opt/www/main 에서 기존 project_db 에 적용(백업 먼저).
--
-- 왜(사용자 요청): 연간 목표 → 월 매출 목표 칸 → 주차별 목표 입력 창에서 주차마다 입력란을 둘로 —
-- 왼쪽 "유통·인플"(value_dist), 오른쪽 "카페24·네이버"(value_mall).
-- value 는 지금처럼 그 주차 합계(= 두 칸 합)로 계속 저장한다 — 회의록 "누적 목표"(주차 합)는 그대로 value 를 읽는다.
-- 예전에 한 칸으로 넣은 주차(두 열 NULL)는 화면이 그 값을 "유통·인플" 칸에 미리 넣어 보여 준다(저장하면 그대로 나뉨).
-- 되돌리기: 백업에서 복원(새 열만 생기므로 남아 있어도 이전 앱은 value 만 쓰며 동작).
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
ALTER TABLE goal_week_targets ADD COLUMN IF NOT EXISTS value_dist NUMERIC NULL;
ALTER TABLE goal_week_targets ADD COLUMN IF NOT EXISTS value_mall NUMERIC NULL;
DO $$
BEGIN
IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'goal_week_targets_parts_nonneg') THEN
ALTER TABLE goal_week_targets ADD CONSTRAINT goal_week_targets_parts_nonneg
CHECK ((value_dist IS NULL OR value_dist >= 0) AND (value_mall IS NULL OR value_mall >= 0));
END IF;
END $$;
COMMENT ON COLUMN goal_week_targets.value_dist IS '주차 목표 — 유통·인플(목표 표 매출 단위)';
COMMENT ON COLUMN goal_week_targets.value_mall IS '주차 목표 — 카페24·네이버(목표 표 매출 단위)';
COMMENT ON COLUMN goal_week_targets.value IS '주차 목표 합계(030 부터 = value_dist + value_mall)';
COMMIT;
SELECT 'project_db 030 week target split ready' AS status;
+189
View File
@@ -0,0 +1,189 @@
// 실제 브라우저 — 보드 카드 끌기(필터를 켠 브라우저에서도 섹션 안 순서 변경, 숨은 업무는 제자리)와
// 파일 → 구글 드라이브(설명란 = 놓은 자리에 링크, 보드 카드 = 서버가 설명 끝에 링크 append) (2026-10-19).
// 서버는 가짜(이 파일의 http 서버), 화면은 실제 템플릿 렌더 결과.
// python tests/js/render_project.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/board_drive.browser.test.js
const fs = require("node:fs"), path = require("node:path"), http = require("node:http");
const { chromium } = require("playwright");
const ROOT = path.resolve(__dirname, "../.."), OUT = path.join(__dirname, ".out"), STATIC = path.join(ROOT, "app/static");
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); }
}
// 렌더된 보드(할 일 섹션 = 작업 A·B) 에 완료된 C(필터 "미완료"로 숨김)와 D 를 더한다
function boardHtml() {
let html = fs.readFileSync(path.join(OUT, "project_render.html"), "utf8");
return html.replace(/(<script id="pj-data" type="application\/json">)([\s\S]*?)(<\/script>)/, function (_, a, json, c) {
const data = JSON.parse(json);
const base = data.tasks.find(function (t) { return t.id === 101; });
base.description = "<p>앞 글</p>";
const b = data.tasks.find(function (t) { return t.id === 102; });
b.description = '<p>앞 <a href="https://example.com/x">링크 글자</a> 뒤</p><p>끝 링크 <a href="https://example.com/y">마지막</a></p>';
data.tasks.push(Object.assign({}, base, { description: "", id: 104, title: "작업 C(완료)", completed_at: "2026-10-01T00:00:00+09:00", sort_order: 104 }));
data.tasks.push(Object.assign({}, base, { description: "", id: 105, title: "작업 D", sort_order: 105 }));
return a + JSON.stringify(data) + c;
});
}
const orders = [], drives = [], puts = [];
const server = http.createServer(async (req, res) => {
const url = new URL(req.url, "http://localhost");
const json = (code, body) => { res.statusCode = code; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(body)); };
if (url.pathname === "/project/p/1") { res.setHeader("Content-Type", "text/html; charset=utf-8"); res.end(boardHtml()); return; }
if (url.pathname.startsWith("/project/api/")) {
const chunks = []; for await (const c of req) chunks.push(c);
const raw = Buffer.concat(chunks).toString("utf8");
const order = /^\/project\/api\/projects\/1\/stages\/(\d+)\/tasks\/order$/.exec(url.pathname);
if (order) { orders.push({ stage: +order[1], ids: JSON.parse(raw).ordered_ids }); return json(200, { ok: true }); }
const drive = /^\/project\/api\/tasks\/(\d+)\/drive-files$/.exec(url.pathname);
if (drive && req.method === "POST") {
const name = (/filename="([^"]+)"/.exec(raw) || [])[1] || "file";
const append = /name="append"\r\n\r\ntrue/.test(raw);
drives.push({ id: +drive[1], name: name, append: append });
const f = { id: "FILE" + drives.length + "abcdefgh", name: name, url: "https://drive.google.com/file/d/FILE" + drives.length + "abcdefgh/view" };
const out = { file: f, link_html: "" };
if (append) out.task = { id: +drive[1], project_id: 1, context_project_id: 1, stage_id: 11, title: "작업", description: '<p><a href="' + f.url + '">' + name + "</a></p>" };
return json(201, out);
}
const task = /^\/project\/api\/tasks\/(\d+)$/.exec(url.pathname);
if (task && req.method === "GET") return json(200, { task: { id: +task[1], title: "작업 " + task[1], project_id: 1, context_project_id: 1, stage_id: 11,
description: "<p>앞 글</p>", priority: "normal", assignee_email: "", subtasks: [], links: [], followers: [], access: "full", completed_at: null } });
if (task && req.method === "PUT") {
const body = JSON.parse(raw); puts.push({ id: +task[1], body: body });
return json(200, { task: Object.assign({ id: +task[1], title: "작업", project_id: 1, context_project_id: 1, stage_id: 11 }, body) });
}
if (url.pathname.endsWith("/comments")) return json(200, { comments: [], events: [], features: {} });
if (url.pathname.endsWith("/attachments")) return json(200, { attachments: [] });
if (url.pathname.endsWith("/members")) return json(200, { members: [{ user_email: "me@test.local" }] });
if (url.pathname.endsWith("/live-version")) return json(200, { ts: "v1" });
if (url.pathname.endsWith("/alerts")) return json(200, { me: "me@test.local", latest_id: 0, alerts: [] });
return json(200, {});
}
if (url.pathname.startsWith("/static/")) {
const file = path.join(STATIC, decodeURIComponent(url.pathname.slice("/static/".length)));
if (file.startsWith(STATIC) && fs.existsSync(file)) {
res.setHeader("Content-Type", file.endsWith(".js") ? "text/javascript" : file.endsWith(".css") ? "text/css" : "application/octet-stream");
res.end(fs.readFileSync(file)); return;
}
}
res.statusCode = 404; res.end("");
});
// 파일 끌어 놓기 흉내 — 진짜 File 을 담은 DataTransfer 로 dragenter·dragover·drop
async function dropFile(page, selector, name) {
await page.evaluate(function (a) {
const target = document.querySelector(a.sel);
const r = target.getBoundingClientRect();
const dt = new DataTransfer();
dt.items.add(new File(["hello"], a.name, { type: "text/plain" }));
const opts = { bubbles: true, cancelable: true, dataTransfer: dt, clientX: r.left + 10, clientY: r.top + Math.min(10, r.height / 2) };
["dragenter", "dragover", "drop"].forEach(function (k) { target.dispatchEvent(new DragEvent(k, opts)); });
}, { sel: selector, name: name });
}
(async function () {
await new Promise(r => server.listen(0, "127.0.0.1", r));
const base = "http://127.0.0.1:" + server.address().port;
const browser = await chromium.launch(process.env.PJ_TEST_BROWSER ? { executablePath: process.env.PJ_TEST_BROWSER } : {});
try {
const page = await browser.newPage({ viewport: { width: 1600, height: 1000 } });
page.on("pageerror", e => console.log("PAGEERR", e.message));
// 이 브라우저에는 "미완료만" 필터가 저장돼 있다(다른 컴퓨터는 없음) — 예전엔 이 상태에서 섹션 안 이동이 늘 제자리로
await page.addInitScript(() => {
localStorage.setItem("pj_filter_1", JSON.stringify({ status: "open" }));
localStorage.setItem("pj_view", "board");
});
await page.goto(base + "/project/p/1");
await page.waitForSelector('.pj-card[data-task-id="105"]');
check("필터(미완료) — 완료된 C 는 보드에 안 보임", !(await page.$('.pj-card[data-task-id="104"]')));
// ── 1) 섹션 안 카드 끌기: D 를 A 위로
const a = await page.locator('.pj-card[data-task-id="101"]').boundingBox();
const d = await page.locator('.pj-card[data-task-id="105"]').boundingBox();
await page.mouse.move(d.x + d.width / 2, d.y + d.height / 2);
await page.mouse.down();
await page.mouse.move(d.x + d.width / 2, d.y + d.height / 2 - 8, { steps: 3 });
for (let i = 1; i <= 12; i++) await page.mouse.move(a.x + a.width / 2, d.y + (a.y + 4 - d.y) * i / 12, { steps: 2 });
await page.waitForTimeout(150);
await page.mouse.up();
await page.waitForTimeout(400);
check("필터를 켠 채 섹션 안 이동 — 순서 저장 요청", orders.length === 1, orders);
check("숨은 C 는 제자리, D 는 A 앞", orders[0] && JSON.stringify(orders[0].ids) === JSON.stringify([105, 101, 102, 104]), orders[0]);
const ids = await page.$$eval('.pj-col-body .pj-card[data-task-id]', els => els.map(e => +e.dataset.taskId));
check("보드도 D·A·B 순서로 다시 그림", JSON.stringify(ids.slice(0, 3)) === JSON.stringify([105, 101, 102]), ids);
// ── 2) 보드 카드에 파일 놓기 → 서버가 설명 끝에 링크(append)
await dropFile(page, '.pj-card[data-task-id="102"] .pj-card-title', "견적서.pdf");
await page.waitForTimeout(400);
check("보드 카드 파일 → drive-files(append) 한 번", drives.length === 1 && drives[0].id === 102 && drives[0].append && drives[0].name === "견적서.pdf", drives);
// ── 3) 업무 창 설명란에 파일 놓기 → 놓은 자리에 "파일 이름.확장자" 링크 + 설명 저장
await page.click('.pj-card[data-task-id="101"] .pj-card-title');
await page.waitForSelector("#pj-t-desc", { state: "visible" });
await page.waitForFunction(() => document.getElementById("pj-t-desc").textContent.includes("앞 글"));
await dropFile(page, "#pj-t-desc", "도면 v2.dwg");
await page.waitForFunction(() => !!document.querySelector('#pj-t-desc a[href*="drive.google.com"]'), null, { timeout: 5000 }).catch(() => {});
const link = await page.evaluate(() => {
const x = document.querySelector('#pj-t-desc a[href*="drive.google.com"]');
return x ? { text: x.textContent, href: x.getAttribute("href"), target: x.getAttribute("target"),
busy: !!document.querySelector("#pj-t-desc .pj-drive-uploading") } : null;
});
check("설명란 파일 → drive-files(append 아님)", drives.length === 2 && drives[1].id === 101 && !drives[1].append, drives);
check("설명란에 '파일 이름.확장자' 링크(새 탭)", link && link.text === "도면 v2.dwg" && /\/file\/d\/FILE2abcdefgh\/view$/.test(link.href) && link.target === "_blank" && !link.busy, link);
await page.waitForTimeout(1600); // 설명 자동 저장(1.2초)
const descPut = puts.filter(p => p.id === 101 && p.body.description != null).pop();
check("링크가 들어간 설명 저장", !!descPut && descPut.body.description.includes("FILE2abcdefgh") &&
/앞.*도면 v2\.dwg<\/a>.*글/.test(descPut.body.description), descPut); // 놓은 자리(앞|글 사이)에 링크
// ── 4) 업무 창이 열린 업무의 카드에 놓으면 서버 append 대신 편집기 끝에(옛 설명 저장이 링크를 지우지 않게)
await dropFile(page, '.pj-card[data-task-id="101"] .pj-card-title', "사진.jpg");
await page.waitForTimeout(500);
const n = await page.$$eval('#pj-t-desc a[href*="drive.google.com"]', els => els.map(e => e.textContent));
check("열린 업무 카드 → 편집기에 링크(append 아님)", drives.length === 3 && !drives[2].append && n.indexOf("사진.jpg") >= 0, { drives: drives, n: n });
// ── 5) 설명란 링크 = 굵게·기울임·밑줄, 한 글자처럼(Backspace·Delete 한 번에 통째로, Ctrl+Z 로 되살림)
await page.keyboard.press("Escape");
await page.waitForTimeout(300);
await page.evaluate(() => { const c = document.querySelector('.pj-card[data-task-id="102"] .pj-card-title'); c.click(); });
await page.waitForFunction(() => document.getElementById("pj-t-desc").textContent.includes("링크 글자"));
const st = await page.evaluate(() => {
const a = document.querySelector("#pj-t-desc a"), cs = getComputedStyle(a);
return { ce: a.getAttribute("contenteditable"), w: cs.fontWeight, i: cs.fontStyle, u: cs.textDecorationLine };
});
check("링크 서식 굵게·기울임·밑줄 + 잠금", st.ce === "false" && +st.w >= 700 && st.i === "italic" && st.u.includes("underline"), st);
function caret(where) { // where: "after1" = 첫 링크 바로 뒤, "before2" = 둘째 링크 바로 앞
return page.evaluate((w) => {
const box = document.getElementById("pj-t-desc"); box.focus();
const as = box.querySelectorAll("a"), r = document.createRange();
if (w === "after1") r.setStart(as[0].nextSibling, 0);
else { const t = as[as.length - 1].previousSibling; r.setStart(t, t.nodeValue.length); }
r.collapse(true); const s = getSelection(); s.removeAllRanges(); s.addRange(r);
}, where);
}
await caret("after1");
await page.keyboard.press("Backspace");
let txt = await page.evaluate(() => ({ t: document.getElementById("pj-t-desc").textContent, n: document.querySelectorAll("#pj-t-desc a").length }));
check("링크 바로 뒤 Backspace 한 번 → 링크 통째로 지움", txt.n === 1 && !txt.t.includes("링크 글자") && txt.t.replace(/ /g, " ").includes("앞 뒤"), txt);
await page.keyboard.press("Control+z");
txt = await page.evaluate(() => document.querySelectorAll("#pj-t-desc a").length);
check("Ctrl+Z 로 링크 되살림", txt === 2, txt);
await caret("before2");
await page.keyboard.press("Delete");
txt = await page.evaluate(() => ({ t: document.getElementById("pj-t-desc").textContent, n: document.querySelectorAll("#pj-t-desc a").length }));
check("링크 바로 앞 Delete 한 번 → 링크 통째로 지움", !txt.t.includes("마지막") && txt.t.includes("끝 링크"), txt);
await page.keyboard.press("Control+z");
// 줄 끝 링크 오른쪽을 눌러 이어 쓰면 링크 밖에 써진다
const last = await page.locator("#pj-t-desc a").last().boundingBox();
await page.mouse.click(last.x + last.width + 40, last.y + last.height / 2);
await page.keyboard.type("추가");
txt = await page.evaluate(() => { const a = [...document.querySelectorAll("#pj-t-desc a")].pop(); return { a: a.textContent, p: a.parentElement.textContent }; });
check("줄 끝 링크 뒤에 이어 쓰기(링크 밖)", txt.a === "마지막" && /마지막추가$/.test(txt.p), txt);
await page.waitForTimeout(1600);
const saved = puts.filter(p => p.id === 102 && p.body.description != null).pop();
check("저장 HTML 에 잠금 표시(contenteditable) 없음", !!saved && !saved.body.description.includes("contenteditable"), saved);
} finally { await browser.close(); server.close(); }
console.log(fails.length ? "\n" + fails.length + " FAILED" : "\nALL PASS");
process.exit(fails.length ? 1 : 0);
})();
+35 -2
View File
@@ -15,7 +15,7 @@ const ROOT = path.join(__dirname, "..", "..");
const OUT = path.join(__dirname, ".out");
const JS = fs.readFileSync(path.join(ROOT, "app", "static", "project.js"), "utf8");
const PAGE = {};
["goals_admin", "goals_ro", "goals_weekly_admin", "meeting_admin", "meeting_err", "meeting_ro", "meeting_member",
["goals_admin", "goals_ro", "goals_weekly_admin", "goals_weekly_split", "meeting_admin", "meeting_err", "meeting_ro", "meeting_member",
"meeting_groups", "meeting_groups_added"].forEach(function (n) {
PAGE[n] = fs.readFileSync(path.join(OUT, n + ".html"), "utf8");
});
@@ -497,6 +497,36 @@ function meetServer(env, st) {
check("[2e] 월 목표 직접 저장 요청 없음", !st.metric);
});
// ════════════════════ [2e2] 주차 목표 두 칸(030) — 유통·인플 | 카페24·네이버, 머리글은 전체 목표 아래 ════════════════════
await section(async function () {
const env = makeEnv(PAGE.goals_weekly_split, GOALS_URL);
goalsServer(env);
let sent = null;
env.route("PUT", /\/project\/api\/goals\/2026\/week-targets\/1$/, function (u, body) {
sent = body;
return { body: { ok: true, value: Number(body.month), label: body.month, week_total: 0, weeks: {}, parts: {
"2026-01-12": { dist: "30", mall: "20" } } } };
});
await boot(env);
env.d.querySelector('input.pj-goal-num[data-metric="sales"][data-kind="target"][data-month="1"]').click();
const pop = env.d.body.querySelector(".pj-goal-wkpop");
const kids = Array.from(pop.children).map(function (n) { return n.className; });
const head = pop.querySelector(".pj-goal-wkpop-colhead");
check("[2e2] 두 칸 창 — 머리글(유통·인플 | 카페24·네이버)이 전체 목표 바로 아래",
pop.classList.contains("is-split") && !!head && /유통·인플/.test(head.textContent) && /카페24·네이버/.test(head.textContent) &&
kids.indexOf(head.className) === kids.findIndex(function (c) { return /pj-goal-wkpop-month/.test(c); }) + 1, kids);
const dist = Array.from(pop.querySelectorAll('input[data-part="dist"]')), mall = Array.from(pop.querySelectorAll('input[data-part="mall"]'));
const sumEl = pop.querySelector('[data-sum="weeks"]');
check("[2e2] 주차마다 두 칸 · 저장값(예전 한 칸 값은 유통·인플 칸) · 합계 = 두 칸 모두", dist.length === 5 && mall.length === 5 &&
dist[0].value === "60" && mall[0].value === "40" && dist[1].value === "200" && mall[1].value === "" && sumEl.textContent === "300", sumEl.textContent);
type(env, dist[2], "30"); type(env, mall[2], "20");
check("[2e2] 두 칸 입력 → 합계", sumEl.textContent === "350", sumEl.textContent);
pop.querySelector('[data-act="save"]').click();
await settle(); await wait(10); await settle();
check("[2e2] 주차마다 {dist, mall} 로 전송", sent && sent.weeks["2026-01-12"] && sent.weeks["2026-01-12"].dist === "30" &&
sent.weeks["2026-01-12"].mall === "20" && sent.weeks["2026-01-01"].dist === "60" && sent.weeks["2026-01-01"].mall === "40", sent);
});
// ════════════════════ [2f] 회의록 보드 — 누르는 순간 창을 열고, 서버가 준 Google 슬라이드 주소로 바꾼다 ════════════════════
await section(async function () {
const env = makeEnv(PAGE.meeting_ro, MEET_URL); // 보기만 하는 사람도 연다
@@ -572,7 +602,10 @@ function meetServer(env, st) {
{ id: 73, name: "완료", sort_order: 0, is_done_stage: true }] } }; });
await boot(env); await settle(); await wait(5); await settle();
const d = env.d, board = d.querySelector(".pj-meet-board");
check("[2g] 머리 영역: 월 계획 · 결정 사항 · 작업 등록", !!board && board.children.length === 3 &&
check("[2g] 머리 영역: (월 계획 숫자 + 결정 사항) 한 칸 · 작업 등록", !!board && board.children.length === 2 &&
!!board.querySelector(".pj-meet-pn .pj-meet-pn-title") && !board.querySelector(".pj-meet-plan-head") &&
!!env.d.querySelector(".pj-meet-title > .pj-meet-kpitop + .pj-meet-weeks") &&
!!env.d.querySelector(".pj-meet-kpitop .pj-meet-plan-head .pj-meet-kpiline") && !env.d.querySelector(".pj-meet-plan-grid") &&
!!board.querySelector(".pj-meet-notes #pj-meet-notes") && !!board.querySelector("#pj-meet-quick"));
check("[2g] 서버 표를 읽어 빈 줄 3개", env.calls.some(function (c) { return /\/meetings\/2026-09-28\/quick-tasks$/.test(c.url) && c.method === "GET"; }) &&
d.querySelectorAll("#pj-meet-quick tbody tr").length === 3);

Some files were not shown because too many files have changed in this diff Show More