33 Commits

Author SHA1 Message Date
king 4171d61db1 feat(카페24): 소스 편집기 이미지 파일명 번호 단축키
img 태그 안에서 커서 바로 뒤가 .jpg/.gif/.png 일 때 Ctrl+위/아래로
파일명 번호를 바꾼다(없음 → _2 → _3 …, 내리면 _2 다음은 원래 이름).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 21:24:18 +09:00
king 677bf8f1d1 Merge branch 'feat/live-lang-toggle' 2026-11-04 17:35:24 +09:00
king 15dcabc538 feat(라이브커머스): 한글·영문 전환 버튼과 메인 카드 제목 표기
스케줄표·달력·호스트 설정 위에 한글/EN 버튼을 두고 화면·창·오류·확인
문구를 모두 전환한다(쿠키 live_lang, 브라우저마다 기억). 메인 카드 제목은
"라이브 커머스 · Live Commerce"로 표기한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 17:35:16 +09:00
king 25c885d5dd Merge branch 'feat/live-calendar' 2026-11-04 16:58:12 +09:00
king 61f5b3c320 feat(라이브커머스): 달력 보기와 호스트 비용 계산 추가
2시간 칸 × 날짜 달력(카드 머리 = Tiktok Handle, SALES·COM·Fee), 끌어 옮기기·
맞바꾸기, Jump to Date, 날짜별 합계·광고비·ROAS 를 넣는다.
호스트 비용 = 시간 × RM 25 + 판매금액 10%, 표 보기에도 표시한다.
끝 시간을 필수로 바꾸고 광고비 표는 마이그레이션 002 로 추가한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 16:58:07 +09:00
king 5d55081464 Merge branch 'feat/live-commerce-module' 2026-11-04 16:41:42 +09:00
king f54f19fa45 feat(라이브커머스): 라이브 커머스 모듈 추가
말레이시아 라이브 방송의 호스트 정보와 방송 스케줄을 관리하는 새 모듈.
호스트 설정(이름·연락처·주소·계좌·틱톡)은 ERP 관리자만 다루고,
스케줄표에서 등록된 호스트를 골라 날짜·시간·장소·판매금액(RM)·결과
이미지를 저장한다. 권한키 live, DB live_db(LIVE_DB_URL), 미설정이면
설정 필요 안내만 표시한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 16:41:37 +09:00
king 876d9758bd Merge branch 'feat/inout-simple-order-mail' 2026-11-04 15:43:39 +09:00
king 0ba6192e95 feat(입출고): 대성화학·인천공장 발주 메일 표를 간단하게
공장 이름에 대성화학·인천공장이 들어가면 품목 표를 번호·제품 코드·
제품명·수량·박스당 수량·박스 수·비고로 만들고, 요약 표와 글 본문에서도
금액·무게·PP·은을 뺀다. 박스 값은 메일을 만들 때의 상품 정보로 계산한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:43:19 +09:00
king dd5010019d Merge branch 'feat/inout-bag-pallet-picture' 2026-11-04 15:35:00 +09:00
king 57745e114e feat(입출고): 봉투·백 합계 줄에 파렛트 그림 표시
새 발주서 합계 줄의 봉투·백도 통처럼 파렛트 그림으로 보여 주고,
"통·뚜껑과 따로 셈" 글자를 뺀다. 1파렛트 박스 수가 다른 상품이 섞이면
가장 큰 값으로 환산해 잔량은 %만 표시하고, 그림은 60칸까지만 그린다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:34:54 +09:00
king 307a0c31b1 Merge branch 'feat/inout-bag-no-price-columns' 2026-11-04 15:29:30 +09:00
king cfb6878bea feat(입출고): 봉투·백 표에서 단가·무게·은 열 제거
봉투·백에는 단가·무게·은이 없어 표에서 네 열을 뺀다. 전에 넣은 값은
숨은 칸으로 저장 때 그대로 보내 지우지 않는다.
새 발주서·발주서 화면·발주 메일의 단가 미입력 안내에서도 봉투·백을 뺀다.
은 칸이 없는 줄에서 그룹을 바꿔도 색상 표시가 덮이지 않게 고친다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:29:20 +09:00
king b0f559907f Merge branch 'feat/inout-bag-pallet' 2026-11-04 15:17:53 +09:00
king b6c8173899 feat(입출고): 미라클 봉투·미라클백 상품을 표로 분리하고 파렛트 입력 추가
이름에 "미라클 봉투"·"미라클백"이 들어간 상품은 옵션 → 상품 정보에서
별도 표로 나누고 박스당 수량·1파렛트당 박스 수량을 입력한다.
새 발주서 합계 줄에 봉투·백 박스·파렛트를 통·뚜껑과 따로 표시한다.
마이그레이션 008 필요, 미적용이면 모두 일반 상품으로 동작한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 15:17:47 +09:00
king d0e3e3622b Merge branch 'feat/inout-list-status-per-user' 2026-11-04 11:27:07 +09:00
king 6055d50dbe feat(입출고): 발주 목록 상태 보기를 사람마다 기억
진행 중·완료·종결·취소·전체 중 고른 보기를 다음 접속에도 유지한다.
inout_settings 에 list_status:{이메일} 키로 저장해 마이그레이션은 없고,
005 미적용이면 기억만 하지 않는다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 11:27:01 +09:00
king 321041b65a Merge branch 'feat/cafe24-img-preview-name' 2026-11-03 15:38:54 +09:00
king faed6581fd feat(카페24): 이미지 미리보기 시 태그 오렌지 표시·레이어 상단 파일명
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:38:54 +09:00
king 6b04b7ab6e Merge branch 'fix/cafe24-img-preview-width' 2026-11-03 15:33:07 +09:00
king a85d562fa7 fix(카페24): 이미지 미리보기 레이어 폭 500px 고정
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:33:07 +09:00
king 889522d935 Merge branch 'feat/cafe24-img-hover-preview' 2026-11-03 15:29:56 +09:00
king 5e5586a25c feat(카페24): 상세 소스의 img 태그 hover 시 오른쪽에 이미지 미리보기
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 15:29:55 +09:00
king 5cf1a33e98 Merge branch 'fix/vacation-mail-gmail-retry'
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 16:26:13 +09:00
king f4b80e8abc fix(휴가): 메일 실패 시 Gmail 연결 안내·다시 보내기 — 휴가 권한 없는 협의자 포함
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 16:26:13 +09:00
king 7e86e9c91b Merge branch 'fix/vacation-holiday-name-size'
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:52:50 +09:00
king 4ecde312f9 fix(휴가): 신청 달력 공휴일 이름 크게(9→10.5px), 달력 폭 380px
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:52:49 +09:00
king 0c17b02468 Merge branch 'feat/vacation-consult-photo-rotate'
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:46:25 +09:00
king 97f4a904cd feat(휴가): 협의자 결재·신청 화면 개편(라디오·붙박이 달력·결재 라인)·내 신청 내역
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:46:19 +09:00
king f7a3afcebf feat(입출고): 입고증 사진 왼쪽·오른쪽 회전 — 돌린 상태로 저장
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:46:18 +09:00
king b3001c3051 fix(실적): 수기 입력 뒤 새로고침해도 스크롤 위치 유지
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 15:46:17 +09:00
king 443fa56671 Merge branch 'feat/perf-cafe24-real' 2026-11-02 12:21:35 +09:00
king 884e654bea feat(실적): 카페24(실적) 열·합계 기준 통일·공통 보기 설정·일 합계 고정
매출 실적
- "카페24" 열 → "카페24(전체)", 바로 오른쪽 "카페24(실적)" = 전체 − 자사몰(공동구매),
  광고비 줄은 카페24(전체)의 구글·메타 그대로 (예전 "공구 제외" 열 대체)
- 합계 기준 통일: 일 합계·ROAS·KPI·추이·비중·월/연 누적 = 카페24(실적) + 공동구매 + 나머지
  (카페24(전체)에 공동구매가 들어 있어 이중 합산 제거, 그래프·누적의 카페24 줄 = 카페24(실적))
- 실적 설정 "공통 보기 설정"(관리자, perf_settings, 모든 사용자 적용):
  매출 단위(예전 브라우저 쿠키 perf_unit 대체), 표 열 숨기기(열만, 합계 그대로)
  표 열 너비는 사람(브라우저)마다 그대로

매출 실적·광고비 공통
- 일 합계 열을 날짜 오른쪽으로, 날짜와 함께 가로 고정
- 이전달·다음달 = 날짜 바로 옆 진한 회색 화살표 SVG(글자 높이)
- 광고비 탭 매출 대비 광고비·합계 ROAS 도 공동구매 이중 합산 제거

CSS·JS 캐시 버전 20261102a. 새 마이그레이션 없음(011 perf_settings 사용).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 12:21:33 +09:00
83 changed files with 4762 additions and 466 deletions
+5
View File
@@ -161,6 +161,11 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# 초기화: scripts/sql/outreach_db_init.sql (docs/DEPLOYMENT.md "안내문 발송 DB 생성"). 미설정 시 "설정 필요" 안내만.
# OUTREACH_DB_URL=postgresql://outreach_app:replace-me@postgres-db:5432/outreach_db
# ─── 라이브 커머스 모듈 (live_db) — app/modules/live ───
# 말레이시아 라이브 방송의 호스트 정보·방송 스케줄·판매금액·결과 이미지.
# 초기화: scripts/sql/live_db_init.sql (docs/DEPLOYMENT.md "라이브 커머스 DB 생성"). 미설정 시 "설정 필요" 안내만.
# LIVE_DB_URL=postgresql://live_app:replace-me@postgres-db:5432/live_db
# ─── 상품 검색 (itemcode_db 읽기 전용) ───
# cupang 설정 화면에서 제품명을 itemcode_db 에서 검색해 등록한다(읽기만).
# 미설정 시 검색 비활성 → 수동 등록만 가능.
+2
View File
@@ -47,6 +47,7 @@
| `[공지]` `[긴급공지]` | `notice/` | `project_db`(024) | 수퍼관리자 | `docs/NOTICE_MODULE.md` | `erp-notice*` |
| `[자산]` | `asset/` | `asset_db` | `asset` | `docs/ASSET_MODULE.md` | `asset.*` |
| `[안내문 발송]` | `outreach/` | `outreach_db` | `outreach` | (모듈 CLAUDE.md) | `outreach.*` |
| `[라이브커머스]` `[라이브]` | `live/` | `live_db` | `live` | (모듈 CLAUDE.md) | `live.*` |
| `[공통]` `[ERP]` | `app/main.py`, `app/templates/`(셸·로그인·관리자), 인증·권한 | — | — | `docs/PROJECT_OVERVIEW.md`, `docs/DESIGN.md` | `erp*.js/css`, `styles.css` |
| `[배포]` `[서버]` | `docker-compose*.yml`, `Dockerfile`, `scripts/` | — | — | `docs/DEPLOYMENT.md` | — |
| `[DB]` | `scripts/sql/` | — | — | `docs/DATABASES.md` | — |
@@ -62,6 +63,7 @@
- `APP_ENCRYPTION_KEY`: 실적(쇼핑몰·광고 인증) + 입출고(Gmail 토큰).
- 입출고 Gmail 연결(`inout_gmail_tokens`·`/inout/gmail/callback`, `_GMAIL_ORIGINS`): 입출고 발주 메일 + 휴가 메일(`vacation/notify.py`) + 안내문 발송(`outreach/send.py`) — 모두 보내는 사람 본인 Gmail.
- `app/integrations/google_sheets.py`(쿠팡) · `google_slides.py`(프로젝트 회의록 보드).
- `asset/media.py prepare_photo`(이미지 확인·메타데이터 제거): 자산 + 라이브 커머스.
- `app/mail.py`: 프로젝트 알림 메일.
- ERP 모든 화면 스크립트: `erp-notice.js`(공지) · `erp-overdue.js`(프로젝트 마감 알림).
- 아사나식 날짜 팝업: 프로젝트(`project.js` 안) + 공용 복사본 `erp-datepop.js/css`(휴가 신청) — 바꾸면 둘 다.
+19
View File
@@ -26,6 +26,8 @@ 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.live import build_live_store
from .modules.live import router as live_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
@@ -65,6 +67,7 @@ MODULE_LABELS: dict[str, str] = {
"asset": "자산관리",
"inout": "입출고 관리",
"outreach": "안내문 발송",
"live": "라이브 커머스",
"expense_approver": "개인경비",
"vacation_approver": "휴가",
}
@@ -161,6 +164,7 @@ _MODULE_TEMPLATE_DIRS = [
BASE_DIR / "modules" / "notice" / "templates",
BASE_DIR / "modules" / "inout" / "templates",
BASE_DIR / "modules" / "outreach" / "templates",
BASE_DIR / "modules" / "live" / "templates",
]
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.loader = ChoiceLoader(
@@ -233,6 +237,8 @@ app.state.inout_items = build_inout_items()
# 안내문 발송(메일 일괄·인스타 DM 반자동): OUTREACH_DB_URL 없으면 store=None(화면이 "설정 필요" 안내).
# 메일은 보내는 사람 본인 Gmail — 입출고 Gmail 연결(inout_store.inout_gmail_tokens)을 같이 쓴다.
app.state.outreach_store = build_outreach_store(dsn=env("OUTREACH_DB_URL") or None)
# 라이브 커머스(말레이시아 방송 호스트·스케줄): LIVE_DB_URL 없으면 store=None(화면이 "설정 필요" 안내).
app.state.live_store = build_live_store(dsn=env("LIVE_DB_URL") or None)
# 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄.
app.include_router(expense_router)
@@ -247,6 +253,7 @@ app.include_router(asset_router)
app.include_router(notice_router)
app.include_router(inout_router)
app.include_router(outreach_router)
app.include_router(live_router)
def public_url_for(request: Request, route_name: str) -> str:
@@ -459,6 +466,17 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
"status": "ready",
"category": "운영",
},
{
"key": "live",
"title": "라이브 커머스",
"card_title": "라이브 커머스 · Live Commerce", # 메인 카드만 한글·영문 둘 다(사이드바는 짧게)
"subtitle": "Malaysia",
"description": "말레이시아 라이브 방송의 호스트 정보와 방송 스케줄·판매금액·결과 이미지를 관리합니다.",
"url": "/live/",
"health_url": "/live/health",
"status": "ready",
"category": "운영",
},
]
items.append({
"key": "asset", "title": "자산관리", "subtitle": "Asset Management",
@@ -476,6 +494,7 @@ def _icon_svg(name: str) -> str:
paths = {
"inout": '<path d="M3 7l9-4 9 4v10l-9 4-9-4z"/><path d="M3 7l9 4 9-4"/><path d="M12 11v10"/>',
"outreach": '<path d="M22 2 11 13"/><path d="M22 2 15 22l-4-9-9-4z"/>',
"live": '<rect x="2" y="6" width="14" height="12" rx="2"/><path d="m16 11 6-4v10l-6-4"/>',
"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"/>',
+2
View File
@@ -9,6 +9,8 @@
- 카페24 관리자에 들어가지 않고 상품 상세페이지(description HTML) 조회·편집·즉시적용·예약적용·버전 이력.
- 3분할 화면(목록 | HTML 편집기 | 상품 정보 패널).
- HTML 편집기에서 `<img>` 태그에 마우스를 올리면 태그를 오렌지색으로 칠하고 화면 오른쪽에 폭 500px·창 높이로 파일명과 미리보기(상대 경로는 `CAFE24_SHOP_URL` 루트 기준, 색칠 한도 `HL_LIMIT` 초과 소스는 미동작).
- HTML 편집기 `<img>` 안에서 커서 바로 뒤가 `.jpg`/`.gif`/`.png` 일 때 Ctrl+↑/↓ 로 파일명 번호 변경(없음 → `_2` → `_3` …, 내리면 `_2` 다음은 원래 이름, `_2`~`_99` 만 번호로 인식).
- 정보 패널(`routes_product_info.py`, `_side.html`)에서 상품명·판매가·공급가·소비자가, 대표이미지, 옵션(생성/이름·썸네일·표시방식 수정/삭제)·품목(자체코드·추가금액·진열·판매) 수정.
- 대표이미지는 `POST /admin/products/{no}/images` 에 base64 data URI + `image_upload_type=A`.
NNEditor 업로드 경로를 PUT `detail_image` 에 넣는 방식은 적용 안 됨.
@@ -122,7 +122,7 @@
<input type="hidden" name="list_query" value="{{ list_query }}" />
<div class="cf24-editor-bar">
<span class="cf24-shortcuts">단축키: 주석토글[Ctrl+/] · 줄 복사[Alt+Shift+↑↓] · 줄 이동[Alt+↑↓] · 줄 삭제[Shift+Del]</span>
<span class="cf24-shortcuts">단축키: 주석토글[Ctrl+/] · 줄 복사[Alt+Shift+↑↓] · 줄 이동[Alt+↑↓] · 줄 삭제[Shift+Del] · 이미지 번호[Ctrl+↑↓]</span>
<span class="cf24-editor-bar-right">
<input class="cf24-memo" type="text" name="memo" maxlength="200"
placeholder="변경 메모 (버전 이력에 남습니다)" />
@@ -1,7 +1,7 @@
{% extends "erp_base.html" %}
{% block head_extra %}
<link rel="stylesheet" href="/static/cafe24.css?v=20261015a" />
<link rel="stylesheet" href="/static/cafe24.css?v=20261103c" />
{% endblock %}
{% block content %}
@@ -122,6 +122,9 @@
<div class="cf24-modal-body cf24-options-body" id="cf24-options-body"></div>
</div>
</div>
{# 소스의 <img> 위에 마우스를 올리면 화면 오른쪽에 뜨는 미리보기 — setupCodeEditor 가 켜고 끈다. #}
<div class="cf24-img-preview" id="cf24-img-preview" hidden><div class="cf24-img-preview-name"></div><img alt="이미지를 불러올 수 없습니다" /></div>
{% endblock %}
{% block scripts %}
@@ -164,14 +167,42 @@
last = TOKEN_RE.lastIndex;
if (m[1]) { out += '<span class="cf24-t-com">' + esc(m[1]) + "</span>"; continue; }
if (m[2]) { out += '<span class="cf24-t-doc">' + esc(m[2]) + "</span>"; continue; }
out += '<span class="cf24-t-pun">' + esc(m[3]) + "</span>" +
'<span class="cf24-t-tag">' + esc(m[4]) + "</span>" +
paintAttrs(m[5]) +
'<span class="cf24-t-pun">' + esc(m[6]) + "</span>";
var tag = '<span class="cf24-t-pun">' + esc(m[3]) + "</span>" +
'<span class="cf24-t-tag">' + esc(m[4]) + "</span>" +
paintAttrs(m[5]) +
'<span class="cf24-t-pun">' + esc(m[6]) + "</span>";
out += /^img$/i.test(m[4]) ? '<span class="cf24-t-img">' + tag + "</span>" : tag;
}
return out + esc(src.slice(last));
}
// 상대 경로는 쇼핑몰 루트 기준이다: ../img/a.jpg → https://쇼핑몰/img/a.jpg
function imgPreviewUrl(tag) {
var m = tag.match(/\ssrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i);
var src = m && (m[1] || m[2] || m[3]);
var shop = document.getElementById("cf24-url");
if (!src || !shop) return "";
try { return new URL(src, new URL("/", shop.value)).href; }
catch (err) { return ""; }
}
function imgFileName(url) {
var name = new URL(url).pathname.split("/").pop();
// URL 이 한글 파일명을 %XX 로 바꿔 놓으므로 되돌린다.
try { return decodeURIComponent(name); }
catch (err) { return name; }
}
function showImgPreview(url) {
var box = document.getElementById("cf24-img-preview");
var img = box.lastElementChild;
if (url && img.getAttribute("src") !== url) {
img.src = url;
box.firstElementChild.textContent = imgFileName(url);
}
box.hidden = !url;
}
function setupCodeEditor() {
var ta = document.getElementById("cf24-html-pc");
var hl = document.getElementById("cf24-hl-pc");
@@ -337,6 +368,47 @@
applyEdit(from, to, "", lineFrom + col, lineFrom + col);
}
/* Ctrl+↑/↓ — <img> 안에서 커서 바로 뒤가 .jpg/.gif/.png 이면 파일명 번호를 바꾼다.
a.jpg → a_2.jpg → a_3.jpg …, 내릴 때는 _2 다음이 원래 이름. 커서는 확장자 앞에 그대로 둔다.
_2~_99 만 번호로 본다(product_2024.jpg 의 2024 는 번호가 아니다).
조건이 안 맞으면 false — 브라우저 기본 동작을 막지 않는다. */
function stepImgSuffix(up) {
var at = ta.selectionStart, value = ta.value;
if (at !== ta.selectionEnd || !/^\.(jpg|gif|png)/i.test(value.slice(at, at + 4))) return false;
var head = value.slice(value.lastIndexOf("<", at - 1), at);
if (!/^<img\s[^>]*$/i.test(head)) return false;
var m = head.match(/_([2-9]|[1-9]\d)$/);
var n = m ? Number(m[1]) : 1;
if (up ? n >= 99 : !m) return true; // 더 갈 곳이 없다
var next = up ? n + 1 : n - 1;
var text = next < 2 ? "" : "_" + next;
var from = at - (m ? m[0].length : 0);
applyEdit(from, at, text, from + text.length, from + text.length);
return true;
}
/* 이미지 미리보기 — 맨 위 textarea 를 판정에서 잠깐 빼고 색칠 층의 <img> 를 찾는다.
글자 폭을 계산하지 않아 한글·탭·여러 줄 태그에서도 위치가 어긋나지 않는다.
shortcut: HL_LIMIT 초과 소스는 색칠을 안 해 미리보기도 안 뜬다, 그런 상품이 나오면 글자 위치 계산으로 교체. */
var hoverTag = null;
function setHoverTag(tag) {
if (tag === hoverTag) return;
if (hoverTag) hoverTag.classList.remove("cf24-t-img-on");
if (tag) tag.classList.add("cf24-t-img-on");
hoverTag = tag;
showImgPreview(tag ? imgPreviewUrl(tag.textContent) : "");
}
ta.addEventListener("mousemove", function (e) {
ta.style.pointerEvents = "none";
var el = document.elementFromPoint(e.clientX, e.clientY);
ta.style.pointerEvents = "";
setHoverTag(el && el.closest(".cf24-t-img"));
});
ta.addEventListener("mouseleave", function () { setHoverTag(null); });
ta.addEventListener("scroll", sync);
ta.addEventListener("input", function () { dirty = true; refresh(); });
ta.addEventListener("keydown", function (e) {
@@ -356,6 +428,10 @@
else moveLines(isDown);
return;
}
if (e.ctrlKey && !e.altKey && !e.metaKey && !e.shiftKey && (isUp || isDown) && stepImgSuffix(isUp)) {
e.preventDefault();
return;
}
// Shift+Delete — 줄 삭제. (윈도우 기본 동작인 "잘라내기"를 대신한다)
if (e.shiftKey && !e.ctrlKey && !e.altKey && !e.metaKey &&
(e.key === "Delete" || e.code === "Delete")) {
+13
View File
@@ -10,6 +10,7 @@
- 본사 → 공장 제품 제작 발주(발주서 `PO-YYMMDD-NN`). 제품 = `itemcode_db.single_items` 단품만, 검색 `GET /inout/api/items`·저장 때 서버 재확인.
- 물류 입고를 여러 번 나눠 입력, 품목별 발주·입고·미입고.
- 미입고 현황(제품별 합계·발주별·지연).
- 발주 목록 상태 보기(진행 중·완료·종결·취소·전체)는 **사람마다 기억**(2026-11-04) — `inout_settings` 키 `list_status:{이메일}`(마이그레이션 없음, 005 미적용이면 기억만 안 함). 주소에 `status` 가 있으면 저장, 없으면 저장값, 그것도 없으면 진행 중.
- [남은 수량 모두 채우기]를 한 번 더 누르면(= [채운 수량 되돌리기]) 채우기 전 값으로(2026-10-19, `inout.js`).
- 초과 입고는 확인 화면 후 허용(트랜잭션 안에서 발주서 잠그고 판단, `confirm_over`).
- **전체 입고 완료(모든 품목 입고 ≥ 발주, 상태 done·over)면 더 입고 못 함**(2026-10-19) — 화면은 입고 칸·[입고 저장]·사진·[남은 수량 채우기]를 흐리게 disabled, 서버 `_add_receipt` 도 잠근 뒤 거절. 입고 기록을 지우면 다시 열림.
@@ -39,6 +40,9 @@
- **입고 담당 발주 알림 자동 발송**(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 필요).
- **간단 발주 메일**(2026-11-04): 공장 이름에 "대성화학"·"인천공장"이 들어가면(`store.SIMPLE_MAIL_FACTORIES`, 띄어쓰기 무시) 품목 표 = 번호·제품 코드·제품명·수량·**박스당 수량·박스 수**·비고만, 요약 표·글 본문에서도 금액·무게·PP·은을 뺀다(단가가 공장에 나가지 않게). 색상 줄 배경·합계 수량은 그대로.
박스 값은 발주 품목 사본이 아니라 **메일을 만들 때의 상품 정보**(`router._mail_order` → `store.line_boxes`, 뚜껑 있으면 통·뚜껑 따로, 입수 없으면 `-`). 다른 공장 메일엔 박스 칸 없음.
## 입고 요청 메일 (005, 2026-10-19)
- 입고 담당이 **입고 저장** → 발주서 화면 `?rmail={입고 id}` 로 미리보기 팝업이 바로 뜸 → [메일 발송](입고 담당 본인 Gmail, 발주 메일과 같은 연결 — Gmail 연결 권한은 발주·입고 담당 `_require(…, "mail")`). 입고 기록 줄 [보내기/다시 보내기]로 언제든.
@@ -56,6 +60,8 @@
- 입고 저장 때 첨부(브라우저가 2000px JPEG 로 줄임, 10장·10MB, 파일 머리 검사, 입고와 한 트랜잭션, bytea).
- 썸네일·크게 보기·나중에 더하기. 초과 확인은 브라우저가 먼저(사진 유지).
- **돌리기**(2026-11-02) — 크게 보기 창 왼쪽·오른쪽 버튼(입고 담당) → `POST /inout/orders/{id}/photos/{pid}/rotate?degrees=90|270` → 서버가 **저장된 사진 자체**를 돌려 덮어씀(`store.rotate_image`, EXIF 회전을 픽셀에 반영, 같은 형식, JPEG 품질 92) — 원본 링크·입고 요청 메일도 돌린 사진. 되돌리기 = 반대로 돌리기. HEIC·움직이는 GIF 는 못 돌림(HEIC 은 버튼 숨김).
사진 응답은 `no-cache` + ETag(돌린 뒤 예전 사진이 캐시에 남지 않게).
## 상품 정보 (004, 옵션 세 번째 탭)
@@ -91,6 +97,13 @@
- 화면 계산만 — 발주 품목 사본·발주서 화면·**발주 메일에는 넣지 않음**(사용자 지정). 값은 지금 상품 정보(`_form_page` 의 `body_per_box`, `/api/items`).
- 007 확인 `db.boxes_ready`(groups_ready 와 같은 방식 — 연결 열기 전, 미적용 1분 기억). 그룹·색상 조회(`_PRODUCT_SELECT_006`)는 `p.*` 라 새 열이 따라온다.
## 봉투·백 (008, 2026-11-04)
- 이름에 **"미라클 봉투"·"미라클백"** 이 들어간 상품(`store.is_bag`, 저장 안 함 — 이름으로 판단) = 옵션 → 상품 정보에서 일반 상품과 **표를 나눔**(봉투·백 표가 위). 칸: **박스당 수량**(`body_per_box` 재사용)·**1파렛트당 박스 수량**(`inout_products.boxes_per_pallet`). 뚜껑 없음(저장하면 `lid_per_box` 는 NULL).
**단가·무게·은 칸 없음**(2026-11-04 사용자 지정) — 전에 넣은 값은 줄의 숨은 칸으로 저장 때 그대로 보내 지우지 않음. 그룹·색상 칸은 있음. 새 발주서 "단가 없는 N종"·발주서 화면과 발주 메일의 "단가 미입력 N종"(`store.order_totals`) 안내에서 봉투·백은 뺌.
- 새 발주서 합계 줄에 봉투·백 박스·파렛트를 **통·뚜껑과 따로** 표시: 파렛트 = ⌈Σ(박스 ÷ 그 상품 1파렛트 박스)⌉. 파렛트 그림도 통처럼(`palletVis(all, cap, mixed)`, 그림 칸은 60칸까지) — 1파렛트 박스 수가 다른 상품이 섞이면 가장 큰 값으로 환산해 잔량은 %만. 입수·1파렛트 값은 `store.box_info`(`_form_page`·`/api/items`).
- 008 확인 `db.bags_ready`(boxes_ready 와 같은 방식). 미적용이면 모두 일반 상품으로 동작.
## 오른쪽 달력 (2026-10-21)
- 입출고 **모든 화면** 2열(`.io-split` = 왼쪽 `section.io` | 오른쪽 `_calendar.html`, 1100px 미만은 한 열 300px). 스크롤해도 위에 붙음.
+50
View File
@@ -432,6 +432,19 @@ class InoutDBStore:
if not row:
raise ValueError("사진을 찾을 수 없습니다.")
def rotate_receipt_photo(self, order_id: int, photo_id: int, degrees: int) -> None:
"""저장된 사진 자체를 돌린다(2026-11-02) — 화면·원본·입고 요청 메일 모두 돌린 사진."""
with self._pool.connection() as conn, conn.transaction():
head = self._lock_order(conn, order_id)
if head["cancelled_at"]:
raise ValueError("취소된 발주서입니다.")
row = conn.execute("SELECT p.data FROM inout_receipt_photos p JOIN inout_receipts r ON r.id = p.receipt_id "
"WHERE p.id=%s AND r.order_id=%s", (photo_id, order_id)).fetchone()
if not row:
raise ValueError("사진을 찾을 수 없습니다.")
data = store.rotate_image(bytes(row["data"]), degrees)
conn.execute("UPDATE inout_receipt_photos SET data=%s, size_bytes=%s WHERE id=%s", (data, len(data), photo_id))
def get_photo(self, photo_id: int) -> dict[str, Any] | None:
"""사진 내용(+ 발주서 id) — 보여 주기용."""
try:
@@ -510,6 +523,22 @@ class InoutDBStore:
except UndefinedTable:
raise ValueError("DB 마이그레이션 inout_db 005(물류센터 이메일·입고 요청 메일)가 아직 적용되지 않았습니다.") from None
# 발주 목록 상태 거르기 — 사람마다 기억(2026-11-04). 같은 설정 표에 사람별 키(마이그레이션 없음), 005 미적용이면 기억만 안 한다.
def get_list_status(self, email: str) -> str:
try:
with self._pool.connection() as conn:
row = conn.execute("SELECT value FROM inout_settings WHERE key = %s",
("list_status:" + _norm_email(email),)).fetchone()
except UndefinedTable:
return ""
return row["value"] if row else ""
def save_list_status(self, email: str, status: str) -> None:
try:
self.save_settings({"list_status:" + _norm_email(email): status}, by=email)
except ValueError:
pass
def receipt_photo_data(self, receipt_id: int) -> list[dict[str, Any]]:
"""입고 1건의 사진 내용(메일 본문에 넣기) — 올린 순서."""
try:
@@ -608,7 +637,12 @@ class InoutDBStore:
self._need_products()
grouped = self.groups_ready() and any("group_id" in r for r in rows)
boxed = self.boxes_ready() and any("body_per_box" in r for r in rows)
bagged = self.bags_ready() and any("boxes_per_pallet" in r for r in rows)
with self._pool.connection() as conn, conn.transaction():
if bagged: # 008 — 봉투·백 1파렛트당 박스 수량
for r in rows:
if "boxes_per_pallet" in r:
conn.execute("UPDATE inout_products SET boxes_per_pallet=%s WHERE item_code=%s", (r["boxes_per_pallet"], r["code"]))
if boxed: # 007 — 통·뚜껑 박스 입수(그룹과 무관, 상품마다)
for r in rows:
if "body_per_box" in r:
@@ -730,6 +764,22 @@ class InoutDBStore:
self._boxes_checked = time.monotonic()
return ok
def bags_ready(self) -> bool:
"""008 이 적용됐나(상품 boxes_per_pallet). boxes_ready 와 같은 방식."""
if getattr(self, "_bags_ok", False):
return True
if time.monotonic() - getattr(self, "_bags_checked", -1e9) < 60:
return False
if not self.products_ready():
return False
with self._pool.connection() as conn:
ok = bool(conn.execute(
"SELECT EXISTS (SELECT 1 FROM information_schema.columns WHERE table_name = 'inout_products' "
"AND column_name = 'boxes_per_pallet') AS ok").fetchone()["ok"])
self._bags_ok = ok
self._bags_checked = time.monotonic()
return ok
def _need_groups(self) -> None:
if not self.groups_ready():
raise ValueError("DB 마이그레이션 inout_db 006(상품 그룹·색상)이 아직 적용되지 않았습니다.")
+44 -10
View File
@@ -11,7 +11,7 @@
GET /inout/settings?panel=1 옵션 팝업 내용(톱니, ERP 관리자) — 공장 목록·발주 담당·입고 담당
POST /inout/settings/… 옵션 저장 — 팝업(X-Inout-Options: 1)이면 JSON, 아니면 목록으로 이동
POST /inout/settings/products/import|save · /products/{code}/exclude|restore 옵션 → 상품 정보(단가·무게·은 함유량, 004)
POST /inout/orders/{id}/receipts/{rid}/photos · /orders/{id}/photos/{pid}/delete · GET /inout/photos/{pid} 입고증 사진
POST /inout/orders/{id}/receipts/{rid}/photos · /orders/{id}/photos/{pid}/delete|rotate · GET /inout/photos/{pid} 입고증 사진
GET|POST /inout/orders/{id}/mail 발주 메일 미리보기·발송(발주 담당 본인 Gmail, 사람이 눌러야 보냄)
GET|POST /inout/orders/{id}/receipts/{rid}/mail 입고 요청 메일(물류센터, 입고 담당 본인 Gmail, 005)
POST /inout/settings/logistics 옵션 → 물류센터(입고 요청 메일 받는 주소·참조, 005)
@@ -171,13 +171,17 @@ def _opt_date(v: Any) -> date | None:
# 발주 목록 · 미입고 현황
# ────────────────────────────────────────────────────────────
@router.get("/", response_class=HTMLResponse)
def index(request: Request, status: str = "active", factory: str = "", q: str = "", date_from: str = Query("", alias="from"),
def index(request: Request, status: str = "", factory: str = "", q: str = "", date_from: str = Query("", alias="from"),
date_to: str = Query("", alias="to")) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
status = status if status in store.STATUS_FILTERS else "active"
saved = st.get_list_status(user.get("email", ""))
if status not in store.STATUS_FILTERS: # 주소에 상태가 없으면 이 사람이 마지막으로 고른 보기
status = saved if saved in store.STATUS_FILTERS else "active"
elif status != saved:
st.save_list_status(user.get("email", ""), status)
orders = st.list_orders(status=status, factory_id=_opt_int(factory), q=q, date_from=_opt_date(date_from),
date_to=_opt_date(date_to))
return _render(request, "inout/index.html", user, {
@@ -263,7 +267,7 @@ def _form_page(request: Request, user: dict[str, Any], st: Any, *, order: dict[s
ln["price"] = float(price) if price is not None else None
ln["price_label"] = store.fmt_num(price) if price is not None else ""
bx = boxes.get(ln["code"]) or {} # 박스 입수(007) — 지금 상품 정보 값(발주 품목에 남기지 않음)
ln["body_per_box"], ln["lid_per_box"] = bx.get("body_per_box"), bx.get("lid_per_box")
ln.update(store.box_info(bx))
reader = _items(request)
catalog_n = st.catalog_count()
return _render(request, "inout/order_form.html", user, {
@@ -486,7 +490,7 @@ def receipt_delete(request: Request, order_id: int, receipt_id: int) -> Any:
_PHOTO_HEADERS = {
"X-Content-Type-Options": "nosniff",
"Content-Security-Policy": "default-src 'none'; img-src 'self'; style-src 'unsafe-inline'; sandbox",
"Cache-Control": "private, max-age=86400",
"Cache-Control": "private, no-cache",
}
@@ -530,6 +534,21 @@ def receipt_photo_delete(request: Request, order_id: int, photo_id: int) -> Any:
return _redirect(f"/inout/orders/{order_id}", "사진을 지웠습니다.")
@router.post("/orders/{order_id}/photos/{photo_id}/rotate")
def receipt_photo_rotate(request: Request, order_id: int, photo_id: int, degrees: int = Query(...)) -> Any:
"""크게 보기 창의 회전 버튼 — 창을 닫지 않게 JSON 으로 답한다(화면이 사진을 다시 받아 그림)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
try:
st.rotate_receipt_photo(order_id, photo_id, degrees)
except (ValueError, LookupError) as exc:
return JSONResponse({"error": str(exc)}, status_code=400)
return JSONResponse({"ok": True})
@router.get("/photos/{photo_id}")
def photo_view(request: Request, photo_id: int) -> Response:
_user(request)
@@ -537,12 +556,18 @@ def photo_view(request: Request, photo_id: int) -> Response:
row = st.get_photo(photo_id) if st is not None else None
if row is None:
raise HTTPException(status_code=404, detail="사진을 찾을 수 없습니다.")
from hashlib import md5 # noqa: WPS433
from urllib.parse import quote # noqa: WPS433
data = bytes(row["data"])
# 돌린 사진이 하루 동안 예전 모습으로 남지 않게 — 브라우저가 매번 내용이 같은지 묻는다(no-cache + ETag)
etag = '"' + md5(data, usedforsecurity=False).hexdigest() + '"'
if request.headers.get("if-none-match") == etag:
return Response(status_code=304, headers={"ETag": etag, "Cache-Control": _PHOTO_HEADERS["Cache-Control"]})
name = quote(str(row["filename"] or f"photo-{photo_id}"))
disp = "attachment" if row["content_type"] == "image/heic" else "inline" # HEIC 은 브라우저가 못 보여 줌 → 내려받기
return Response(content=bytes(row["data"]), media_type=row["content_type"],
headers={**_PHOTO_HEADERS, "Content-Disposition": f"{disp}; filename*=UTF-8''{name}"})
return Response(content=data, media_type=row["content_type"],
headers={**_PHOTO_HEADERS, "ETag": etag, "Content-Disposition": f"{disp}; filename*=UTF-8''{name}"})
# ────────────────────────────────────────────────────────────
@@ -638,7 +663,8 @@ async def _gmail_callback_vacation(request: Request) -> Any:
user = get_current_user_record(request)
if user is None:
return RedirectResponse(url="/login?next=" + quote(nxt, safe=""), status_code=303)
if not has_module(user, origin):
# 휴가 협의자는 휴가 권한이 없어도 연결한다 — 휴가 연결 시작 때 그 신청의 협의자인지 확인해 세션에 남긴 값(2026-11-02)
if not request.session.pop("_gmail_consultant", False) and not has_module(user, origin):
raise HTTPException(status_code=403, detail=denied)
st = _store(request)
if st is None:
@@ -683,6 +709,10 @@ def _mail_order(request: Request, order_id: int) -> tuple[Any, dict[str, Any], d
order = _order_or_404(st, order_id)
if order["cancelled_at"]:
raise HTTPException(status_code=400, detail="취소된 발주서는 메일로 보낼 수 없습니다.")
if store.is_simple_mail_factory(order["factory_name"]) and st.boxes_ready(): # 박스 칸 — 발주 품목에 없어 지금 상품 정보 값
found = st.catalog_lookup([x["item_code"] for x in order["lines"]])
for x in order["lines"]:
x.update(store.box_info(found.get(x["item_code"]) or {}))
return st, user, order
@@ -913,8 +943,10 @@ def _options_ctx(request: Request, st: Any) -> dict[str, Any]:
known.add(e)
reader = _items(request)
products = st.list_products()
bags_ready = st.bags_ready()
for pr in products:
pr["silver_g"] = store.silver_g(pr.get("weight_g"), pr.get("silver_pct"))
pr["is_bag"] = bags_ready and store.is_bag(pr.get("item_name"))
return {"products": products, "excluded": st.list_excluded(), "products_ready": st.products_ready(),
"groups": st.list_groups(), "groups_ready": st.groups_ready(), "colors": store.COLORS,
"boxes_ready": st.boxes_ready(),
@@ -1073,7 +1105,9 @@ def settings_products_save(request: Request, payload: dict[str, Any] = Body(...)
code = str((r or {}).get("code") or "").strip().upper()
try:
row = {"code": code, **store.validate_product_values(r)}
if "body_per_box" in (r or {}): # 007 — 통·뚜껑 박스 입수(빈칸 = 없음)
if "boxes_per_pallet" in (r or {}): # 008 — 봉투·백(박스당 수량·1파렛트당 박스 수량)
row.update(store.validate_bag_values(r))
elif "body_per_box" in (r or {}): # 007 — 통·뚜껑 박스 입수(빈칸 = 없음)
row.update(store.validate_box_values(r))
if "group_id" in (r or {}): # 006 — 그룹(빈칸 = 그룹 없음)·상품 자기 색상
gid = str(r.get("group_id") or "").strip()
@@ -1172,7 +1206,7 @@ def api_items(request: Request, q: str = "") -> JSONResponse:
"weight_g": store.fmt_num(r["weight_g"]) if r["weight_g"] is not None else "",
"silver_pct": store.fmt_num(r["silver_pct"], 4) if r["silver_pct"] is not None else "",
"color": r.get("color") or "none",
"body_per_box": r.get("body_per_box"), "lid_per_box": r.get("lid_per_box")} for r in rows]})
**store.box_info(r)} for r in rows]})
reader = _items(request)
if reader is None or not reader.enabled:
return JSONResponse({"items": [], "enabled": False,
+123 -27
View File
@@ -248,6 +248,28 @@ def parse_emails(raw: Any, *, label: str = "이메일", required: bool = False)
return out
# 간단 발주 메일(2026-11-04) — 이 공장들엔 품목 표를 번호·제품 코드·제품명·수량·박스당 수량·박스 수·비고만, 요약에서도 금액·무게·은을 뺀다.
SIMPLE_MAIL_FACTORIES = ("대성화학", "인천공장")
def is_simple_mail_factory(name: Any) -> bool:
"""이름 일부·띄어쓰기가 달라도 맞게 — 놓치면 단가가 공장에 나간다."""
compact = "".join(str(name or "").split())
return any(word in compact for word in SIMPLE_MAIL_FACTORIES)
def line_boxes(x: dict[str, Any]) -> dict[str, Any]:
"""간단 발주 메일 칸 — 박스당 수량·박스 수(올림). 뚜껑이 있으면 통·뚜껑 따로, 입수가 없으면 '-'(total None)."""
body, lid, qty = x.get("body_per_box"), x.get("lid_per_box"), int(x["qty"])
if not body:
return {"per": "-", "count": "-", "total": None}
boxes = -(-qty // body)
if not lid:
return {"per": f"{body:,}개", "count": f"{boxes:,}박스", "total": boxes}
lids = -(-qty // lid)
return {"per": f"통 {body:,}개 · 뚜껑 {lid:,}개", "count": f"통 {boxes:,} · 뚜껑 {lids:,}박스", "total": boxes + lids}
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)
@@ -263,16 +285,18 @@ def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) ->
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}"))
simple = is_simple_mail_factory(order.get("factory_name"))
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 not simple:
if money["amount"] is not None:
note = f" (단가 미입력 {money['missing_price']}종 제외)" if money["missing_price"] else ""
facts.append(("발주 금액", f"{fmt_num(money['amount'])}원{note}"))
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"]))
@@ -289,12 +313,17 @@ def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) ->
# 글 본문(HTML 을 못 보는 메일 프로그램용)
text = [greet, "", "아래와 같이 제품 제작을 발주합니다.", ""]
text += [f"- {k}: {v}" for k, v in facts]
text += ["", "[발주 품목] 수량 · 단가 · 금액 · 전체 무게 · PP 사용량 · 은 함유량"]
text += ["", "[발주 품목] 제품 코드 · 제품명 · 수량 · 박스당 수량 · 박스 수 · 비고" if simple else "[발주 품목] 수량 · 단가 · 금액 · 전체 무게 · 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']}"
b = line_boxes(x)
if simple:
detail = f" · 박스당 {b['per']} · {b['count']}" if b["total"] is not None else ""
else:
detail = (f" · 단가 {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']}")
text.append(f"{i}. {x['item_code']} {x['item_name']} — {int(x['qty']):,}개{detail}"
+ (f" ({x['memo']})" if x.get("memo") else ""))
text += ["", "입고 예정일까지 물류로 입고 부탁드리며, 일정이 바뀌면 회신 부탁드립니다.", "", f"발주 담당: {who} ({sender_email})"]
# HTML 본문 — 값은 모두 escape
@@ -323,12 +352,14 @@ def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) ->
hexc = color_hex(x.get("color"))
ctd = f"{td}background:{hexc};" if hexc else td
tr_style = f' style="background:{hexc}"' if hexc else ""
b = line_boxes(x)
detail = (f'<td style="{ctd}{r}">{e(b["per"])}</td><td style="{ctd}{r}">{e(b["count"])}</td>') if simple else (
f'<td style="{ctd}{r}">{e(c["price"])}</td><td style="{ctd}{r}">{e(c["amount"])}</td>'
f'<td style="{ctd}{r}">{e(c["weight"])}</td><td style="{ctd}{r}">{e(c["pp_use"])}</td><td style="{ctd}{r}">{e(c["ag"])}</td>')
rows.append(
f'<tr{tr_style}><td style="{ctd}text-align:center">{i}</td>'
f'<td style="{ctd}font-family:Consolas,monospace">{e(x["item_code"])}</td>'
f'<td style="{ctd}">{e(x["item_name"])}</td><td style="{ctd}{r}">{int(x["qty"]):,}</td>'
f'<td style="{ctd}{r}">{e(c["price"])}</td><td style="{ctd}{r}">{e(c["amount"])}</td>'
f'<td style="{ctd}{r}">{e(c["weight"])}</td><td style="{ctd}{r}">{e(c["pp_use"])}</td><td style="{ctd}{r}">{e(c["ag"])}</td>'
f'<td style="{ctd}">{e(x["item_name"])}</td><td style="{ctd}{r}">{int(x["qty"]):,}</td>{detail}'
f'<td style="{ctd}">{e(x.get("memo") or "")}</td></tr>')
# 합계 줄(2026-10-21) — 금액 뒤 " 원", 무게 뒤 " kg", 무게는 소수 첫째 자리에서 반올림(정수 kg)
foot_amount = f'{fmt_num(money["amount"])} 원' if money["amount"] is not None else ""
@@ -336,6 +367,16 @@ def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) ->
foot_use = f'{fmt_num(money["pp_use_kg"], 0)} kg' if money["pp_use_kg"] is not None else ""
foot_ag = f'{fmt_num(ag_kg, 0)} kg' if ag_kg is not None else ""
bg = "background:#f6f7f9;"
box_totals = [t for t in (line_boxes(x)["total"] for x in lines) if t is not None]
foot_boxes = f"{sum(box_totals):,}박스" if box_totals else ""
if box_totals and len(box_totals) < len(lines):
foot_boxes += f" (미설정 {len(lines) - len(box_totals)}종 제외)"
head_detail = f'<th style="{td}">박스당 수량</th><th style="{td}">박스 수</th>' if simple else (
f'<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>')
foot_detail = f'<th style="{td}{bg}"></th><th style="{td}{bg}{r}">{e(foot_boxes)}</th>' if simple else (
f'<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>')
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>"
@@ -343,14 +384,12 @@ def order_mail(order: dict[str, Any], *, sender_name: str, sender_email: str) ->
# 두 표 사이 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'<thead><tr style="{bg}"><th style="{td}">{"번호" if simple else "No"}</th><th style="{td}">제품 코드</th><th style="{td}">제품명</th>'
f'<th style="{td}">수량</th>{head_detail}'
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}{r}">{total:,}</th>{foot_detail}'
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>'
@@ -547,7 +586,8 @@ def order_totals(lines: list[dict[str, Any]]) -> dict[str, Any]:
q = int(x["qty"])
a = line_amount(q, x.get("unit_price"))
if a is None:
missing += 1
if not is_bag(x.get("item_name")): # 봉투·백은 단가가 원래 없음 — "단가 미입력" 안내에서 뺀다
missing += 1
else:
amount = (amount or Decimal(0)) + a
w = to_dec(x.get("weight_g"))
@@ -557,7 +597,7 @@ def order_totals(lines: list[dict[str, Any]]) -> dict[str, Any]:
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,
return {"amount": amount, "missing_price": missing, "pp_kg": pp, "silver_g": ag,
"pp_use_kg": use}
@@ -586,7 +626,8 @@ def validate_product_values(values: dict[str, Any]) -> dict[str, Decimal | None]
def has_values(p: dict[str, Any]) -> bool:
"""단가·무게·은 함유량(·그룹·색상 006·박스 입수 007) 중 하나라도 넣었나 — 넣은 상품은 다시 불러와도 그대로 둔다."""
return (any(p.get(k) is not None for k in PRODUCT_LIMITS) or p.get("group_id") is not None
or (p.get("color") or "none") != "none" or any(p.get(k) is not None for k in BOX_FIELDS))
or (p.get("color") or "none") != "none" or any(p.get(k) is not None for k in BOX_FIELDS)
or p.get("boxes_per_pallet") is not None)
# ════════════════════════════════════════════════════════════
@@ -598,9 +639,9 @@ MAX_PER_BOX = 1_000_000
PALLET_BOXES = 30
def parse_per_box(raw: Any, *, key: str) -> int | None:
def parse_per_box(raw: Any, *, key: str = "", label: str = "") -> int | None:
"""박스 입수 칸 하나 — 빈칸은 None(없음·미입력), 1 이상 정수(쉼표 허용)."""
label = BOX_FIELDS[key]
label = label or BOX_FIELDS[key]
s = str(raw if raw is not None else "").replace(",", "").strip()
if not s:
return None
@@ -608,7 +649,7 @@ def parse_per_box(raw: Any, *, key: str) -> int | None:
raise ValueError(f"{label}은(는) 1 이상 정수로 입력하세요.")
n = int(s)
if n < 1:
raise ValueError(f"{label}은(는) 1 이상이어야 합니다(뚜껑이 없으면 빈칸).")
raise ValueError(f"{label}은(는) 1 이상이어야 합니다(없으면 빈칸).")
if n > MAX_PER_BOX:
raise ValueError(f"{label}이(가) 너무 큽니다.")
return n
@@ -618,6 +659,26 @@ def validate_box_values(values: dict[str, Any]) -> dict[str, int | None]:
return {k: parse_per_box(values.get(k), key=k) for k in BOX_FIELDS}
# 봉투·백(2026-11-04, 마이그레이션 008) — 이름으로 판단(저장 안 함). 뚜껑 없음, 박스당 수량 = body_per_box, 1파렛트 박스 수는 상품마다.
BAG_NAME_WORDS = ("미라클 봉투", "미라클백")
def is_bag(name: Any) -> bool:
return any(word in str(name or "") for word in BAG_NAME_WORDS)
def validate_bag_values(values: dict[str, Any]) -> dict[str, int | None]:
return {"body_per_box": parse_per_box(values.get("body_per_box"), label="박스당 수량"), "lid_per_box": None,
"boxes_per_pallet": parse_per_box(values.get("boxes_per_pallet"), label="1파렛트당 박스 수량")}
def box_info(row: dict[str, Any]) -> dict[str, Any]:
"""발주서 화면 박스 계산 값 — 008 미적용(열 없음)이면 모두 일반 상품으로."""
bag = "boxes_per_pallet" in row and is_bag(row.get("item_name"))
return {"body_per_box": row.get("body_per_box"), "lid_per_box": None if bag else row.get("lid_per_box"),
"is_bag": bag, "boxes_per_pallet": row.get("boxes_per_pallet") if bag else None}
# ════════════════════════════════════════════════════════════
# 상품 그룹·색상(2026-10-21, 마이그레이션 006)
# 그룹에 은 함유량·색상을 한 번만 — 그룹 상품은 그룹 값, 그룹 없는 상품은 자기 값(effective_product).
@@ -700,6 +761,41 @@ def validate_photos(files: list[tuple[str, bytes]], *, existing: int = 0) -> lis
return out
def rotate_image(data: bytes, degrees: int) -> bytes:
"""사진 내용을 시계 방향 90·270도로 돌려 같은 형식으로(2026-11-02). 휴대폰 사진의 회전 정보(EXIF)는 픽셀에 반영한 뒤 돌린다."""
from io import BytesIO # noqa: WPS433
from PIL import Image, ImageOps # noqa: WPS433
if degrees not in (90, 270):
raise ValueError("사진은 왼쪽·오른쪽으로만 돌릴 수 있습니다.")
kind = sniff_image(data)
if kind == "image/heic":
raise ValueError("HEIC 사진은 돌릴 수 없습니다 — JPG 로 바꿔 다시 올려 주세요.")
try:
im = Image.open(BytesIO(data))
if getattr(im, "n_frames", 1) > 1:
raise ValueError("움직이는 사진은 돌릴 수 없습니다.")
icc = im.info.get("icc_profile")
im = ImageOps.exif_transpose(im)
# PIL 의 ROTATE_n 은 반시계 방향 — 시계 90도 = ROTATE_270
im = im.transpose(Image.Transpose.ROTATE_270 if degrees == 90 else Image.Transpose.ROTATE_90)
fmt = {"image/jpeg": "JPEG", "image/png": "PNG", "image/webp": "WEBP", "image/gif": "GIF"}[kind]
opts: dict[str, Any] = {"icc_profile": icc} if icc and fmt != "GIF" else {}
if fmt in ("JPEG", "WEBP"):
opts["quality"] = 92
buf = BytesIO()
im.save(buf, format=fmt, **opts)
except ValueError:
raise
except Exception as exc: # noqa: BLE001 — 깨진 파일 등(원본은 그대로 둔다)
raise ValueError("이 사진은 돌릴 수 없습니다.") from exc
out = buf.getvalue()
if len(out) > MAX_PHOTO_BYTES:
raise ValueError(f"돌린 사진이 너무 큽니다(한 장 {MAX_PHOTO_BYTES // 1024 // 1024}MB까지).")
return out
# ════════════════════════════════════════════════════════════
# 입고 요청 메일(2026-10-19, 마이그레이션 005) — 입고 담당이 입고를 저장한 뒤 물류센터 입고 담당자에게
# "전산 등록 부탁" 메일(입고 담당 본인 Gmail). 받는 사람 = 옵션 → 물류센터 이메일, 참조 기본 = king@·bj@dbxcorp.co.kr.
@@ -141,6 +141,7 @@
값을 넣은 상품은 다시 불러와도 그대로이고, 지운 단품은 다음 불러오기에서 빠집니다. 발주서 제품은 이 목록에서 고르며, 발주할 때의 값이 발주서에 남습니다.
{% if groups_ready %}<b>그룹</b>을 고른 상품은 은 함유량·<b>색상</b>을 그룹 값으로 씁니다(<b>상품 그룹</b> 탭에서 한 번만 설정).{% endif %}
{% if boxes_ready %}<b>통 수량(박스)</b>·<b>뚜껑 수량(박스)</b> = 통·뚜껑이 한 박스에 몇 개씩 들어가는지(뚜껑이 없으면 빈칸) — 새 발주서에서 박스 수·파렛트 수를 계산합니다.{% endif %}
이름에 "미라클 봉투"·"미라클백"이 들어간 상품은 <b>봉투·백</b> 표에서 <b>박스당 수량</b>·<b>1파렛트당 박스 수량</b>을 넣습니다(단가·무게·은 없음).
</p>
<div class="io-prod-bar">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" id="io-prod-import">단품 불러오기</button>
@@ -151,14 +152,23 @@
</div>
{% if products %}
<div class="io-prod-scroll">
{# 봉투·백(008) = 일반 상품과 표를 나눔, 짧은 목록이라 위에. 박스 칸 두 개만 다르고 나머지 칸은 같다 #}
{% set bags = products|selectattr('is_bag')|list %}
{% for bag_table, rows in [(true, bags), (false, products|rejectattr('is_bag')|list)] if rows %}
<div class="io-prod-part">
{% if bags %}<div class="io-prod-part-title">{{ '봉투·백' if bag_table else '일반 상품' }} <span class="io-sub">{{ rows|length }}개</span></div>{% endif %}
<table class="io-dlg-table io-prod-table{% if groups_ready %} has-groups{% endif %}">
<colgroup><col class="w-code" /><col />{% if groups_ready %}<col class="w-group" />{% endif %}<col class="w-num" /><col class="w-num" /><col class="w-num" /><col class="w-ag" />{% if boxes_ready %}<col class="w-box" /><col class="w-box" />{% endif %}{% if groups_ready %}<col class="w-color" />{% endif %}<col class="w-del" /></colgroup>
<thead><tr><th>코드</th><th>제품명</th>{% if groups_ready %}<th>그룹</th>{% endif %}<th class="io-r">단가(원)</th><th class="io-r">무게·PP(g/개)</th><th class="io-r">은 함유량(%)</th><th class="io-r">은(g/개)</th>{% if boxes_ready %}<th title="통이 한 박스에 몇 개">통 수량(박스)</th><th title="뚜껑이 한 박스에 몇 개 — 뚜껑이 없으면 빈칸">뚜껑 수량(박스)</th>{% endif %}{% if groups_ready %}<th>색상</th>{% endif %}<th></th></tr></thead>
<colgroup><col class="w-code" /><col />{% if groups_ready %}<col class="w-group" />{% endif %}{% if not bag_table %}<col class="w-num" /><col class="w-num" /><col class="w-num" /><col class="w-ag" />{% endif %}{% if boxes_ready %}<col class="w-box" /><col class="w-box" />{% endif %}{% if groups_ready %}<col class="w-color" />{% endif %}<col class="w-del" /></colgroup>
<thead><tr><th>코드</th><th>제품명</th>{% if groups_ready %}<th>그룹</th>{% endif %}{% if not bag_table %}<th class="io-r">단가(원)</th><th class="io-r">무게·PP(g/개)</th><th class="io-r">은 함유량(%)</th><th class="io-r">은(g/개)</th>{% endif %}{% if bag_table %}<th title="한 박스에 몇 개">박스당 수량</th><th title="한 파렛트에 몇 박스">1파렛트당 박스 수량</th>{% elif boxes_ready %}<th title="통이 한 박스에 몇 개">통 수량(박스)</th><th title="뚜껑이 한 박스에 몇 개 — 뚜껑이 없으면 빈칸">뚜껑 수량(박스)</th>{% endif %}{% if groups_ready %}<th>색상</th>{% endif %}<th></th></tr></thead>
<tbody>
{% for p in products %}
{% for p in rows %}
{% set own_pct = p.own_silver_pct if groups_ready else p.silver_pct %}
<tr data-code="{{ p.item_code }}" data-search="{{ (p.item_code ~ ' ' ~ p.item_name ~ ' ' ~ (p.group_name or ''))|lower }}"{% if groups_ready and p.group_id %} class="is-grouped"{% endif %}>
<td class="io-code">{{ p.item_code }}</td>
<td class="io-code">{{ p.item_code }}{% if bag_table %}
{# 봉투·백엔 단가·무게·은 칸이 없다 — 전에 넣은 값이 저장 때 지워지지 않게 숨은 칸으로 그대로 보낸다 #}
<input type="hidden" data-key="unit_price" value="{{ fmt_num(p.unit_price) if p.unit_price is not none else '' }}" />
<input type="hidden" data-key="weight_g" value="{{ fmt_num(p.weight_g) if p.weight_g is not none else '' }}" />
<input type="hidden" data-key="silver_pct" value="{{ fmt_num(own_pct, 4) if own_pct is not none else '' }}" />{% endif %}</td>
<td class="io-prod-name">{{ p.item_name }}</td>
{% if groups_ready %}
<td><select class="io-in io-group-select" data-key="group_id" aria-label="{{ p.item_code }} 그룹">
@@ -166,12 +176,17 @@
{% for g in groups %}<option value="{{ g.id }}" data-silver="{{ fmt_num(g.silver_pct, 4) if g.silver_pct is not none else '' }}" data-color="{{ g.color }}" {% if p.group_id == g.id %}selected{% endif %}>{{ g.name }}</option>{% endfor %}
</select></td>
{% endif %}
{% if not bag_table %}
<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 io-own" data-key="silver_pct" value="{{ fmt_num(own_pct, 4) if own_pct is not none else '' }}" inputmode="decimal" aria-label="{{ p.item_code }} 은 함유량" />
{% if groups_ready %}<span class="io-group-val io-r" title="그룹 값 — 그룹에서 바꿉니다">{{ fmt_num(p.silver_pct, 4) if p.silver_pct is not none else '-' }}</span>{% endif %}</td>
<td class="io-r io-ag" title="무게 × 은 함유량 ÷ 100">{{ fmt_num(p.silver_g, 4) if p.silver_g is not none else '-' }}</td>
{% if boxes_ready %}
{% endif %}
{% if bag_table %}
<td><input class="io-in io-in-num" data-key="body_per_box" value="{{ '{:,}'.format(p.body_per_box) if p.body_per_box else '' }}" inputmode="numeric" aria-label="{{ p.item_code }} 박스당 수량" /></td>
<td><input class="io-in io-in-num" data-key="boxes_per_pallet" value="{{ '{:,}'.format(p.boxes_per_pallet) if p.boxes_per_pallet else '' }}" inputmode="numeric" aria-label="{{ p.item_code }} 1파렛트당 박스 수량" /></td>
{% elif boxes_ready %}
<td><input class="io-in io-in-num" data-key="body_per_box" value="{{ '{:,}'.format(p.body_per_box) if p.body_per_box else '' }}" inputmode="numeric" aria-label="{{ p.item_code }} 통 수량(박스)" /></td>
<td><input class="io-in io-in-num" data-key="lid_per_box" value="{{ '{:,}'.format(p.lid_per_box) if p.lid_per_box else '' }}" inputmode="numeric" placeholder="없음" aria-label="{{ p.item_code }} 뚜껑 수량(박스)" /></td>
{% endif %}
@@ -186,6 +201,8 @@
{% endfor %}
</tbody>
</table>
</div>
{% endfor %}
</div>
{% else %}
<p class="io-empty">아직 불러온 단품이 없습니다 — [단품 불러오기]를 누르세요. (그 전에는 발주서에서 코드표 단품을 바로 고릅니다)</p>
+2 -2
View File
@@ -1,6 +1,6 @@
{% 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=20261027b" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261104c" />{% endblock %}
{% block content %}
<div class="io-split">{# 2열 — 왼쪽 화면 | 오른쪽 달력(2026-10-21) #}
@@ -71,4 +71,4 @@
{% include "inout/_calendar.html" %}
</div>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261027b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261104c" defer></script>{% endblock %}
@@ -20,7 +20,7 @@
</footer>
</dialog>
{%- endmacro -%}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261027b" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261104c" />{% endblock %}
{% block content %}
{% set active = order.status in ('open', 'partial') %}
@@ -232,6 +232,10 @@
<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>
{% if photo_admin %}
<button type="button" class="io-viewer-btn io-viewer-rot" data-rotate="270" title="왼쪽으로 돌리기" aria-label="왼쪽으로 돌리기"><svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 4v6h6"/><path d="M3.5 15a9 9 0 1 0 2.1-9.4L3 10"/></svg></button>
<button type="button" class="io-viewer-btn io-viewer-rot" data-rotate="90" title="오른쪽으로 돌리기" aria-label="오른쪽으로 돌리기"><svg viewBox="0 0 24 24" width="16" height="16" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M21 4v6h-6"/><path d="M20.5 15a9 9 0 1 1-2.1-9.4L21 10"/></svg></button>
{% endif %}
<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>
@@ -258,4 +262,4 @@
{% include "inout/_calendar.html" %}
</div>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261027b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261104c" defer></script>{% endblock %}
@@ -1,5 +1,5 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261027b" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261104c" />{% endblock %}
{% block content %}
<div class="io-split">{# 2열 — 왼쪽 화면 | 오른쪽 달력(2026-10-21) #}
@@ -34,7 +34,7 @@
<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 '' }}"{% if boxes_ready %} data-body-box="{{ ln.body_per_box or '' }}" data-lid-box="{{ ln.lid_per_box or '' }}"{% endif %}>
<tr class="io-line" data-price="{{ ln.price if ln.price is not none else '' }}"{% if boxes_ready %} data-body-box="{{ ln.body_per_box or '' }}" data-lid-box="{{ ln.lid_per_box or '' }}" data-bag="{{ '1' if ln.is_bag else '' }}" data-pallet-box="{{ ln.boxes_per_pallet or '' }}"{% endif %}>
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="{{ ln.code }}" />
@@ -64,13 +64,20 @@
<span class="io-pallet-vis" data-k="vis"></span>
<span class="erp-muted" data-k="note">1파렛트 = {{ pallet_boxes }}박스</span>
</div>
{# 봉투·백(008) — 상품마다 1파렛트 박스 수가 달라 통·뚜껑 파렛트와 따로 셈 #}
<div class="io-pallet" id="io-pallet-bag" aria-live="polite" hidden>
<span>봉투·백 <b data-k="boxes">0</b>박스</span>
<span class="io-pallet-main">→ <b data-k="pallets">0</b>파렛트</span>
<span class="io-pallet-vis" data-k="vis"></span>
<span class="erp-muted" data-k="note"></span>
</div>
{% endif %}
</td></tr></tfoot>
</table>
</div>
<template id="io-line-tpl">
<tr class="io-line"{% if boxes_ready %} data-body-box="" data-lid-box=""{% endif %}>
<tr class="io-line"{% if boxes_ready %} data-body-box="" data-lid-box="" data-bag="" data-pallet-box=""{% endif %}>
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="" />
@@ -95,4 +102,4 @@
{% include "inout/_calendar.html" %}
</div>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261027b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261104c" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import due, n, ymd %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261027b" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261104c" />{% endblock %}
{% block content %}
<div class="io-split">{# 2열 — 왼쪽 화면 | 오른쪽 달력(2026-10-21) #}
@@ -91,4 +91,4 @@
{% include "inout/_calendar.html" %}
</div>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261027b" defer></script>{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261104c" defer></script>{% endblock %}
+22
View File
@@ -0,0 +1,22 @@
# [라이브커머스] 라이브 커머스 모듈 — `app/modules/live/`, `live_db`(2026-11-04)
> 이 모듈만 고칠 때 읽는 요약. 별도 상세 문서 없음 — 코드가 기준.
> 정적 파일: `app/static/live.js`, `live.css`. 템플릿: `templates/live/`. 테스트: `tests/test_live.py`(`LIVE_TEST_DB_URL` 이 localhost 일 때 실제 DB).
> 다른 모듈과 연결: 이미지 검사 = 자산 모듈 `app/modules/asset/media.py prepare_photo` 재사용(바꾸면 양쪽 확인).
- 말레이시아 라이브 커머스 방송의 호스트 정보·방송 스케줄. 권한키 `live`, DB `LIVE_DB_URL`(없으면 "설정 필요" 안내).
- **호스트 설정** `/live/settings` — Full Name (as per IC)(필수)·Phone Number·Email·Address·Bank Name·Bank Account Number·Tiktok Handle(`@`·주소를 붙여 넣어도 계정명만 저장).
**계좌 등 개인정보라 ERP 관리자만**(`is_admin`) — 화면·저장·지우기 모두. 스케줄 화면에는 `db.host_choices`(이름·틱톡·사용 여부)만 넘긴다.
사용 안 함 = 새 방송에서 못 고름(그 호스트로 이미 등록된 방송을 고칠 때만 보임). 방송 기록이 있는 호스트는 못 지움(FK RESTRICT).
- **스케줄표** `/live/?month=YYYY-MM`(`live` 권한자 모두) — 호스트·날짜·시작/끝 시간·방송 장소·판매금액·커미션·호스트 비용·결과 이미지. 호스트·날짜·시작·끝 시간 필수(판매금액은 방송 후 입력).
시간은 입력한 말레이시아 시간 그대로(시간대 변환 없음, DATE·TIME). 판매금액 단위 RM(`NUMERIC(14,2)`, `store.parse_money`). 끝 시간이 시작보다 이르면 자정을 넘긴 방송.
- **호스트 비용**(`store.session_pay`, 저장 안 함 — 화면마다 계산) = 시간 × RM 25(`HOURLY_RATE`) + 판매금액 × 10%(`COMMISSION_PERCENT`). 요율이 코드 상수라 바꾸면 지난 방송 금액도 바뀐다.
- **달력 보기** `/live/calendar?month=`(`store.build_calendar`, 사용자가 준 화면 참고, 글자도 영어 그대로) — 줄 = 2시간 칸(06:00~24:00 늘 보임, 그보다 이른 칸은 방송이 있을 때만, 칸은 시작 시간으로 정함), 열 = 날짜, 주말 노랑, Jump to Date, 위 달 합계, 맨 아래 날짜별 TOTAL SALES·AD SPEND·HOST FEE·ROAS.
카드 머리 = **Tiktok Handle**(없으면 이름, 색 = 호스트 id 순 `HOST_COLORS`), SALES·COM·Fee. 카드 머리를 끌어 빈 칸으로 = 옮기기(`move`, 방송 길이 유지) · 다른 카드 위 = 맞바꾸기(`swap_with`, 날짜·시간 교환). 다시 그린 뒤 가로 위치 유지(sessionStorage). 빈 칸 + = 그 날짜·시간이 채워진 추가 창.
**AD SPEND** = 날짜별 광고비 `live_daily_ad_spend`(마이그레이션 002, `POST /live/ad-spend`, 빈칸 = 지우기), ROAS = 판매금액 ÷ 광고비(광고비 없으면 `-`). 002 미적용이면 0 으로 보이고 저장만 안내.
- **결과 이미지** — 방송 저장과 한 트랜잭션, JPG·PNG·WebP, 한 장 8MB, 방송당 10장(`store.MAX_IMAGES`). `prepare_photo` 가 실제 이미지 확인·긴 변 2400px·EXIF(GPS 등) 제거. BYTEA 저장.
`GET /live/images/{id}`(권한 필요, 하루 private 캐시), `?thumb=1` = 160px JPEG(그때그때 만듦). 올린 뒤 내용이 안 바뀐다는 전제 — 이미지를 고치는 기능을 넣으면 캐시도 바꿀 것.
- 저장은 `live.js` 가 fetch → JSON `{ok, message}`(틀려도 창의 입력값 유지). 창 하나로 추가·고치기(`data-edit` JSON).
- **한글·영문 전환**(`i18n.py`) — 위 막대 [한글|EN], 쿠키 `live_lang`(브라우저마다, path=/live, 기본 한글). 한글 문구가 키, 템플릿 `t('…')`, 오류 `LiveError(틀, 값)`(라우터가 언어에 맞게), JS `LV_T`(`JS_KEYS`).
**새 문구는 `i18n.EN` 에도 넣는다** — `tests/test_live.py` 가 빠진 문구와 영문 화면의 한글을 잡는다. 입력한 데이터(이름·장소 등)·ERP 공용 사이드바는 번역하지 않는다.
- 메인 카드 제목 = `main.py` `card_title`(한글·영문), 사이드바는 `title` 그대로.
+21
View File
@@ -0,0 +1,21 @@
"""라이브 커머스(live) 모듈 — 말레이시아 라이브 방송의 호스트 정보와 방송 스케줄(2026-11-04).
- 라우터: `router.py` (prefix=/live) · 저장소: `db.py` (live_db) · 순수 함수: `store.py`(입력 검사·표시 형식)
- 템플릿: `templates/live/`, 화면 스크립트·스타일 `static/live.{js,css}`
LIVE_DB_URL 미설정이면 build_live_store 가 None → 화면이 "설정 필요" 안내(앱은 죽지 않음). 권한키 `live`.
"""
from typing import Any
from .router import router
__all__ = ["router", "build_live_store"]
def build_live_store(*, dsn: str | None) -> Any:
if not dsn:
return None
from .db import LiveDBStore # 지연 import
return LiveDBStore(dsn)
+175
View File
@@ -0,0 +1,175 @@
"""live_db PostgreSQL 저장소 — 라이브 커머스 호스트·방송 스케줄·결과 이미지(2026-11-04).
- 연결: 환경변수 `LIVE_DB_URL` (예: postgresql://live_app:<pwd>@postgres-db:5432/live_db)
- 스키마는 앱이 만들지 않는다 — `scripts/sql/live_db_init.sql` 을 superuser 가 먼저 적용(앱 계정은 CRUD 만).
- 연결 풀은 lazy open — 부팅 때 DB 가 잠시 끊겨도 컨테이너가 죽지 않게(다른 모듈과 같은 방식).
"""
from __future__ import annotations
from datetime import date, time
from decimal import Decimal
from typing import Any
from psycopg.errors import ForeignKeyViolation, UndefinedTable
from psycopg.rows import dict_row
from psycopg_pool import ConnectionPool
from . import store
from .i18n import LiveError
_HOST_COLUMNS = ("full_name", "phone", "email", "address", "bank_name", "bank_account", "tiktok_handle")
class LiveDBStore:
def __init__(self, dsn: str, *, min_size: int = 1, max_size: int = 4):
self._pool = ConnectionPool(conninfo=dsn, min_size=min_size, max_size=max_size,
kwargs={"row_factory": dict_row, "autocommit": True}, open=False)
self._pool.open(wait=False)
def close(self) -> None:
self._pool.close()
# ── 호스트 ─────────────────────────────────────────────
def list_hosts(self) -> list[dict[str, Any]]:
"""전체 정보(계좌 포함) — 설정 화면(ERP 관리자)에서만 쓴다."""
with self._pool.connection() as conn:
return conn.execute("SELECT * FROM live_hosts ORDER BY is_active DESC, full_name, id").fetchall()
def host_choices(self) -> list[dict[str, Any]]:
"""스케줄 화면 호스트 고르기 — 개인정보·계좌는 뺀다."""
with self._pool.connection() as conn:
return conn.execute("SELECT id, full_name, tiktok_handle, is_active FROM live_hosts "
"ORDER BY full_name, id").fetchall()
def save_host(self, host_id: int | None, values: dict[str, str], *, is_active: bool, by: str) -> int:
cols = [values[k] for k in _HOST_COLUMNS]
with self._pool.connection() as conn:
if host_id is None:
row = conn.execute(
"INSERT INTO live_hosts (full_name, phone, email, address, bank_name, bank_account, tiktok_handle, "
"is_active, created_by, updated_by) VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s) RETURNING id",
(*cols, is_active, by, by)).fetchone()
else:
row = conn.execute(
"UPDATE live_hosts SET full_name=%s, phone=%s, email=%s, address=%s, bank_name=%s, bank_account=%s, "
"tiktok_handle=%s, is_active=%s, updated_by=%s WHERE id=%s RETURNING id",
(*cols, is_active, by, host_id)).fetchone()
if not row:
raise LiveError("호스트를 찾을 수 없습니다.")
return int(row["id"])
def delete_host(self, host_id: int) -> None:
try:
with self._pool.connection() as conn:
row = conn.execute("DELETE FROM live_hosts WHERE id=%s RETURNING id", (host_id,)).fetchone()
except ForeignKeyViolation:
raise LiveError("방송 기록이 있는 호스트는 지울 수 없습니다 — 사용 안 함으로 바꾸세요.") from None
if not row:
raise LiveError("호스트를 찾을 수 없습니다.")
# ── 방송 스케줄 ─────────────────────────────────────────
def list_broadcasts(self, start: date, end: date) -> list[dict[str, Any]]:
"""start 이상 end 미만, 날짜·시간 순. 줄마다 images = [{id, filename}](내용 제외)."""
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT b.*, h.full_name AS host_name, h.tiktok_handle FROM live_broadcasts b JOIN live_hosts h ON h.id = b.host_id "
"WHERE b.broadcast_date >= %s AND b.broadcast_date < %s ORDER BY b.broadcast_date, b.start_time, b.id",
(start, end)).fetchall()
images = conn.execute(
"SELECT id, broadcast_id, filename FROM live_broadcast_images WHERE broadcast_id = ANY(%s) ORDER BY id",
([r["id"] for r in rows],)).fetchall()
for r in rows:
r["images"] = [i for i in images if i["broadcast_id"] == r["id"]]
return rows
def save_broadcast(self, broadcast_id: int | None, values: dict[str, Any], images: list[dict[str, Any]], *, by: str) -> int:
"""방송·이미지를 한 트랜잭션으로. 사용 안 함 호스트는 이미 그 호스트인 방송을 고칠 때만 허용."""
with self._pool.connection() as conn, conn.transaction():
current = None
if broadcast_id is not None:
found = conn.execute("SELECT host_id FROM live_broadcasts WHERE id=%s FOR UPDATE", (broadcast_id,)).fetchone()
if not found:
raise LiveError("방송을 찾을 수 없습니다(다른 사람이 지웠을 수 있음).")
current = found["host_id"]
host = conn.execute("SELECT is_active FROM live_hosts WHERE id=%s", (values["host_id"],)).fetchone()
if not host:
raise LiveError("호스트를 찾을 수 없습니다.")
if not host["is_active"] and values["host_id"] != current:
raise LiveError("사용 안 함으로 바뀐 호스트입니다 — 다른 호스트를 고르세요.")
args = (values["host_id"], values["broadcast_date"], values["start_time"], values["end_time"], values["venue"],
values["sales_amount"], by)
if broadcast_id is None:
broadcast_id = int(conn.execute(
"INSERT INTO live_broadcasts (host_id, broadcast_date, start_time, end_time, venue, sales_amount, updated_by, created_by) "
"VALUES (%s,%s,%s,%s,%s,%s,%s,%s) RETURNING id", (*args, by)).fetchone()["id"])
else:
conn.execute("UPDATE live_broadcasts SET host_id=%s, broadcast_date=%s, start_time=%s, end_time=%s, venue=%s, "
"sales_amount=%s, updated_by=%s WHERE id=%s", (*args, broadcast_id))
have = conn.execute("SELECT count(*) AS n FROM live_broadcast_images WHERE broadcast_id=%s", (broadcast_id,)).fetchone()["n"]
if have + len(images) > store.MAX_IMAGES:
raise LiveError("방송 한 건에 이미지는 {max}장까지입니다(지금 {have}장).", max=store.MAX_IMAGES, have=have)
for im in images:
conn.execute("INSERT INTO live_broadcast_images (broadcast_id, filename, content_type, data, width, height, created_by) "
"VALUES (%s,%s,%s,%s,%s,%s,%s)",
(broadcast_id, im["filename"], im["content_type"], im["data"], im["width"], im["height"], by))
return broadcast_id
def delete_broadcast(self, broadcast_id: int) -> None:
with self._pool.connection() as conn:
if not conn.execute("DELETE FROM live_broadcasts WHERE id=%s RETURNING id", (broadcast_id,)).fetchone():
raise LiveError("방송을 찾을 수 없습니다.")
def move_broadcast(self, broadcast_id: int, day: date, start: time, *, by: str) -> None:
"""달력에서 빈 칸으로 옮기기 — 방송 길이는 그대로."""
with self._pool.connection() as conn, conn.transaction():
row = conn.execute("SELECT start_time, end_time FROM live_broadcasts WHERE id=%s FOR UPDATE", (broadcast_id,)).fetchone()
if not row:
raise LiveError("방송을 찾을 수 없습니다(다른 사람이 지웠을 수 있음).")
conn.execute("UPDATE live_broadcasts SET broadcast_date=%s, start_time=%s, end_time=%s, updated_by=%s WHERE id=%s",
(day, start, store.moved_end(row["start_time"], row["end_time"], start), by, broadcast_id))
def swap_broadcasts(self, first_id: int, second_id: int, *, by: str) -> None:
"""달력에서 다른 방송 위로 놓기 — 두 방송의 날짜·시간을 맞바꾼다(id 순서로 잠가 교착 방지)."""
if first_id == second_id:
return
with self._pool.connection() as conn, conn.transaction():
rows = conn.execute("SELECT id, broadcast_date, start_time, end_time FROM live_broadcasts WHERE id = ANY(%s) ORDER BY id FOR UPDATE",
([first_id, second_id],)).fetchall()
if len(rows) != 2:
raise LiveError("방송을 찾을 수 없습니다(다른 사람이 지웠을 수 있음).")
for mine, other in ((rows[0], rows[1]), (rows[1], rows[0])):
conn.execute("UPDATE live_broadcasts SET broadcast_date=%s, start_time=%s, end_time=%s, updated_by=%s WHERE id=%s",
(other["broadcast_date"], other["start_time"], other["end_time"], by, mine["id"]))
# ── 날짜별 광고비(002) ───────────────────────────────────
def ad_spends(self, start: date, end: date) -> dict[date, Decimal]:
try:
with self._pool.connection() as conn:
rows = conn.execute("SELECT ad_date, ad_spend FROM live_daily_ad_spend WHERE ad_date >= %s AND ad_date < %s", (start, end)).fetchall()
except UndefinedTable:
return {}
return {r["ad_date"]: r["ad_spend"] for r in rows}
def save_ad_spend(self, day: date, amount: Decimal | None, *, by: str) -> None:
"""빈칸(None) = 지우기."""
try:
with self._pool.connection() as conn:
if amount is None:
conn.execute("DELETE FROM live_daily_ad_spend WHERE ad_date=%s", (day,))
else:
conn.execute("INSERT INTO live_daily_ad_spend (ad_date, ad_spend, updated_by) VALUES (%s,%s,%s) "
"ON CONFLICT (ad_date) DO UPDATE SET ad_spend=EXCLUDED.ad_spend, updated_by=EXCLUDED.updated_by, updated_at=now()",
(day, amount, by))
except UndefinedTable:
raise LiveError("DB 마이그레이션 live_db 002(광고비)가 아직 적용되지 않았습니다.") from None
# ── 결과 이미지 ─────────────────────────────────────────
def get_image(self, image_id: int) -> dict[str, Any] | None:
with self._pool.connection() as conn:
return conn.execute("SELECT content_type, data FROM live_broadcast_images WHERE id=%s", (image_id,)).fetchone()
def delete_image(self, image_id: int) -> None:
with self._pool.connection() as conn:
if not conn.execute("DELETE FROM live_broadcast_images WHERE id=%s RETURNING id", (image_id,)).fetchone():
raise LiveError("이미지를 찾을 수 없습니다.")
+112
View File
@@ -0,0 +1,112 @@
"""라이브 커머스 한글·영문 전환(2026-11-04) — 한글 문구가 키, 없으면 한글 그대로. 언어는 쿠키 `live_lang`(브라우저마다).
새 문구는 여기에도 넣는다 — tests/test_live.py 가 템플릿·오류 문구가 모두 있는지, 영문 화면에 한글이 없는지 확인한다.
"""
from __future__ import annotations
from typing import Any
LANG_COOKIE = "live_lang"
EN: dict[str, str] = {
# 위 막대·보기
"이전 달": "Previous month", "다음 달": "Next month", "보기 방식": "View", "표": "Table", "달력": "Calendar",
"호스트 설정": "Host Settings", "+ 방송 추가": "+ Add Broadcast", "언어": "Language",
"방송을 추가하려면 먼저 호스트를 등록해야 합니다.": "Register a host before adding a broadcast.",
"ERP 관리자에게 등록을 요청하세요.": "Ask an ERP admin to register one.",
# 방송 창
"방송 추가": "Add Broadcast", "방송 고치기": "Edit Broadcast", "호스트": "Host", "호스트를 고르세요": "Select a host",
"사용 안 함": "Inactive", "방송 날짜": "Broadcast Date", "시작 시간": "Start Time", "끝 시간": "End Time",
"시간은 말레이시아 시간으로 입력합니다.": "Enter times in Malaysia time.", "방송 장소": "Venue", "판매금액 (RM)": "Sales (RM)",
"방송 후 입력": "Enter after the broadcast",
"방송 결과 이미지 (JPG·PNG·WebP, 한 장 8MB, 방송당 {n}장까지)": "Result images (JPG, PNG, WebP, 8 MB each, up to {n} per broadcast)",
"취소": "Cancel", "저장": "Save", "확인": "OK",
# 표
"날짜": "Date", "시간": "Time", "판매금액(RM)": "Sales (RM)", "커미션 10%(RM)": "Commission 10% (RM)",
"호스트 비용(RM)": "Host Fee (RM)", "방송 결과": "Result", "고치기": "Edit", "지우기": "Delete",
"기본 요금 RM {base} + 커미션 RM {commission}": "Base RM {base} + commission RM {commission}",
"{date} {host} 방송을 지울까요? 결과 이미지도 함께 지워집니다.": "Delete the {date} broadcast by {host}? Its result images will be deleted too.",
"이 달에 등록한 방송이 없습니다.": "No broadcasts this month.",
# 달력
"판매금액": "Sales", "커미션": "Com", "비용": "Fee", "광고비": "Ad Spend", "호스트 비용": "Host Fee", "총 판매금액": "Total Sales",
"ROAS": "ROAS", "합계 & ROAS": "Total & ROAS", "날짜로 이동": "Jump to Date",
"팁: 카드 머리를 끌어 옮기거나 맞바꿀 수 있습니다. 오른쪽으로 스크롤하면 이달 {n}일을 모두 볼 수 있습니다.":
"Tip: Drag & drop any host header to move or swap dates. Scroll right to see all {n} days of the month.",
"{date} {slot} 방송 추가": "Add broadcast on {date} {slot}", "{name} {date} {times} 고치기": "Edit {name} {date} {times}",
"{date} 광고비 고치기": "Edit ad spend for {date}", "방송 결과 이미지": "Result images", "이미지 {n}": "IMG {n}",
# 호스트 설정
"◀ 스케줄표": "◀ Schedule", "+ 호스트 등록": "+ Add Host", "호스트 등록": "Add Host", "호스트 고치기": "Edit Host",
"이름 (IC 기준)": "Full Name (as per IC)", "전화번호": "Phone Number", "이메일": "Email", "주소": "Address", "은행명": "Bank Name",
"계좌번호": "Bank Account Number", "틱톡 핸들": "Tiktok Handle", "상태": "Status", "사용": "Active",
"{name} 호스트를 지울까요?": "Delete host {name}?", "등록한 호스트가 없습니다.": "No hosts registered.",
"사용 (끄면 새 방송에서 고를 수 없습니다)": "Active (when off, the host can't be selected for new broadcasts)",
# 화면 스크립트(live.js)
"서버에 연결하지 못했습니다. 입력한 값은 그대로 있으니 다시 저장해 보세요.": "Could not reach the server. Your entries are kept — please try saving again.",
"이 이미지": "this image", "{name} 를 지울까요?": "Delete {name}?", "{day} 광고비 (RM) — 비우면 지웁니다": "{day} ad spend (RM) — leave empty to clear",
# 저장 결과·입력 오류
"저장했습니다.": "Saved.", "옮겼습니다.": "Moved.", "광고비를 저장했습니다.": "Ad spend saved.", "방송을 지웠습니다.": "Broadcast deleted.",
"이미지를 지웠습니다.": "Image deleted.", "호스트를 저장했습니다.": "Host saved.", "호스트를 지웠습니다.": "Host deleted.",
"잘못된 요청입니다.": "Invalid request.",
"이름 (IC 기준)을 입력하세요.": "Enter the Full Name (as per IC).", "{label} 이(가) 너무 깁니다({limit}자까지).": "{label} is too long (up to {limit} characters).",
"이메일 형식이 올바르지 않습니다.": "The email format is invalid.", "전화번호는 숫자·+·-·괄호만 입력하세요.": "Phone Number may contain only digits, +, - and brackets.",
"계좌번호는 숫자·-만 입력하세요.": "Bank Account Number may contain only digits and -.",
"틱톡 핸들은 영문·숫자·밑줄·점만 입력하세요.": "Tiktok Handle may contain only letters, digits, underscores and dots.",
"판매금액은 숫자로 입력하세요.": "Sales must be a number.", "판매금액은 0 이상 숫자로 입력하세요.": "Sales must be a number of 0 or more.", "판매금액이 너무 큽니다.": "Sales is too large.",
"{label}을 입력하세요.": "Enter the {label}.", "{label}이 올바르지 않습니다.": "The {label} is invalid.",
"호스트를 고르세요.": "Select a host.", "방송 날짜를 입력하세요.": "Enter the broadcast date.", "방송 장소가 너무 깁니다(200자까지).": "Venue is too long (up to 200 characters).",
"끝 시간이 시작 시간과 같습니다.": "End time is the same as start time.", "날짜가 올바르지 않습니다.": "The date is invalid.",
"호스트를 찾을 수 없습니다.": "Host not found.", "방송 기록이 있는 호스트는 지울 수 없습니다 — 사용 안 함으로 바꾸세요.": "A host with broadcasts can't be deleted — set the host to Inactive instead.",
"방송을 찾을 수 없습니다(다른 사람이 지웠을 수 있음).": "Broadcast not found (someone may have deleted it).", "방송을 찾을 수 없습니다.": "Broadcast not found.",
"사용 안 함으로 바뀐 호스트입니다 — 다른 호스트를 고르세요.": "This host is Inactive — select another host.",
"방송 한 건에 이미지는 {max}장까지입니다(지금 {have}장).": "Up to {max} images per broadcast (currently {have}).", "방송 한 건에 이미지는 {max}장까지입니다.": "Up to {max} images per broadcast.",
"DB 마이그레이션 live_db 002(광고비)가 아직 적용되지 않았습니다.": "DB migration live_db 002 (ad spend) has not been applied yet.", "이미지를 찾을 수 없습니다.": "Image not found.",
"{name}: {detail}": "{name}: {detail}",
# 권한·설정
"로그인이 필요합니다.": "Please sign in.", "라이브 커머스 모듈 권한이 없습니다.": "You don't have access to the Live Commerce module.",
"호스트 정보는 ERP 관리자만 볼 수 있습니다.": "Only ERP admins can view host information.", "라이브 커머스 DB(LIVE_DB_URL)가 설정되지 않았습니다.": "The Live Commerce DB (LIVE_DB_URL) is not configured.",
"라이브 커머스 모듈 접근 권한이 없습니다.": "You don't have access to the Live Commerce module.",
"라이브 커머스 모듈이 아직 설정되지 않았습니다. scripts/sql/live_db_init.sql 로 live_db 를 만들고 .env 에 LIVE_DB_URL 을 넣은 뒤 컨테이너를 다시 시작하세요.":
"The Live Commerce module is not set up yet. Create live_db with scripts/sql/live_db_init.sql, add LIVE_DB_URL to .env and restart the container.",
# 자산 모듈 prepare_photo 오류(이미지 검사를 함께 쓴다)
"사진은 비어 있지 않은 8 MB 이하 파일이어야 합니다.": "The image must be a non-empty file of 8 MB or less.", "JPG, PNG, WebP 사진만 등록할 수 있습니다.": "Only JPG, PNG and WebP images are allowed.",
"사진은 2천만 화소 이하로 등록하세요.": "The image must be 20 megapixels or less.", "사진을 압축해 다시 등록하세요. 저장 크기는 5 MB 이하입니다.": "Please compress the image and try again (5 MB or less once stored).",
"사진을 읽을 수 없습니다. 정상적인 JPG, PNG, WebP 파일을 선택하세요.": "The image can't be read. Please choose a valid JPG, PNG or WebP file.",
}
# 화면 스크립트에 넘기는 문구(window.LV_T)
JS_KEYS = ("확인", "취소", "지우기", "서버에 연결하지 못했습니다. 입력한 값은 그대로 있으니 다시 저장해 보세요.", "이 이미지", "{name} 를 지울까요?",
"{day} 광고비 (RM) — 비우면 지웁니다")
_MONTH_NAMES = ("January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December")
def norm_lang(raw: Any) -> str:
return "en" if raw == "en" else "ko"
def t(text: str, lang: str = "ko") -> str:
return EN.get(text, text) if lang == "en" else text
def js_text(lang: str) -> dict[str, str]:
return {k: t(k, lang) for k in JS_KEYS}
def month_label(year: int, month: int, lang: str = "ko") -> str:
return f"{_MONTH_NAMES[month - 1]} {year}" if lang == "en" else f"{year}년 {month}월"
class LiveError(ValueError):
"""입력·저장 오류 — 언어에 맞게 다시 쓸 수 있게 문구 틀과 값을 따로 둔다. str() = 한글."""
def __init__(self, template: str, **params: Any):
self.template, self.params = template, params
super().__init__(template.format(**params))
def text(self, lang: str) -> str:
return t(self.template, lang).format(**{k: t(v, lang) if isinstance(v, str) else v for k, v in self.params.items()})
def error_text(exc: Exception, lang: str) -> str:
return exc.text(lang) if isinstance(exc, LiveError) else t(str(exc), lang)
+284
View File
@@ -0,0 +1,284 @@
"""라이브 커머스(live) 라우터 — 말레이시아 라이브 방송의 호스트 정보·방송 스케줄(2026-11-04).
GET /live/ 스케줄표(?month=YYYY-MM) · GET /live/calendar 달력 보기(같은 달 값)
POST /live/broadcasts 방송 추가·고치기(id 칸이 있으면 고치기) + 결과 이미지 올리기
POST /live/broadcasts/{id}/delete 방송 지우기(이미지도 함께)
POST /live/broadcasts/{id}/move 달력에서 끌어 옮기기(broadcast_date·start_time) 또는 맞바꾸기(swap_with)
POST /live/ad-spend 날짜별 광고비(빈칸 = 지우기)
GET /live/images/{id} 결과 이미지(?thumb=1 = 작은 그림) · POST /live/images/{id}/delete
GET /live/settings 설정 — 호스트 정보(ERP 관리자만, 계좌 등 개인정보)
POST /live/settings/hosts 호스트 추가·고치기 · POST /live/settings/hosts/{id}/delete
권한: 모듈 권한키 `live`(스케줄), 설정은 ERP 관리자. DB: LIVE_DB_URL(live_db) — 없으면 "설정 필요" 안내.
저장 요청은 live.js 가 fetch 로 보내고 JSON {ok, message} 를 받는다(틀려도 입력한 값이 창에 남게).
"""
from __future__ import annotations
from pathlib import PurePath
from typing import Any
from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
from fastapi.responses import HTMLResponse, JSONResponse, Response
from app.modules.asset.media import MAX_PHOTO_BYTES, prepare_photo
from app.timezone import today_kst
from . import i18n, store
router = APIRouter(prefix="/live", tags=["live"])
def _store(request: Request) -> Any:
return getattr(request.app.state, "live_store", None)
def _lang(request: Request) -> str:
return i18n.norm_lang(request.cookies.get(i18n.LANG_COOKIE))
def _t(request: Request, text: str) -> str:
return i18n.t(text, _lang(request))
def _user(request: Request) -> dict[str, Any]:
from app.main import get_current_user_record # noqa: WPS433
from app.store import has_module # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail=_t(request, "로그인이 필요합니다."))
if not has_module(user, "live"):
raise HTTPException(status_code=403, detail=_t(request, "라이브 커머스 모듈 권한이 없습니다."))
return user
def _admin(request: Request) -> dict[str, Any]:
from app.store import is_admin # noqa: WPS433
user = _user(request)
if not is_admin(user):
raise HTTPException(status_code=403, detail=_t(request, "호스트 정보는 ERP 관리자만 볼 수 있습니다."))
return user
def _db(request: Request) -> Any:
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail=_t(request, "라이브 커머스 DB(LIVE_DB_URL)가 설정되지 않았습니다."))
return st
def _page(request: Request) -> Any:
"""화면 공통 — (st, user) 또는 응답(로그인·권한·설정 필요)."""
from app.main import build_erp_nav, get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin, login_redirect # noqa: WPS433
user = get_current_user_record(request)
if user is None:
return login_redirect(request)
if not has_module(user, "live"):
return render_template(request, "denied.html", {"reason": _t(request, "라이브 커머스 모듈 접근 권한이 없습니다."),
"is_admin": is_admin(user)}, status_code=403)
st = _store(request)
if st is None:
return render_template(request, "denied.html", {
"reason": _t(request, "라이브 커머스 모듈이 아직 설정되지 않았습니다. scripts/sql/live_db_init.sql 로 live_db 를 만들고 "
".env 에 LIVE_DB_URL 을 넣은 뒤 컨테이너를 다시 시작하세요."),
"user": user, "is_admin": is_admin(user), "nav_items": build_erp_nav(user, active="live")}, status_code=503)
return st, user
def _render(request: Request, name: str, user: dict[str, Any], ctx: dict[str, Any]) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
lang = _lang(request)
return render_template(request, name, {"user": user, "is_admin": is_admin(user), "lang": lang,
"t": lambda text: i18n.t(text, lang), "js_text": i18n.js_text(lang),
"nav_items": build_erp_nav(user, active="live"), **ctx})
def _ok(request: Request, message: str) -> JSONResponse:
return JSONResponse({"ok": True, "message": _t(request, message)})
def _fail(request: Request, exc: Exception) -> JSONResponse:
return JSONResponse({"ok": False, "message": i18n.error_text(exc, _lang(request))}, status_code=400)
def _opt_id(raw: str) -> int | None:
s = (raw or "").strip()
if not s:
return None
if not s.isdigit():
raise ValueError("잘못된 요청입니다.")
return int(s)
@router.get("/health")
def health(request: Request) -> JSONResponse:
return JSONResponse({"status": "ok" if _store(request) is not None else "not_configured"})
# ────────────────────────────────────────────────────────────
# 스케줄표
# ────────────────────────────────────────────────────────────
@router.get("/", response_class=HTMLResponse)
def index(request: Request, month: str = "") -> Any:
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
lang = _lang(request)
span = store.month_range(month, today_kst(), lang)
rows = [store.broadcast_view(b, lang) for b in st.list_broadcasts(span["start"], span["end"])]
return _render(request, "live/index.html", user, {"view": "table", "span": span, "rows": rows, "hosts": st.host_choices(),
"max_images": store.MAX_IMAGES})
@router.get("/calendar", response_class=HTMLResponse)
def calendar(request: Request, month: str = "") -> Any:
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
today, lang = today_kst(), _lang(request)
span = store.month_range(month, today, lang)
cal = store.build_calendar(span, st.list_broadcasts(span["start"], span["end"]), st.ad_spends(span["start"], span["end"]), today, lang)
return _render(request, "live/calendar.html", user, {"view": "calendar", "span": span, "cal": cal, "hosts": st.host_choices(),
"max_images": store.MAX_IMAGES})
@router.post("/broadcasts/{broadcast_id}/move")
def broadcast_move(request: Request, broadcast_id: int, broadcast_date: str = Form(""), start_time: str = Form(""),
swap_with: str = Form("")) -> JSONResponse:
user = _user(request)
st = _db(request)
try:
other = _opt_id(swap_with)
if other is not None:
st.swap_broadcasts(broadcast_id, other, by=user.get("email", ""))
else:
day, start = store.parse_move(broadcast_date, start_time)
st.move_broadcast(broadcast_id, day, start, by=user.get("email", ""))
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "옮겼습니다.")
@router.post("/ad-spend")
def ad_spend_save(request: Request, day: str = Form(""), amount: str = Form("")) -> JSONResponse:
user = _user(request)
st = _db(request)
try:
when, _ = store.parse_move(day, "00:00")
st.save_ad_spend(when, store.parse_money(amount), by=user.get("email", ""))
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "광고비를 저장했습니다.")
def _read_images(files: list[UploadFile]) -> list[dict[str, Any]]:
"""고른 파일을 실제 이미지로 확인·메타데이터 제거(GPS 등). 틀리면 ValueError — 아무것도 저장하지 않게 DB 전에."""
picked = [f for f in files if f.filename]
if len(picked) > store.MAX_IMAGES:
raise i18n.LiveError("방송 한 건에 이미지는 {max}장까지입니다.", max=store.MAX_IMAGES)
out = []
for f in picked:
name = PurePath(f.filename.replace("\\", "/")).name[:200]
try:
data, ctype, width, height = prepare_photo(f.file.read(MAX_PHOTO_BYTES + 1))
except ValueError as exc:
raise i18n.LiveError("{name}: {detail}", name=name, detail=str(exc)) from None
out.append({"filename": name, "content_type": ctype, "data": data, "width": width, "height": height})
return out
@router.post("/broadcasts")
def broadcast_save(request: Request, id: str = Form(""), host_id: str = Form(""), broadcast_date: str = Form(""),
start_time: str = Form(""), end_time: str = Form(""), venue: str = Form(""), sales_amount: str = Form(""),
images: list[UploadFile] = File(default=[])) -> JSONResponse:
user = _user(request)
st = _db(request)
try:
broadcast_id = _opt_id(id)
values = store.clean_broadcast({"host_id": host_id, "broadcast_date": broadcast_date, "start_time": start_time,
"end_time": end_time, "venue": venue, "sales_amount": sales_amount})
st.save_broadcast(broadcast_id, values, _read_images(images), by=user.get("email", ""))
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "저장했습니다.")
@router.post("/broadcasts/{broadcast_id}/delete")
def broadcast_delete(request: Request, broadcast_id: int) -> JSONResponse:
_user(request)
try:
_db(request).delete_broadcast(broadcast_id)
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "방송을 지웠습니다.")
@router.get("/images/{image_id}")
def image(request: Request, image_id: int, thumb: int = 0) -> Response:
_user(request)
row = _db(request).get_image(image_id)
if not row:
raise HTTPException(status_code=404, detail=_t(request, "이미지를 찾을 수 없습니다."))
data, ctype = (store.thumbnail(row["data"]), "image/jpeg") if thumb else (bytes(row["data"]), row["content_type"])
# 올린 뒤 내용이 바뀌지 않으므로 하루 캐시. 권한이 필요한 이미지라 private.
return Response(data, media_type=ctype, headers={"Cache-Control": "private, max-age=86400", "X-Content-Type-Options": "nosniff"})
@router.post("/images/{image_id}/delete")
def image_delete(request: Request, image_id: int) -> JSONResponse:
_user(request)
try:
_db(request).delete_image(image_id)
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "이미지를 지웠습니다.")
# ────────────────────────────────────────────────────────────
# 설정 — 호스트 정보(ERP 관리자만: 계좌 등 개인정보)
# ────────────────────────────────────────────────────────────
@router.get("/settings", response_class=HTMLResponse)
def settings(request: Request) -> Any:
from app.main import render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
got = _page(request)
if not isinstance(got, tuple):
return got
st, user = got
if not is_admin(user):
return render_template(request, "denied.html", {"reason": _t(request, "호스트 정보는 ERP 관리자만 볼 수 있습니다."), "is_admin": False},
status_code=403)
return _render(request, "live/settings.html", user, {"hosts": st.list_hosts()})
@router.post("/settings/hosts")
def host_save(request: Request, id: str = Form(""), full_name: str = Form(""), phone: str = Form(""), email: str = Form(""),
address: str = Form(""), bank_name: str = Form(""), bank_account: str = Form(""), tiktok_handle: str = Form(""),
is_active: str = Form("")) -> JSONResponse:
user = _admin(request)
st = _db(request)
try:
values = store.clean_host({"full_name": full_name, "phone": phone, "email": email, "address": address, "bank_name": bank_name,
"bank_account": bank_account, "tiktok_handle": tiktok_handle})
st.save_host(_opt_id(id), values, is_active=bool(is_active), by=user.get("email", ""))
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "호스트를 저장했습니다.")
@router.post("/settings/hosts/{host_id}/delete")
def host_delete(request: Request, host_id: int) -> JSONResponse:
_admin(request)
try:
_db(request).delete_host(host_id)
except ValueError as exc:
return _fail(request, exc)
return _ok(request, "호스트를 지웠습니다.")
+231
View File
@@ -0,0 +1,231 @@
"""라이브 커머스 순수 함수 — 입력 검사·표시 형식(DB 없이 시험 가능)."""
from __future__ import annotations
import io
import re
from datetime import date, datetime, time, timedelta
from decimal import ROUND_HALF_UP, Decimal, InvalidOperation
from typing import Any
from PIL import Image
from .i18n import LiveError, month_label
MAX_IMAGES = 10 # 방송 한 건에
MAX_SALES = Decimal("999999999999.99")
THUMB_SIZE = 160
# shortcut: 요율이 코드 상수라 바꾸면 지난 방송 금액도 다시 계산된다 — 요율이 바뀌는 일이 생기면 방송마다 저장하도록 바꿀 것
HOURLY_RATE = Decimal("25") # 호스트 시간당 요금(RM)
COMMISSION_PERCENT = Decimal("10") # 판매금액의 %
SLOT_HOURS = 2 # 달력 한 칸
FIRST_SLOT_HOUR = 6 # 달력에 늘 보이는 첫 칸(이보다 이른 칸은 방송이 있을 때만)
HOST_COLORS = ("#66d4e6", "#6ee05a", "#d4f06a", "#e9cf7a", "#ec9d88", "#cdb9ea", "#f4a9c8", "#a9c4f5")
_CENT = Decimal("0.01")
_WEEKDAYS = ("MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY", "SUNDAY")
_MONTHS = ("JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC")
HOST_LIMITS = {"full_name": 200, "phone": 40, "email": 254, "address": 500, "bank_name": 100, "bank_account": 40, "tiktok_handle": 64}
_LABELS = {"full_name": "이름 (IC 기준)", "phone": "전화번호", "email": "이메일", "address": "주소", "bank_name": "은행명",
"bank_account": "계좌번호", "tiktok_handle": "틱톡 핸들"}
_EMAIL_RE = re.compile(r"^[A-Za-z0-9._%+\-']+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$")
_PHONE_RE = re.compile(r"^\+?[0-9()\-\s]+$")
_ACCOUNT_RE = re.compile(r"^[0-9\-\s]+$")
_HANDLE_RE = re.compile(r"^[A-Za-z0-9._]+$")
_HANDLE_URL_RE = re.compile(r"^(?:https?://)?(?:www\.|m\.)?tiktok\.com/@?", re.I)
WEEKDAYS_KO = "월화수목금토일"
_WEEKDAYS_EN_SHORT = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
def clean_handle(raw: Any) -> str:
"""'@name'·'https://www.tiktok.com/@name?lang=en' → 'name'."""
s = _HANDLE_URL_RE.sub("", str(raw or "").strip())
return re.split(r"[/?#]", s, maxsplit=1)[0].lstrip("@")
def clean_host(values: dict[str, Any]) -> dict[str, str]:
"""호스트 입력 검사 — 이름만 필수, 나머지는 있으면 형식 확인. 틀리면 ValueError."""
out = {k: str(values.get(k) or "").strip() for k in HOST_LIMITS}
out["tiktok_handle"] = clean_handle(values.get("tiktok_handle"))
if not out["full_name"]:
raise LiveError("이름 (IC 기준)을 입력하세요.")
for key, limit in HOST_LIMITS.items():
if len(out[key]) > limit:
raise LiveError("{label} 이(가) 너무 깁니다({limit}자까지).", label=_LABELS[key], limit=limit)
if out["email"] and not _EMAIL_RE.match(out["email"]):
raise LiveError("이메일 형식이 올바르지 않습니다.")
if out["phone"] and not _PHONE_RE.match(out["phone"]):
raise LiveError("전화번호는 숫자·+·-·괄호만 입력하세요.")
if out["bank_account"] and not _ACCOUNT_RE.match(out["bank_account"]):
raise LiveError("계좌번호는 숫자·-만 입력하세요.")
if out["tiktok_handle"] and not _HANDLE_RE.match(out["tiktok_handle"]):
raise LiveError("틱톡 핸들은 영문·숫자·밑줄·점만 입력하세요.")
return out
def parse_money(raw: Any) -> Decimal | None:
"""판매금액(RM) — 빈칸은 None(아직 입력 안 함), 0 이상, 소수 둘째 자리까지. 쉼표·RM 허용."""
s = re.sub(r"(?i)^rm|[,\s]", "", str(raw if raw is not None else "").strip())
if not s:
return None
try:
n = Decimal(s)
except InvalidOperation:
raise LiveError("판매금액은 숫자로 입력하세요.") from None
if not n.is_finite() or n < 0:
raise LiveError("판매금액은 0 이상 숫자로 입력하세요.")
if n > MAX_SALES:
raise LiveError("판매금액이 너무 큽니다.")
return n.quantize(Decimal("0.01"), rounding=ROUND_HALF_UP)
def _parse_time(raw: Any, *, label: str, required: bool) -> time | None:
s = str(raw or "").strip()
if not s:
if required:
raise LiveError("{label}을 입력하세요.", label=label)
return None
try:
return time.fromisoformat(s).replace(second=0, microsecond=0, tzinfo=None)
except ValueError:
raise LiveError("{label}이 올바르지 않습니다.", label=label) from None
def clean_broadcast(values: dict[str, Any]) -> dict[str, Any]:
"""방송 입력 검사 — 호스트·날짜·시작·끝 시간 필수(끝 시간으로 시간 요금 계산). 끝이 시작보다 이르면 자정을 넘긴 방송. 틀리면 ValueError."""
host = str(values.get("host_id") or "").strip()
if not host.isdigit():
raise LiveError("호스트를 고르세요.")
try:
day = date.fromisoformat(str(values.get("broadcast_date") or "").strip())
except ValueError:
raise LiveError("방송 날짜를 입력하세요.") from None
venue = str(values.get("venue") or "").strip()
if len(venue) > 200:
raise LiveError("방송 장소가 너무 깁니다(200자까지).")
start = _parse_time(values.get("start_time"), label="시작 시간", required=True)
end = _parse_time(values.get("end_time"), label="끝 시간", required=True)
if start == end:
raise LiveError("끝 시간이 시작 시간과 같습니다.")
return {"host_id": int(host), "broadcast_date": day, "start_time": start, "end_time": end,
"venue": venue, "sales_amount": parse_money(values.get("sales_amount"))}
def parse_move(day: Any, start: Any) -> tuple[date, time]:
"""달력 칸 — 날짜·시작 시간. 틀리면 ValueError."""
try:
when = date.fromisoformat(str(day or "").strip())
except ValueError:
raise LiveError("날짜가 올바르지 않습니다.") from None
return when, _parse_time(start, label="시간", required=True)
def moved_end(old_start: time, old_end: time | None, new_start: time) -> time | None:
"""칸을 옮겨도 방송 길이는 그대로."""
if old_end is None:
return None
return (datetime.combine(date.min, new_start) + _duration(old_start, old_end)).time()
def _duration(start: time, end: time) -> timedelta:
minutes = (end.hour * 60 + end.minute - start.hour * 60 - start.minute) % 1440 # 끝이 더 이르면 자정을 넘긴 방송
return timedelta(minutes=minutes)
def session_pay(start: time, end: time | None, sales: Decimal | None) -> dict[str, Decimal]:
"""호스트 비용 — 기본 요금(시간 × 시간당 요금) + 커미션(판매금액 × %)."""
hours = Decimal(_duration(start, end).seconds) / 3600 if end else Decimal(0)
base = (hours * HOURLY_RATE).quantize(_CENT, rounding=ROUND_HALF_UP)
commission = ((sales or Decimal(0)) * COMMISSION_PERCENT / 100).quantize(_CENT, rounding=ROUND_HALF_UP)
return {"hours": hours, "base": base, "commission": commission, "fee": base + commission}
def fmt_short(n: Decimal) -> str:
"""카드·합계용 — 소수점 아래가 0 이면 뺀다(48, 4.80, 1,234.50)."""
return f"{n:,.2f}".removesuffix(".00")
def broadcast_view(b: dict[str, Any], lang: str = "ko") -> dict[str, Any]:
"""방송 한 건 화면 값 — 표·달력 공통. b = db.list_broadcasts 한 줄."""
pay = session_pay(b["start_time"], b["end_time"], b["sales_amount"])
return {
"date": fmt_date(b["broadcast_date"], lang), "times": fmt_times(b["start_time"], b["end_time"]),
"host_name": b["host_name"], "tiktok_handle": b["tiktok_handle"], "venue": b["venue"],
"sales": fmt_money(b["sales_amount"]), "commission": fmt_money(pay["commission"]), "fee": fmt_money(pay["fee"]),
"images": b["images"], "pay": pay, "id": b["id"],
"label": b["tiktok_handle"] or b["host_name"], "color": HOST_COLORS[b["host_id"] % len(HOST_COLORS)],
"card_sales": fmt_short(b["sales_amount"] or Decimal(0)), "card_commission": fmt_short(pay["commission"]),
"card_fee": fmt_short(pay["fee"]),
"edit": {"id": b["id"], "host_id": b["host_id"], "broadcast_date": b["broadcast_date"].isoformat(),
"start_time": f"{b['start_time']:%H:%M}", "end_time": f"{b['end_time']:%H:%M}" if b["end_time"] else "",
"venue": b["venue"], "sales_amount": f"{b['sales_amount']:.2f}" if b["sales_amount"] is not None else "",
"images": [{"id": i["id"], "filename": i["filename"]} for i in b["images"]]},
}
def _roas(sales: Decimal, ad_spend: Decimal) -> str:
return f"{sales / ad_spend:.2f}" if ad_spend else "-"
def build_calendar(span: dict[str, Any], broadcasts: list[dict[str, Any]], ad_spend: dict[date, Decimal], today: date, lang: str = "ko") -> dict[str, Any]:
"""달력 보기 값 — 날짜(열)·2시간 칸(줄)·날짜별 합계·달 합계. 칸은 시작 시간으로 정한다."""
views = [(b, broadcast_view(b, lang)) for b in broadcasts]
used = {b["start_time"].hour // SLOT_HOURS * SLOT_HOURS for b, _ in views}
days = []
day = span["start"]
while day < span["end"]:
mine = [(b, v) for b, v in views if b["broadcast_date"] == day]
sales = sum((b["sales_amount"] or Decimal(0) for b, _ in mine), Decimal(0))
fee = sum((v["pay"]["fee"] for _, v in mine), Decimal(0))
spend = ad_spend.get(day, Decimal(0))
days.append({"iso": day.isoformat(), "date": day, "day": day.day, "weekday": _WEEKDAYS[day.weekday()] if lang == "en" else WEEKDAYS_KO[day.weekday()] + "요일",
"label": f"{day.day} {_MONTHS[day.month - 1]}" if lang == "en" else f"{day.month}월 {day.day}일", "is_weekend": day.weekday() >= 5, "is_today": day == today,
"count": len(mine), "sales": sales, "fee": fee, "spend": spend,
"sales_text": fmt_short(sales), "fee_text": fmt_short(fee), "spend_text": fmt_short(spend), "roas": _roas(sales, spend)})
day += timedelta(days=1)
slots = []
for hour in sorted(set(range(FIRST_SLOT_HOUR, 24, SLOT_HOURS)) | used):
end_hour = (hour + SLOT_HOURS) % 24
cells = [{"iso": d["iso"], "is_weekend": d["is_weekend"],
"cards": [v for b, v in views if b["broadcast_date"] == d["date"] and b["start_time"].hour // SLOT_HOURS * SLOT_HOURS == hour]}
for d in days]
slots.append({"start": f"{hour:02d}:00", "end": f"{end_hour:02d}:00", "label": f"{hour:02d}:00 - {end_hour:02d}:00", "cells": cells})
sales, fee, spend = (sum((d[k] for d in days), Decimal(0)) for k in ("sales", "fee", "spend"))
return {"days": days, "slots": slots, "slot_note": f"{SLOT_HOURS} Hours (RM{fmt_short(HOURLY_RATE * SLOT_HOURS)} Base)" if lang == "en" else f"{SLOT_HOURS}시간 (기본 RM{fmt_short(HOURLY_RATE * SLOT_HOURS)})",
"commission_percent": fmt_short(COMMISSION_PERCENT).split(".")[0],
"totals": {"sales": fmt_short(sales), "fee": fmt_short(fee), "spend": fmt_short(spend), "roas": _roas(sales, spend)}}
def month_range(raw: Any, today: date, lang: str = "ko") -> dict[str, Any]:
"""'YYYY-MM'(틀리거나 없으면 이번 달) → 그 달 첫날·다음 달 첫날·앞뒤 달 주소 값·제목."""
m = re.fullmatch(r"(\d{4})-(\d{2})", str(raw or "").strip())
year, month = (int(m[1]), int(m[2])) if m and 2000 <= int(m[1]) <= 2100 and 1 <= int(m[2]) <= 12 else (today.year, today.month)
start = date(year, month, 1)
end = date(year + (month == 12), month % 12 + 1, 1)
prev = date(year - (month == 1), (month - 2) % 12 + 1, 1)
return {"start": start, "end": end, "prev": prev.strftime("%Y-%m"), "next": end.strftime("%Y-%m"),
"label": month_label(year, month, lang)}
def fmt_date(d: date, lang: str = "ko") -> str:
return f"{d:%Y.%m.%d} ({_WEEKDAYS_EN_SHORT[d.weekday()]})" if lang == "en" else f"{d:%Y.%m.%d}({WEEKDAYS_KO[d.weekday()]})"
def fmt_times(start: time, end: time | None) -> str:
return f"{start:%H:%M}" + (f" ~ {end:%H:%M}" if end else "")
def fmt_money(n: Decimal | None) -> str:
return f"{n:,.2f}" if n is not None else ""
def thumbnail(data: bytes) -> bytes:
"""목록 작은 그림 — JPEG(투명은 흰 바탕). 저장할 때 이미 확인한 이미지만 들어온다."""
with Image.open(io.BytesIO(data)) as source:
source.thumbnail((THUMB_SIZE, THUMB_SIZE))
rgba = source.convert("RGBA")
canvas = Image.new("RGB", rgba.size, "white")
canvas.paste(rgba, mask=rgba.getchannel("A"))
out = io.BytesIO()
canvas.save(out, format="JPEG", quality=80)
return out.getvalue()
+19
View File
@@ -0,0 +1,19 @@
{#- 스케줄표·달력 공통 위 막대 — 달 이동, 표/달력 전환, 언어, 호스트 설정, 방송 추가. view = table | calendar -#}
{% set here = '/live/calendar' if view == 'calendar' else '/live/' %}
{% set can_add = hosts | selectattr('is_active') | list %}
<div class="lv-bar">
<a class="erp-btn erp-btn-outline" href="{{ here }}?month={{ span.prev }}" aria-label="{{ t('이전 달') }}">◀</a>
<h2 class="lv-month">{{ span.label }}</h2>
<a class="erp-btn erp-btn-outline" href="{{ here }}?month={{ span.next }}" aria-label="{{ t('다음 달') }}">▶</a>
<nav class="lv-views" aria-label="{{ t('보기 방식') }}">
<a class="erp-btn {{ 'erp-btn-primary' if view == 'table' else 'erp-btn-outline' }}" href="/live/?month={{ span.start.strftime('%Y-%m') }}"{% if view == 'table' %} aria-current="page"{% endif %}>{{ t('표') }}</a>
<a class="erp-btn {{ 'erp-btn-primary' if view == 'calendar' else 'erp-btn-outline' }}" href="/live/calendar?month={{ span.start.strftime('%Y-%m') }}"{% if view == 'calendar' %} aria-current="page"{% endif %}>{{ t('달력') }}</a>
</nav>
<span class="lv-gap"></span>
{% include "live/_lang.html" %}
{% if is_admin %}<a class="erp-btn erp-btn-outline" href="/live/settings">{{ t('호스트 설정') }}</a>{% endif %}
<button type="button" class="erp-btn erp-btn-primary" id="lv-add"{% if not can_add %} disabled{% endif %}>{{ t('+ 방송 추가') }}</button>
</div>
{% if not can_add %}
<p class="lv-note">{{ t('방송을 추가하려면 먼저 호스트를 등록해야 합니다.') }} {% if is_admin %}<a href="/live/settings">{{ t('호스트 설정') }}</a>{% else %}{{ t('ERP 관리자에게 등록을 요청하세요.') }}{% endif %}</p>
{% endif %}
@@ -0,0 +1,30 @@
{#- 방송 추가·고치기 창 — 스케줄표·달력 공통(live.js). 호스트 고르기엔 이름·틱톡만(계좌 등은 설정 화면). -#}
<dialog class="lv-dlg" id="lv-dlg" aria-labelledby="lv-dlg-title">
<form id="lv-form" action="/live/broadcasts">
<h3 id="lv-dlg-title" data-add="{{ t('방송 추가') }}" data-edit="{{ t('방송 고치기') }}"></h3>
<input type="hidden" name="id" />
<label class="lv-field">{{ t('호스트') }}
<select class="erp-select" name="host_id" required>
<option value="">{{ t('호스트를 고르세요') }}</option>
{% for h in hosts %}<option value="{{ h.id }}"{% if not h.is_active %} data-inactive="1"{% endif %}>{{ h.full_name }}{% if h.tiktok_handle %} (@{{ h.tiktok_handle }}){% endif %}{% if not h.is_active %} — {{ t('사용 안 함') }}{% endif %}</option>{% endfor %}
</select>
</label>
<div class="lv-row">
<label class="lv-field">{{ t('방송 날짜') }} <input class="erp-input" type="date" name="broadcast_date" required /></label>
<label class="lv-field">{{ t('시작 시간') }} <input class="erp-input" type="time" name="start_time" required /></label>
<label class="lv-field">{{ t('끝 시간') }} <input class="erp-input" type="time" name="end_time" required /></label>
</div>
<p class="lv-sub">{{ t('시간은 말레이시아 시간으로 입력합니다.') }}</p>
<label class="lv-field">{{ t('방송 장소') }} <input class="erp-input" type="text" name="venue" maxlength="200" /></label>
<label class="lv-field">{{ t('판매금액 (RM)') }} <input class="erp-input lv-num" type="text" name="sales_amount" inputmode="decimal" placeholder="{{ t('방송 후 입력') }}" /></label>
<label class="lv-field">{{ t('방송 결과 이미지 (JPG·PNG·WebP, 한 장 8MB, 방송당 {n}장까지)').format(n=max_images) }}
<input type="file" name="images" accept="image/jpeg,image/png,image/webp" multiple />
</label>
<ul class="lv-saved" data-saved hidden></ul>
<p class="lv-msg" data-msg role="alert" hidden></p>
<div class="lv-foot">
<button type="button" class="erp-btn erp-btn-outline" data-close>{{ t('취소') }}</button>
<button type="submit" class="erp-btn erp-btn-primary">{{ t('저장') }}</button>
</div>
</form>
</dialog>
@@ -0,0 +1,5 @@
{#- 한글·영문 전환 — 누르면 쿠키에 저장하고 다시 그린다(live.js). 언어 이름은 언어와 상관없이 그대로 보인다. -#}
<div class="lv-lang" role="group" aria-label="{{ t('언어') }}">
<button type="button" data-lang="ko"{% if lang != 'en' %} class="is-active" aria-pressed="true"{% else %} aria-pressed="false"{% endif %}>한글</button>
<button type="button" data-lang="en"{% if lang == 'en' %} class="is-active" aria-pressed="true"{% else %} aria-pressed="false"{% endif %}>EN</button>
</div>
@@ -0,0 +1,2 @@
<script>window.LV_T = {{ js_text | tojson }};</script>
<script src="/static/live.js?v=20261104c" defer></script>
@@ -0,0 +1,86 @@
{% extends "erp_base.html" %}
{#- 라이브 커머스 달력 보기(2026-11-04) — 줄 = 2시간 칸, 열 = 날짜, 맨 아래 = 날짜별 합계. 카드 머리 = Tiktok Handle(없으면 이름).
카드 머리를 끌어 빈 칸으로 옮기거나 다른 카드 위에 놓아 맞바꾼다(live.js). 문구 = t()(i18n.py), 영문은 CSS 로 대문자(받은 화면과 같게). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/live.css?v=20261104c" />{% endblock %}
{% block content %}
<section class="lv" lang="{{ lang }}">
{% include "live/_bar.html" %}
<div class="lv-kpis">
<div class="lv-kpi"><span>{{ t('총 판매금액') }}</span><b>RM {{ cal.totals.sales }}</b></div>
<div class="lv-kpi"><span>{{ t('광고비') }}</span><b>RM {{ cal.totals.spend }}</b></div>
<div class="lv-kpi"><span>{{ t('호스트 비용') }}</span><b>RM {{ cal.totals.fee }}</b></div>
<div class="lv-kpi"><span>ROAS</span><b>{{ cal.totals.roas }}</b></div>
</div>
<nav class="lv-jump" aria-label="{{ t('날짜로 이동') }}">
<span class="lv-jump-label">{{ t('날짜로 이동') }}:</span>
{% for d in cal.days %}<button type="button" class="lv-jump-day{% if d.is_weekend %} is-weekend{% endif %}{% if d.is_today %} is-today{% endif %}" data-jump="{{ d.iso }}">{{ d.day }}</button>{% endfor %}
</nav>
<p class="lv-tip">{{ t('팁: 카드 머리를 끌어 옮기거나 맞바꿀 수 있습니다. 오른쪽으로 스크롤하면 이달 {n}일을 모두 볼 수 있습니다.').format(n=cal.days | length) }}</p>
<div class="lv-cal-wrap" id="lv-cal-wrap">
<table class="lv-cal">
<thead>
<tr>
<th class="lv-cal-time" scope="col">{{ t('시간') }}</th>
{% for d in cal.days %}
<th scope="col" data-day="{{ d.iso }}"{% if d.is_today %} data-today="1"{% endif %} class="{% if d.is_weekend %}is-weekend{% endif %}{% if d.is_today %} is-today{% endif %}">
<div class="lv-cal-weekday">{{ d.weekday }} <span class="lv-cal-count">{{ d.count }}</span></div>
<div class="lv-cal-date">{{ d.label }}</div>
</th>
{% endfor %}
</tr>
</thead>
<tbody>
{% for slot in cal.slots %}
<tr>
<th class="lv-cal-time" scope="row">{{ slot.label }}<small>{{ cal.slot_note }}</small></th>
{% for cell in slot.cells %}
<td class="lv-cell{% if cell.is_weekend %} is-weekend{% endif %}" data-drop data-day="{{ cell.iso }}" data-start="{{ slot.start }}">
{% for c in cell.cards %}
<article class="lv-card" data-card="{{ c.id }}">
<header class="lv-card-head" draggable="true" style="background:{{ c.color }}" title="{{ c.host_name }} · {{ c.times }}{% if c.venue %} · {{ c.venue }}{% endif %}">
<span class="lv-card-grip" aria-hidden="true">✥</span>
<span class="lv-card-name">{{ c.label }}</span>
<button type="button" class="lv-card-edit" data-edit='{{ c.edit | tojson }}' aria-label="{{ t('{name} {date} {times} 고치기').format(name=c.label, date=c.date, times=c.times) }}">✎</button>
</header>
<div class="lv-card-nums">
<div><span>{{ t('판매금액') }}</span><b>{{ c.card_sales }}</b></div>
<div><span>{{ t('커미션') }} ({{ cal.commission_percent }}%)</span><b>{{ c.card_commission }}</b></div>
</div>
<footer class="lv-card-foot"><span>{{ t('비용') }}: <b>RM{{ c.card_fee }}</b></span>{% if c.images %}<a href="/live/images/{{ c.images[0].id }}" target="_blank" rel="noopener" title="{{ t('방송 결과 이미지') }}">{{ t('이미지 {n}').format(n=c.images | length) }}</a>{% endif %}</footer>
</article>
{% endfor %}
{% if not cell.cards and hosts | selectattr('is_active') | list %}
<button type="button" class="lv-cell-add" data-new='{{ {"broadcast_date": cell.iso, "start_time": slot.start, "end_time": slot.end} | tojson }}' aria-label="{{ t('{date} {slot} 방송 추가').format(date=cell.iso, slot=slot.label) }}">+</button>
{% endif %}
</td>
{% endfor %}
</tr>
{% endfor %}
</tbody>
<tfoot>
<tr>
<th class="lv-cal-time" scope="row">{{ t('합계 & ROAS') }}</th>
{% for d in cal.days %}
<td>
<dl class="lv-total">
<div><dt>{{ t('총 판매금액') }}:</dt><dd class="is-sales">RM {{ d.sales_text }}</dd></div>
<div><dt>{{ t('광고비') }}:</dt><dd>RM {{ d.spend_text }} <button type="button" class="lv-total-edit" data-spend="{{ d.iso }}" data-value="{{ d.spend if d.spend else '' }}" aria-label="{{ t('{date} 광고비 고치기').format(date=d.iso) }}">✎</button></dd></div>
<div><dt>{{ t('호스트 비용') }}:</dt><dd>RM {{ d.fee_text }}</dd></div>
<div><dt>ROAS:</dt><dd>{{ d.roas }}</dd></div>
</dl>
</td>
{% endfor %}
</tr>
</tfoot>
</table>
</div>
</section>
{% include "live/_dialog.html" %}
{% endblock %}
{% block scripts %}{% include "live/_scripts.html" %}{% endblock %}
@@ -0,0 +1,41 @@
{% extends "erp_base.html" %}
{#- 라이브 커머스 스케줄표(2026-11-04) — 달마다 방송 목록. 추가·고치기 창은 달력과 공용(_dialog.html, live.js). 문구 = t()(i18n.py). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/live.css?v=20261104c" />{% endblock %}
{% block content %}
<section class="lv" lang="{{ lang }}">
{% include "live/_bar.html" %}
<div class="erp-card-block">
<div class="erp-table-wrap">
<table class="erp-table lv-table">
<thead><tr><th>{{ t('날짜') }}</th><th>{{ t('시간') }}</th><th>{{ t('호스트') }}</th><th>{{ t('방송 장소') }}</th><th class="lv-r">{{ t('판매금액(RM)') }}</th><th class="lv-r">{{ t('커미션 10%(RM)') }}</th><th class="lv-r">{{ t('호스트 비용(RM)') }}</th><th>{{ t('방송 결과') }}</th><th></th></tr></thead>
<tbody>
{% for r in rows %}
<tr>
<td class="lv-nowrap" data-label="{{ t('날짜') }}">{{ r.date }}</td>
<td class="lv-nowrap" data-label="{{ t('시간') }}">{{ r.times }}</td>
<td data-label="{{ t('호스트') }}">{{ r.host_name }}{% if r.tiktok_handle %}<div class="lv-sub">@{{ r.tiktok_handle }}</div>{% endif %}</td>
<td data-label="{{ t('방송 장소') }}">{{ r.venue }}</td>
<td class="lv-r lv-num" data-label="{{ t('판매금액(RM)') }}">{{ r.sales }}</td>
<td class="lv-r lv-num" data-label="{{ t('커미션 10%(RM)') }}">{{ r.commission }}</td>
<td class="lv-r lv-num" data-label="{{ t('호스트 비용(RM)') }}" title="{{ t('기본 요금 RM {base} + 커미션 RM {commission}').format(base=r.pay.base, commission=r.pay.commission) }}">{{ r.fee }}</td>
<td data-label="{{ t('방송 결과') }}"><div class="lv-thumbs">{% for im in r.images %}<a href="/live/images/{{ im.id }}" target="_blank" rel="noopener" title="{{ im.filename }}"><img src="/live/images/{{ im.id }}?thumb=1" alt="{{ im.filename }}" loading="lazy" /></a>{% endfor %}</div></td>
<td class="lv-actions">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-edit='{{ r.edit | tojson }}'>{{ t('고치기') }}</button>
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-post="/live/broadcasts/{{ r.id }}/delete" data-confirm="{{ t('{date} {host} 방송을 지울까요? 결과 이미지도 함께 지워집니다.').format(date=r.date, host=r.host_name) }}">{{ t('지우기') }}</button>
</td>
</tr>
{% else %}
<tr><td colspan="9" class="erp-empty">{{ t('이 달에 등록한 방송이 없습니다.') }}</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</section>
{% include "live/_dialog.html" %}
{% endblock %}
{% block scripts %}{% include "live/_scripts.html" %}{% endblock %}
@@ -0,0 +1,67 @@
{% extends "erp_base.html" %}
{#- 라이브 커머스 설정(2026-11-04) — 호스트 정보. 계좌 등 개인정보라 ERP 관리자만(router.settings). 추가·고치기는 같은 창(live.js). 문구 = t()(i18n.py). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/live.css?v=20261104c" />{% endblock %}
{% block content %}
<section class="lv" lang="{{ lang }}">
<div class="lv-bar">
<a class="erp-btn erp-btn-outline" href="/live/">{{ t('◀ 스케줄표') }}</a>
<h2 class="lv-month">{{ t('호스트 설정') }}</h2>
<span class="lv-gap"></span>
{% include "live/_lang.html" %}
<button type="button" class="erp-btn erp-btn-primary" id="lv-add">{{ t('+ 호스트 등록') }}</button>
</div>
<div class="erp-card-block">
<div class="erp-table-wrap">
<table class="erp-table lv-table">
<thead><tr><th>{{ t('이름 (IC 기준)') }}</th><th>{{ t('전화번호') }}</th><th>{{ t('이메일') }}</th><th>{{ t('주소') }}</th><th>{{ t('은행명') }}</th><th>{{ t('계좌번호') }}</th><th>{{ t('틱톡 핸들') }}</th><th>{{ t('상태') }}</th><th></th></tr></thead>
<tbody>
{% for h in hosts %}
<tr{% if not h.is_active %} class="lv-off"{% endif %}>
<td data-label="{{ t('이름 (IC 기준)') }}">{{ h.full_name }}</td>
<td class="lv-nowrap" data-label="{{ t('전화번호') }}">{{ h.phone }}</td>
<td data-label="{{ t('이메일') }}">{{ h.email }}</td>
<td data-label="{{ t('주소') }}">{{ h.address }}</td>
<td data-label="{{ t('은행명') }}">{{ h.bank_name }}</td>
<td class="lv-nowrap" data-label="{{ t('계좌번호') }}">{{ h.bank_account }}</td>
<td data-label="{{ t('틱톡 핸들') }}">{% if h.tiktok_handle %}@{{ h.tiktok_handle }}{% endif %}</td>
<td class="lv-nowrap" data-label="{{ t('상태') }}">{{ t('사용') if h.is_active else t('사용 안 함') }}</td>
<td class="lv-actions">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-edit='{{ {"id": h.id, "full_name": h.full_name, "phone": h.phone, "email": h.email, "address": h.address, "bank_name": h.bank_name, "bank_account": h.bank_account, "tiktok_handle": h.tiktok_handle, "is_active": h.is_active} | tojson }}'>{{ t('고치기') }}</button>
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" data-post="/live/settings/hosts/{{ h.id }}/delete" data-confirm="{{ t('{name} 호스트를 지울까요?').format(name=h.full_name) }}">{{ t('지우기') }}</button>
</td>
</tr>
{% else %}
<tr><td colspan="9" class="erp-empty">{{ t('등록한 호스트가 없습니다.') }}</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</section>
<dialog class="lv-dlg" id="lv-dlg" aria-labelledby="lv-dlg-title">
<form id="lv-form" action="/live/settings/hosts">
<h3 id="lv-dlg-title" data-add="{{ t('호스트 등록') }}" data-edit="{{ t('호스트 고치기') }}"></h3>
<input type="hidden" name="id" />
<label class="lv-field">{{ t('이름 (IC 기준)') }} <input class="erp-input" type="text" name="full_name" maxlength="200" required /></label>
<label class="lv-field">{{ t('전화번호') }} <input class="erp-input" type="tel" name="phone" maxlength="40" /></label>
<label class="lv-field">{{ t('이메일') }} <input class="erp-input" type="email" name="email" maxlength="254" /></label>
<label class="lv-field">{{ t('주소') }} <textarea class="erp-input" name="address" rows="2" maxlength="500"></textarea></label>
<div class="lv-row">
<label class="lv-field">{{ t('은행명') }} <input class="erp-input" type="text" name="bank_name" maxlength="100" /></label>
<label class="lv-field">{{ t('계좌번호') }} <input class="erp-input" type="text" name="bank_account" maxlength="40" inputmode="numeric" /></label>
</div>
<label class="lv-field">{{ t('틱톡 핸들') }} <input class="erp-input" type="text" name="tiktok_handle" maxlength="200" placeholder="@handle" /></label>
<label class="lv-check"><input type="checkbox" name="is_active" value="1" checked /> {{ t('사용 (끄면 새 방송에서 고를 수 없습니다)') }}</label>
<p class="lv-msg" data-msg role="alert" hidden></p>
<div class="lv-foot">
<button type="button" class="erp-btn erp-btn-outline" data-close>{{ t('취소') }}</button>
<button type="submit" class="erp-btn erp-btn-primary">{{ t('저장') }}</button>
</div>
</form>
</dialog>
{% endblock %}
{% block scripts %}{% include "live/_scripts.html" %}{% endblock %}
+9 -3
View File
@@ -57,6 +57,8 @@
묶어 상자 안에서 스크롤했는데, 진짜 셸에서는 상자 아래가 화면 밖에 잘리고(`overscroll-behavior: contain`) 휠이 페이지로 안 넘어갔다.
스크롤 막대 배경(트랙) 투명 = `scrollbar-color: #c3c6cb transparent`(표 상자·실적 화면 `.erp-page`). 테스트 `tests/js/perf_sticky.browser.test.js`
(진짜 `erp_base.html` 셸 렌더 `perf_*_shell.html` 로 휠 스크롤 — 스텁 셸로는 이 문제가 안 보였다).
- **새로고침해도 스크롤 유지**(2026-11-02) — 수기 입력을 마치면 합계를 다시 계산하려고 새로고침하는데, 세로 스크롤은 `.erp-page` 상자라 브라우저가 복원하지 않아 맨 위로 돌아갔다.
`performance.js keepScroll` 이 떠날 때 세로·가로 위치를 sessionStorage `perf_scroll` 에 저장 → **새로고침일 때만** 복원(같은 주소, 메뉴·기간 이동은 맨 위부터). 자동 새로 고침·업로드 뒤 새로고침도 같음.
- 열 순서 카페24·네이버·쿠팡(윙)·쿠팡(로켓)·오늘의집·G마켓·카카오·GS샵·11번가·롯데ON·토스·애터미아자몰(마이그레이션 003).
- 쿠팡(로켓)·애터미아자몰은 **수동 입력 전용**(`adapters/manual.py`, `manual_only` — 매출 업데이트에서 빠지고 인증 설정·연결 테스트 없음, 수동 입력 늘 켜짐).
- **직접 추가 쇼핑몰·그룹·순서 드래그**(2026-10-22, 마이그레이션 009 `is_custom`·`is_group`·`parent_code`) — 설정 [+ 쇼핑몰 추가(수동 입력)]
@@ -64,8 +66,12 @@
직접 추가 쇼핑몰만 그룹 select 로 묶음, 이름 변경·삭제(삭제 = 그 쇼핑몰 수동 입력·수수료도). 매출 실적 표 그룹 열 = 보이는 하위 합계(일 합계엔 안 더함),
▾/▸ 하위 열 접기(localStorage). ⠿ 드래그 → `PUT /api/marketplace-order` → `sort_order`, 화면 순서는 `dashboard.ordered_marketplaces`
(그룹 바로 뒤 하위) 한 곳. 상세 `docs/PERFORMANCE_MODULE.md` "직접 추가 쇼핑몰·그룹".
- **카페24(공구 제외) 열**(2026-10-30) — 직접 추가 쇼핑몰 "카페24 공동구매"(이름으로 찾음, 띄어쓰기 무시) 바로 오른쪽에 카페24 − 공동구매 계산 열
(`dashboard._cafe24_ex_gb_column`, kind `diff`, 표 열만 — 일 합계엔 안 더함, 클릭·메모 없음). 공동구매 칸을 저장하면 그 줄 차이 칸이 바로 바뀜(`performance.js saveManual`, td `data-diff-minus`·`data-base`), 합계 줄은 입력 마친 뒤 새로고침 때. 상세 `docs/PERFORMANCE_MODULE.md` "직접 추가 쇼핑몰·그룹".
- **카페24(전체)·카페24(실적) 열**(2026-11-02, 예전 "공구 제외") — 카페24 열 이름 = 카페24(전체)(`_short_name`), 바로 오른쪽 카페24(실적) = 카페24 − 직접 추가 쇼핑몰 "자사몰(공동구매)"("카페24 공동구매"도, 이름으로 찾음·띄어쓰기 무시 — 없으면 전체 그대로, 쇼핑몰 필터·숨김과 무관하게 뺌).
광고비 줄은 카페24(전체)와 같은 구글·메타(`dashboard._cafe24_real_column`, kind `diff`, 표 열만 — 일 합계엔 안 더함, 클릭·메모 없음). 공동구매 칸을 저장하면 그 줄 칸이 바로 바뀜(`performance.js saveManual`, td `data-diff-minus`·`data-base`), 합계 줄은 입력 마친 뒤 새로고침 때. 상세 `docs/PERFORMANCE_MODULE.md` "직접 추가 쇼핑몰·그룹".
- **합계 기준**(2026-11-02) — 일 합계 = 카페24(실적) + 공동구매 + 나머지 쇼핑몰(카페24(전체)는 안 더함 — 공동구매가 들어 있어 중복). 일 합계·ROAS·KPI·추이·비중·월/연 누적 모두 `dashboard._summary_cells`(카페24 칸 = 실적, 그래프·누적의 카페24 줄 이름도 `summary_names` = 카페24(실적)), 표의 카페24(전체) 열만 원래 값. 광고비 탭 매출 대비 광고비·합계 ROAS = `total_sales_codes`(카페24 있으면 공동구매 코드 뺌, 같은 금액). **프로젝트 회의록 머리 카드는 아직 예전 합계**(`project/router.py` `total` — 공동구매 중복).
- **매출 실적 표 열 숨기기**(2026-11-02) — 실적 설정 "공통 보기 설정" 카드(관리자만, `PUT /api/hidden-marketplaces`, `perf_settings` key `hidden_marketplaces`, 011 미적용 503) → **모든 사용자에게 적용**. **열만** 숨김(`dashboard.load_hidden`) — 일 합계·KPI·그래프·누적은 그대로, 그룹 열 = 보이는 하위 합계(다 숨기면 그룹 열도 없음). 쇼핑몰 필터(합계까지 바뀜)와 다름. 광고비 탭은 적용 안 함.
- **일 합계 열 위치**(2026-11-02) — 매출 실적·광고비 표 모두 날짜 바로 오른쪽, 날짜 열과 함께 가로 고정(왼쪽 위치 `--perf-label-w` = 날짜 열 너비, `performance.js stickyHead`).
- **기간 이동**(2026-11-02, `_period_nav.html` 공통) — 날짜 바로 좌우 화살표 SVG(글자 높이, 진한 회색), 글자 버튼 없음.
- **매출 실적 표 모양(2026-10-22)** — `table.perf-autofit`(매출 탭만, 모든 기간 같음): 표가 100% 로 늘지 않고 **열 너비 = 내용 길이**, 날짜 열은 고정 210px 대신 자동 +
**가로 스크롤해도 고정**(sticky left, 오른쪽 그림자). 그룹 열 = 진한 보라 머리·왼쪽 묶음 선, 하위 열 = 옅은 보라 머리(위 띠)·옅은 칸, 마지막 하위(`is-glast`, 접히면 그룹 열 `is-gclosed`) = 오른쪽 선.
접기 단추 = 22px ⊟/⊞(SVG, 세로 막대가 돌아 바뀜). 접기·펴기 애니메이션 = 하위 칸 내용 `.perf-gc` 너비·칸 여백·투명도 260ms(`setGroup(code, fold, animate)`,
@@ -86,7 +92,7 @@
수동 = 매출 실적·광고비 일자별 표에 `perf-colw-manual` → `performance.js initColWidths` 가 자동 너비를 잰 뒤 `table-layout:fixed`(`is-colw-fixed`, 넘치는 글자 …),
머리글 오른쪽 경계 `.perf-colw-grip` 드래그(최소 36px)·두 번 누르면 그 열만 자동. **날짜 열(`label`)은 조절 불가 — 늘 자동 너비, 손잡이 없음, 저장값 무시**. 너비 = localStorage `perf_colw_sales`/`perf_colw_ads`(th `data-col` = 쇼핑몰·채널 코드·`label`·`total`)에 계속 유지,
설정 [조절한 너비 초기화]가 둘 다 지움. 그룹 접기·펴기 때 열 너비도 함께 움직임(`colw.animate/settle`). 테스트 `tests/js/perf_colw.browser.test.js`.
- **매출 단위** 원·천원·백만원 — 설정 "보기 설정"(누구나, 이 브라우저 쿠키 `perf_unit`), 서버가 `amount_text`(천원 정수·백만원 소수 한 자리)로 그림(`router._unit_ctx` → 템플릿 `amt`). 광고비 탭은 원 그대로.
- **매출 단위** 원·천원·백만원(2026-11-02 모든 사용자 공통) — 설정 "공통 보기 설정"(관리자, `PUT /api/display-unit`, `perf_settings` key `display_unit`, 저장 값 없음·011 미적용 = 원, 예전 쿠키 `perf_unit` 은 안 봄), 서버가 `amount_text`(천원 정수·백만원 소수 한 자리)로 그림(`router._unit_ctx` → 템플릿 `amt`). 광고비 탭은 원 그대로. 표 열 너비는 사람(브라우저)마다 그대로.
- 설정의 진단 카드(쇼핑몰 원본 데이터 확인·카페24 매출 대조·일별 한 번에 비교)는 2026-10-19 화면에서 뺐다(서버 API `marketplaces/{code}/reconcile`·`daily-check` 는 진단용으로 남김).
## 날짜 칸 메모 (2026-10-22, 마이그레이션 010 `perf_cell_memos`)
+94 -31
View File
@@ -57,27 +57,44 @@ def _group_columns(store_rows: Sequence[Mapping[str, Any]], codes: Sequence[str]
return cols, members
# 카페24 − 카페24 공동구매 열(2026-10-30) — 직접 추가 쇼핑몰 "카페24 공동구매" 바로 오른쪽, 표 열만(일 합계·그래프·누적엔 안 더함).
# shortcut: 공동구매 쇼핑몰은 이름(띄어쓰기 무시)으로 찾는다 — 설정에서 이름을 바꾸면 이 열이 사라진다, 자주 바뀌면 설정 값으로.
CAFE24_GB_NAME = "카페24공동구매"
# 카페24(실적) 열(2026-11-02, 예전 "공구 제외") — 카페24(전체) 바로 오른쪽, 카페24 − 공동구매. 표 열만(일 합계·그래프·누적엔 안 더함).
# shortcut: 공동구매 쇼핑몰은 이름(띄어쓰기 무시)으로 찾는다 — 설정에서 다른 이름으로 바꾸면 빼지 않아 실적 = 전체가 된다, 자주 바뀌면 설정 값으로.
CAFE24_GB_NAMES = ("자사몰(공동구매)", "카페24공동구매")
CAFE24_EX_GB = "cafe24_ex_gb"
CAFE24_REAL_NAME = "카페24(실적)"
def _cafe24_ex_gb_column(markets: Sequence[Mapping[str, Any]], codes: Sequence[str], cols: list[dict[str, Any]],
names: dict[str, str], short: dict[str, str], table: list[dict[str, Any]]) -> None:
"""카페24·공동구매 둘 다 보일 때만 공동구매 열 뒤에 차이 열(kind diff — 공동구매가 그룹 하위면 같은 그룹으로 접힘)."""
gb = next((m["code"] for m in markets
if m["name"].replace(" ", "") == CAFE24_GB_NAME and m["code"] in codes), None)
if gb is None or "cafe24" not in codes:
def groupbuy_code(markets: Sequence[Mapping[str, Any]]) -> str:
"""공동구매 쇼핑몰 코드, 없으면 빈 값."""
return next((m["code"] for m in markets if m["name"].replace(" ", "") in CAFE24_GB_NAMES), "")
def total_sales_codes(markets: Sequence[Mapping[str, Any]]) -> list[str]:
"""전체 매출에 더할 쇼핑몰 — 카페24(전체)에 공동구매가 들어 있어 카페24 가 있으면 공동구매는 뺀다(광고비 탭 매출 대비 광고비·합계 ROAS)."""
codes = [m["code"] for m in markets]
gb = groupbuy_code(markets)
return [c for c in codes if c != gb] if "cafe24" in codes else codes
def _summary_cells(cells: Mapping[tuple[date, str], calc.Money], gb: str) -> dict[tuple[date, str], calc.Money]:
"""합계용 칸(2026-11-02) — 카페24 칸 = 카페24(실적)(카페24 − 공동구매). 일 합계·KPI·그래프·누적은 이 값으로 더해 공동구매가 두 번 안 들어간다."""
out = dict(cells)
for (d, c), m in cells.items():
if c == gb:
a = cells.get((d, "cafe24"), calc.Money())
out[(d, "cafe24")] = calc.Money(gross=a.gross - m.gross, commission=a.commission - m.commission)
return out
def _cafe24_real_column(cols: list[dict[str, Any]], names: dict[str, str], short: dict[str, str], gb: str) -> None:
"""카페24(실적) 열 머리 — 공동구매가 없으면(gb 빈 값) 전체와 같은 값이고 화면 즉시 계산도 없다."""
col = next((c for c in cols if c["code"] == CAFE24_EX_GB), None)
if col is None:
return
i = next(i for i, col in enumerate(cols) if col["code"] == gb)
# base·minus = 화면이 공동구매 칸 저장 때 이 줄 차이 칸을 바로 다시 계산할 때 씀(performance.js saveManual)
cols.insert(i + 1, {"code": CAFE24_EX_GB, "kind": "diff", "group": cols[i]["group"], "base": "cafe24", "minus": gb})
names[CAFE24_EX_GB] = f"{names['cafe24']} − {names[gb]}"
short[CAFE24_EX_GB] = f"{short['cafe24']}(공구 제외)"
for r in table:
a, b = r["cells"]["cafe24"], r["cells"][gb]
r["cells"][CAFE24_EX_GB] = {k: a[k] - b[k] for k in ("gross", "commission", "net")}
# base·minus = 화면이 공동구매 칸 저장 때 이 줄 칸을 바로 다시 계산할 때 씀(performance.js saveManual)
col.update(kind="diff", base="cafe24", minus=gb)
names[CAFE24_EX_GB] = f"{names['cafe24']} − {names[gb]}" if gb else CAFE24_REAL_NAME
short[CAFE24_EX_GB] = CAFE24_REAL_NAME
def display_status(marketplace: Mapping[str, Any], status_row: Mapping[str, Any] | None,
@@ -92,9 +109,9 @@ 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) — (나누는 수, 소수 자리, 단위 이름)
# 매출 단위(2026-10-19, 11-02 실적 설정 "공통 보기 설정" — 모든 사용자 같음, 마이그레이션 011 perf_settings) — (나누는 수, 소수 자리, 단위 이름)
UNITS: dict[str, tuple[int, int, str]] = {"won": (1, 0, "원"), "thousand": (1000, 0, "천원"), "million": (1_000_000, 1, "백만원")}
UNIT_COOKIE = "perf_unit"
UNIT_SETTING = "display_unit"
def normalize_unit(value: Any) -> str:
@@ -109,6 +126,29 @@ def normalize_colw(value: Any) -> str:
return "manual" if value == "manual" else "auto"
# 매출 실적 표 열 숨기기(2026-11-02, 실적 설정 "공통 보기 설정" — 관리자가 정하면 모든 사용자에게 적용, 마이그레이션 011 perf_settings) — 코드 목록, 열만 숨김
HIDDEN_SETTING = "hidden_marketplaces"
def _shared_setting(store: Any, key: str) -> Any:
"""모든 사용자 공통 설정 값. 저장 값 없음·011 미적용이면 None(화면은 그대로 열린다)."""
from .db import SettingsMigrationNeeded # noqa: WPS433
reader = getattr(store, "get_setting", None)
try:
return reader(key) if reader else None
except SettingsMigrationNeeded:
return None
def load_hidden(store: Any) -> set[str]:
return set(_shared_setting(store, HIDDEN_SETTING) or ())
def load_unit(store: Any) -> str:
return normalize_unit(_shared_setting(store, UNIT_SETTING))
def amount_text(value: Any, unit: str = "won") -> str:
"""금액 → 화면 글자(쉼표). 천원은 정수, 백만원은 소수 한 자리(반올림)."""
div, places, _ = UNITS[normalize_unit(unit)]
@@ -198,7 +238,10 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
names = {m["code"]: m["name"] for m in markets}
short = {c: _short_name(names[c]) for c in all_codes}
# 그룹(009) — 그룹 열 = 보이는 하위 쇼핑몰 합계(표 열만, 합계·그래프·누적은 쇼핑몰 기준 그대로)
cols, group_members = _group_columns(store_rows, codes)
# 표에 그릴 열 = 고른 쇼핑몰 + 카페24 바로 뒤 카페24(실적) − 숨긴 열(합계·그래프·누적은 codes 그대로)
hidden = load_hidden(store)
shown = [x for c in codes for x in ((c, CAFE24_EX_GB) if c == "cafe24" else (c,)) if x not in hidden]
cols, group_members = _group_columns(store_rows, shown)
for m in store_rows:
if m["code"] in group_members:
names[m["code"]] = short[m["code"]] = m["name"]
@@ -220,7 +263,11 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
q_start = min(period.start, cmp_start, m_cmp_start, y_cmp_start)
q_end = max(period.end, year_period.end)
cells = calc.build_cells(store.daily_amounts(q_start, q_end, codes), store.rate_table())
gb = groupbuy_code(markets)
# 공동구매를 필터로 뺐어도 카페24(실적) 계산엔 필요 — 합계·그래프는 아래에서 codes 만 더한다
cells = calc.build_cells(store.daily_amounts(q_start, q_end, codes if not gb or gb in codes else [*codes, gb]),
store.rate_table())
summary = _summary_cells(cells, gb)
# 수동 입력(설정에서 켠 쇼핑몰) — 일자별 표의 날짜 칸을 눌러 입력. 값이 있는 칸은 표시(API 값 대신 쓰는 중)
manual_codes = [m["code"] for m in markets if m.get("manual_input") and m["code"] in codes]
manual_amounts = getattr(store, "manual_amounts", None)
@@ -232,8 +279,8 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
(manual_formulas(period.start, period.end, manual_codes) if manual_formulas and manual_codes else {}).items()
if f"{d.isoformat()}|{c}" in manual_cells}
cur = calc.sum_range(cells, codes, period.start, period.end)
prev = calc.sum_range(cells, codes, cmp_start, cmp_end)
cur = calc.sum_range(summary, codes, period.start, period.end)
prev = calc.sum_range(summary, codes, cmp_start, cmp_end)
period_word = {"day": "오늘" if period.start == today else "해당일", "week": "이번주" if period.start <= today <= period.end else "해당 주",
"month": "이번달" if period.start <= today <= period.end else "해당 월",
@@ -246,7 +293,9 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
"delta": calc.pct_change(cur.net, prev.net), "cmp": cmp_label},
]
share = calc.by_code(cells, codes, period.start, period.end)
share = calc.by_code(summary, codes, period.start, period.end)
# 비중 그래프·월 누적 표의 카페24 줄 = 카페24(실적) — 줄을 더하면 합계와 같다
summary_names = {**names, "cafe24": CAFE24_REAL_NAME}
statuses = store.statuses()
configured = configured or {}
problems = []
@@ -260,12 +309,18 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
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)
# 일 합계 = 카페24(실적) + 공동구매 + 나머지(2026-11-02) — 공동구매를 필터로 뺐으면 실적 + 나머지.
# 일 합계 ROAS 도 이 값 기준이라 _ad_lines 앞에서.
for r, s in zip(table, calc.main_table(period, codes, summary, today=today, holidays=holidays)):
r["total"] = s["total"]
if "cafe24" in codes:
r["cells"][CAFE24_EX_GB] = s["cells"]["cafe24"]
_ad_lines(store, table, codes, cells, period, q_start, q_end)
for r in table:
for g, members in group_members.items():
r["cells"][g] = calc.total(calc.Money(gross=r["cells"][c]["gross"], commission=r["cells"][c]["commission"])
for c in members).as_dict()
_cafe24_ex_gb_column(markets, codes, cols, names, short, table)
_cafe24_real_column(cols, names, short, gb)
def url(kind: str, anchor_d: date | None = None, start: date | None = None, end: date | None = None) -> str:
if kind == "custom":
@@ -305,10 +360,11 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
"selected_all": len(codes) == len(all_codes),
"kpis": kpis,
"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),
"chart_share": [{"code": c, "name": names[c], **share[c].as_dict()} for c in codes],
"summary_names": summary_names,
"month": calc.month_summary(month_period.start.year, month_period.start.month, codes, summary),
"year": calc.year_months(year_period.start.year, codes, summary, today=today),
"chart_daily": calc.daily_series(period, codes, summary),
"chart_share": [{"code": c, "name": summary_names[c], **share[c].as_dict()} for c in codes],
"problems": problems,
"manual_codes": manual_codes,
"manual_cells": manual_cells,
@@ -325,7 +381,7 @@ def build_dashboard(store: Any, *, kind: str, anchor: date, today: date,
def _short_name(name: str) -> str:
return {"네이버 스마트스토어": "네이버", "토스쇼핑": "토스"}.get(name, name)
return {"네이버 스마트스토어": "네이버", "토스쇼핑": "토스", "카페24": "카페24(전체)"}.get(name, name)
def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapping[str, Any],
@@ -381,7 +437,14 @@ def build_settings(store: Any, *, configured: Mapping[str, bool], key_info: Mapp
else:
blocks.append({"row": r, "children": []})
stale = {v: n for v, n in key_versions_in_use.items() if key_info.get("current_version") and v != key_info["current_version"]}
return {"rows": rows, "blocks": blocks, "groups": groups,
# "매출 실적 표 열 숨기기" 목록 = 매출 실적 표에 나오는 열(그룹 열은 하위를 다 숨기면 사라진다)
hide_options: list[dict[str, str]] = []
for r in rows:
if not r["is_group"] and r["enabled"] and r["include_in_sales"]:
hide_options.append({"code": r["code"], "name": _short_name(r["name"])})
if r["code"] == "cafe24":
hide_options.append({"code": CAFE24_EX_GB, "name": CAFE24_REAL_NAME})
return {"rows": rows, "blocks": blocks, "groups": groups, "hide_options": hide_options, "hidden_codes": load_hidden(store),
"custom_ready": bool(store_rows) and "is_custom" in store_rows[0],
"key_info": key_info, "key_versions_in_use": dict(key_versions_in_use),
"stale_key_rows": sum(stale.values()), "sample_count": sample_count,
+48 -8
View File
@@ -29,6 +29,8 @@ JSON API — 관리자
POST /performance/api/marketplaces 쇼핑몰(수동 입력 전용)·그룹 직접 추가(009)
DELETE /performance/api/marketplaces/{code} 직접 추가 쇼핑몰·그룹 삭제(그 쇼핑몰 수동 입력·수수료도)
PUT /performance/api/marketplace-order 쇼핑몰 순서(설정 드래그 — 매출 실적 열 순서)
PUT /performance/api/hidden-marketplaces 매출 실적 표 열 숨기기(모든 사용자에게 적용)
PUT /performance/api/display-unit 매출 단위(모든 사용자에게 적용)
GET /performance/api/marketplaces/{code}/manual-days 수동 입력해 둔 날 수(삭제 확인 문구)
POST /performance/api/marketplaces/{code}/rates 수수료율(적용 시작일)
DELETE /performance/api/marketplaces/{code}/rates/{id}
@@ -147,7 +149,7 @@ def dashboard_page(
ctx["metric"] = metric if metric in ("gross", "commission", "net") else "net"
ctx["auto_sync"] = _auto_sync_ctx(store, "sales")
ctx["update_watch"] = _update_watch("sales", user)
_unit_ctx(request, ctx)
_unit_ctx(store, ctx)
_colw_ctx(request, ctx)
return render_template(request, "performance/index.html", {**common.base_ctx(user, active_tab="dashboard"), **ctx})
@@ -198,11 +200,11 @@ def api_update_status(request: Request, kind: str = "sales") -> JSONResponse:
"user": job.user if job else ""})
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
def _unit_ctx(store: Any, ctx: dict[str, Any]) -> None:
"""매출 단위(원·천원·백만원) — 관리자가 실적 설정 "공통 보기 설정"에서 정하면 모든 사용자에게 같게. 템플릿은 amt(v) 로 그린다."""
from .dashboard import UNITS, amount_text, load_unit # noqa: WPS433
unit = normalize_unit(request.cookies.get(UNIT_COOKIE))
unit = load_unit(store)
ctx["unit"] = unit
ctx["unit_label"] = UNITS[unit][2]
ctx["amt"] = lambda v: amount_text(v, unit)
@@ -231,13 +233,13 @@ def ads_page(
return g
store, user = g
from .ad_spend import build_ad_dashboard # noqa: WPS433
from .dashboard import _sales_marketplaces # noqa: WPS433
from .dashboard import _sales_marketplaces, total_sales_codes # noqa: WPS433
today = today_kst()
ctx = build_ad_dashboard(
store, kind=period, anchor=_parse_date(d) or today, today=today,
custom_from=_parse_date(from_), custom_to=_parse_date(to), holidays=_holidays(),
sales_codes=[m["code"] for m in _sales_marketplaces(store)],
sales_codes=total_sales_codes(_sales_marketplaces(store)),
)
# [광고비 업데이트](2026-10-20) — 관리자가 실적 설정에서 인증정보를 넣은 광고 연동 전부를 진행 창으로.
# 마지막 업데이트 = 광고 API 마지막 성공 가져오기, 다음 업데이트 = 매출 자동 업데이트와 같은 회차.
@@ -283,7 +285,7 @@ def settings_page(request: Request):
ctx["ad_sources"] = _ad_source_rows(store, ad_sync.configured())
ctx["ad_api_ready"] = store.ad_api_ready()
ctx["auto_sync_settings"] = _auto_sync_settings_ctx(store) # 카드는 관리자에게만(템플릿)
_unit_ctx(request, ctx)
_unit_ctx(store, ctx)
_colw_ctx(request, ctx)
return render_template(request, "performance/settings.html",
{**common.base_ctx(user, active_tab="settings", page_title="실적 설정"), **ctx})
@@ -954,6 +956,44 @@ def api_marketplace_order(request: Request, payload: dict[str, Any] = Body(...))
return JSONResponse({"ok": True})
@router.put("/api/hidden-marketplaces")
def api_hidden_marketplaces(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""매출 실적 표 열 숨기기(2026-11-02, 관리자, 마이그레이션 011) — 체크한 코드 전부. 모든 사용자의 표에 적용."""
from .dashboard import CAFE24_EX_GB, HIDDEN_SETTING # noqa: WPS433
store, user = common.require_store(request, admin=True)
raw = payload.get("codes")
if not isinstance(raw, list):
raise HTTPException(status_code=400, detail="숨길 쇼핑몰 목록이 필요합니다.")
known = {m["code"] for m in store.list_marketplaces()} | {CAFE24_EX_GB}
codes = sorted({str(c) for c in raw} & known)
_save_shared_setting(store, HIDDEN_SETTING, codes, user)
return JSONResponse({"ok": True, "codes": codes})
@router.put("/api/display-unit")
def api_display_unit(request: Request, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""매출 단위(2026-11-02, 관리자, 마이그레이션 011) — won·thousand·million. 모든 사용자의 매출 실적 화면에 적용."""
from .dashboard import UNIT_SETTING, UNITS # noqa: WPS433
store, user = common.require_store(request, admin=True)
unit = payload.get("unit")
if not isinstance(unit, str) or unit not in UNITS:
raise HTTPException(status_code=400, detail="알 수 없는 매출 단위입니다.")
_save_shared_setting(store, UNIT_SETTING, unit, user)
return JSONResponse({"ok": True, "unit": unit})
def _save_shared_setting(store: Any, key: str, value: Any, user: dict[str, Any]) -> None:
from .db import SettingsMigrationNeeded # noqa: WPS433
try:
store.set_setting(key, value, user=user.get("email", ""))
except SettingsMigrationNeeded:
raise HTTPException(status_code=503, detail="저장하려면 performance_db 마이그레이션 011"
"(scripts/sql/performance_db_011_settings.sql)을 먼저 적용해야 합니다.") from None
@router.put("/api/marketplaces/{code}")
def api_update_marketplace(request: Request, code: str, payload: dict[str, Any] = Body(...)) -> JSONResponse:
store, _ = common.require_store(request, admin=True)
@@ -0,0 +1,6 @@
{# 기간 이동(2026-11-02, 매출 실적·광고비 공통) — 날짜 바로 좌우에 화살표 이미지(SVG, 글자 높이), 글자 버튼 없음 #}
<div class="perf-nav">
<a class="perf-nav-btn" href="{{ nav.prev }}" title="{{ period.prev_label }}" aria-label="{{ period.prev_label }}"><svg viewBox="0 0 10 16" aria-hidden="true"><path d="M8 1.5 2 8l6 6.5"/></svg></a>
<span class="perf-nav-label">{{ period.label }}</span>
<a class="perf-nav-btn" href="{{ nav.next }}" title="{{ period.next_label }}" aria-label="{{ period.next_label }}"><svg viewBox="0 0 10 16" aria-hidden="true"><path d="M2 1.5 8 8l-6 6.5"/></svg></a>
</div>
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261030a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261102b" />{% endblock %}
{#- ROAS 덧붙임 — "광고비(ROAS%)". 광고비가 없으면 아무것도 안 붙는다. -#}
{%- macro roas(p) -%}{%- if p is not none -%}<span class="perf-roas">({{ "{:,}".format(p) }}%)</span>{%- endif -%}{%- endmacro -%}
@@ -24,11 +24,7 @@
<button type="button" class="perf-seg{% if period_kind == 'custom' %} is-active{% endif %}" id="perf-custom-btn">직접선택</button>
</div>
<div class="perf-nav">
<a class="perf-nav-btn" href="{{ nav.prev }}" title="{{ period.prev_label }}">‹ {{ period.prev_label }}</a>
<span class="perf-nav-label">{{ period.label }}</span>
<a class="perf-nav-btn" href="{{ nav.next }}" title="{{ period.next_label }}">{{ period.next_label }} ›</a>
</div>
{% include "performance/_period_nav.html" %}
<form class="perf-custom" id="perf-custom" method="get" action="/performance/ads"{% if period_kind != 'custom' %} hidden{% endif %}>
<input type="hidden" name="period" value="custom" />
@@ -102,8 +98,8 @@
<thead>
<tr>
<th class="perf-th-label" data-col="label">{% if period_kind == 'year' %}월{% else %}날짜{% endif %}</th>
{% for c in codes %}{% if c in detail_channels %}<th class="perf-th-detail" data-col="{{ c }}" 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 data-col="{{ c }}" 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" data-col="total">{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}</th>
{% for c in codes %}{% if c in detail_channels %}<th class="perf-th-detail" data-col="{{ c }}" 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 data-col="{{ c }}" 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 %}
</tr>
</thead>
<tbody>
@@ -112,6 +108,7 @@
<th class="perf-td-label" scope="row">
{{ r.label }}{% if r.holiday %}<small class="perf-hol">{{ r.holiday }}</small>{% endif %}
</th>
<td class="perf-num perf-td-total"><span class="v v-gross">{{ won(r.total.gross) }}</span>{{ roas(r.roas_total) }}</td>
{% for c in codes %}
{% set v = r.cells[c].gross %}
{% if r.kind == 'day' and not migration_needed %}
@@ -125,7 +122,6 @@
<td class="perf-num"><span class="v v-gross">{{ won(v) }}</span>{{ roas(r.roas[c]) }}</td>
{% endif %}
{% endfor %}
<td class="perf-num perf-td-total"><span class="v v-gross">{{ won(r.total.gross) }}</span>{{ roas(r.roas_total) }}</td>
</tr>
{% endfor %}
</tbody>
@@ -241,4 +237,4 @@
} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261030a" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261102b" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261030a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261102b" />{% endblock %}
{%- macro won(v) -%}
{%- if v is none -%}<span class="perf-na"></span>
@@ -42,11 +42,7 @@
<button type="button" class="perf-seg{% if period_kind == 'custom' %} is-active{% endif %}" id="perf-custom-btn">직접선택</button>
</div>
<div class="perf-nav">
<a class="perf-nav-btn" href="{{ nav.prev }}" title="{{ period.prev_label }}">‹ {{ period.prev_label }}</a>
<span class="perf-nav-label">{{ period.label }}</span>
<a class="perf-nav-btn" href="{{ nav.next }}" title="{{ period.next_label }}">{{ period.next_label }} ›</a>
</div>
{% include "performance/_period_nav.html" %}
<form class="perf-custom" id="perf-custom" method="get" action="/performance/"{% if period_kind != 'custom' %} hidden{% endif %}>
<input type="hidden" name="period" value="custom" />
@@ -142,6 +138,7 @@
<thead>
<tr>
<th class="perf-th-label" data-col="label">{% if period_kind == 'year' %}월{% else %}날짜{% endif %}</th>
<th class="perf-th-total" data-col="total">{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}</th>
{#- 그룹(2026-10-22) — 그룹 열 = 보이는 하위 쇼핑몰 합계, ⊟/⊞ 로 하위 열 접기/펴기(이 브라우저에 기억, 펼치고 접을 때 애니메이션).
하위 열은 .perf-gc 로 내용을 감싼다 — 접을 때 그 너비를 0 으로 줄여 열이 부드럽게 닫힌다. is-glast = 그룹의 마지막 하위 열(오른쪽 묶음 선) -#}
{% for col in cols %}{% set c = col.code %}
@@ -149,7 +146,6 @@
{% if col.kind == 'group' %}<th class="perf-th-group" data-col="{{ c }}" data-group-head="{{ c }}" title="{{ names[c] }} — 하위 쇼핑몰 {{ group_members[c] | length }}곳 매출 합계"><span class="perf-gh"><button type="button" class="perf-gtoggle" data-group-toggle="{{ c }}" aria-expanded="true" aria-label="{{ short_names[c] }} 하위 쇼핑몰 접기" title="하위 쇼핑몰 접기/펴기"><svg viewBox="0 0 18 18" width="18" height="18" aria-hidden="true"><rect class="g-box" x="1" y="1" width="16" height="16" rx="4"/><path class="g-h" d="M5 9h8"/><path class="g-v" d="M9 5v8"/></svg></button><span>{{ short_names[c] }}</span></span></th>
{% else %}<th data-col="{{ c }}"{% if sub %} class="perf-th-child{% if glast %} is-glast{% endif %}" data-group-child="{{ col.group }}"{% endif %} title="{{ names[c] }}{% if c in manual_codes %} — 수동 입력(날짜 칸을 눌러 입력){% endif %}">{% if sub %}<div class="perf-gc">{% endif %}{{ short_names[c] }}{% if c in manual_codes %} <span class="perf-manual-mark" aria-label="수동 입력">✎</span>{% endif %}{% if sub %}</div>{% endif %}</th>{% endif %}
{% endfor %}
<th class="perf-th-total" data-col="total">{% if period_kind == 'year' %}월 합계{% else %}일 합계{% endif %}</th>
</tr>
</thead>
<tbody>
@@ -158,6 +154,7 @@
<th class="perf-td-label" scope="row">
{{ r.label }}{% if r.holiday %}<small class="perf-hol">{{ r.holiday }}</small>{% endif %}
</th>
<td class="perf-num perf-td-total">{{ m3(r.total) }}{% if r.ads_total %}{{ adl_total(r.ads_total) }}{% endif %}</td>
{% for col in cols %}
{% set c = col.code %}
{% set m = r.cells[c] %}
@@ -166,9 +163,9 @@
{% set gc0 %}{% if sub %}<div class="perf-gc">{% endif %}{% endset %}{% set gc1 %}{% if sub %}</div>{% endif %}{% endset %}
{% if col.kind == 'group' %}
<td class="perf-num perf-td-group" data-group-cell="{{ c }}">{{ m3(m) }}</td>
{% elif col.kind == 'diff' %}{#- 카페24 − 카페24 공동구매(2026-10-30, dashboard._cafe24_ex_gb_column) — 계산 열이라 클릭·메모 없음 -#}
{% elif col.kind == 'diff' %}{#- 카페24(실적) = 카페24(전체) − 공동구매(dashboard._cafe24_real_column) — 계산 열이라 클릭·메모 없음, 광고비 줄은 카페24(전체)와 같음 -#}
{%- set b = r.cells[col.base] %}{#- 일 행 = 공동구매 칸 저장 때 performance.js 가 base(카페24 총매출,수수료,차감) − 새 값으로 바로 바꿈 -#}
<td class="perf-num{% if glast %} is-glast{% endif %}"{{ gattr }}{% if r.kind == 'day' %} data-diff-minus="{{ col.minus }}" data-base="{{ b.gross }},{{ b.commission }},{{ b.net }}"{% endif %}>{{ gc0 }}{{ m3(m) }}{{ gc1 }}</td>
<td class="perf-num{% if glast %} is-glast{% endif %}"{{ gattr }}{% if r.kind == 'day' and col.minus %} data-diff-minus="{{ col.minus }}" data-base="{{ b.gross }},{{ b.commission }},{{ b.net }}"{% endif %}>{{ gc0 }}{{ m3(m) }}{{ adl(r.ads[col.base]) }}{{ gc1 }}</td>
{% elif r.kind == 'day' and c in manual_codes %}
{% set is_manual = (r.date ~ '|' ~ c) in manual_cells %}
{% set fx = (formula_cells or {}).get(r.date ~ '|' ~ c) %}
@@ -182,7 +179,6 @@
{% if r['from'] %}data-code="{{ c }}" data-from="{{ r['from'] }}" data-to="{{ r['to'] }}"{% endif %}{% if r.kind == 'day' %} data-memo-code="{{ c }}" data-date="{{ r.date }}"{% endif %}{% if memo %} data-memo="{{ memo }}"{% endif %}>{{ gc0 }}{{ m3(m) }}{{ adl(r.ads[c]) }}{{ gc1 }}</td>
{% endif %}
{% endfor %}
<td class="perf-num perf-td-total">{{ m3(r.total) }}{% if r.ads_total %}{{ adl_total(r.ads_total) }}{% endif %}</td>
</tr>
{% endfor %}
</tbody>
@@ -218,7 +214,7 @@
<tbody>
{% for r in month.rows %}
<tr>
<th class="perf-td-label" scope="row">{{ names[r.code] }}</th>
<th class="perf-td-label" scope="row">{{ summary_names[r.code] }}</th>
<td class="perf-num">{{ won(r.gross) }}</td>
<td class="perf-num">{{ won(r.commission) }}</td>
<td class="perf-num">{{ won(r.net) }}</td>
@@ -277,6 +273,7 @@
<p class="perf-foot perf-muted">
매출 기준: 결제는 결제일, 취소·반품은 발생일에 반영(음수). 수수료는 그날 적용되는 쇼핑몰 수수료율로 계산하며
일·쇼핑몰 단위로 원 미만 반올림합니다. 금액을 누르면 주문 목록을 볼 수 있습니다.
일 합계·상단 금액·그래프·누적 = 카페24(실적) + 자사몰(공동구매) + 나머지 쇼핑몰(카페24(전체)는 더하지 않음).
</p>
</section>
@@ -297,4 +294,4 @@
} | tojson }}</script>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261030a" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261102b" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261030a" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/performance.css?v=20261102b" />{% endblock %}
{%- macro when(v) -%}{{ (v or '')[:16] | replace('T', ' ') or '—' }}{%- endmacro -%}
@@ -142,23 +142,12 @@
</p>
</div>
{# 보기 설정(2026-10-19) — 모듈 권한자 누구나, 이 브라우저에만(쿠키 perf_unit). 매출 실적 화면 금액·광고비 줄에 적용 #}
{# 보기 설정(2026-10-19) — 모듈 권한자 누구나, 이 브라우저에만 #}
<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>
{# 표 열 너비(2026-10-27, 쿠키 perf_colw) — 매출 실적·광고비 일자별 표. 수동 = 머리글 오른쪽 경계 드래그, 너비는 이 브라우저 localStorage(perf_colw_sales/ads) #}
<div class="perf-opt-row">
<span class="perf-opt-label">표 열 너비</span>
@@ -173,6 +162,36 @@
</div>
</div>
{% if is_admin %}
{# 공통 보기 설정(2026-11-02, 관리자, 마이그레이션 011 perf_settings) — 매출 단위·열 숨기기, 모든 사용자에게 적용 #}
<div class="erp-card perf-card" id="perf-shared-view">
<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 class="perf-opt-row">
<span class="perf-opt-label">숨길 쇼핑몰</span>
<div class="perf-hide-list">
{% for m in hide_options %}
<label class="perf-check"><input type="checkbox" data-hide="{{ m.code }}"{% if m.code in hidden_codes %} checked{% endif %} /> {{ m.name }}</label>
{% endfor %}
</div>
<span class="perf-muted">체크한 쇼핑몰은 일자별 표에서 열만 숨겨집니다. 일 합계·그래프·누적 금액은 그대로입니다.</span>
</div>
</div>
{% endif %}
{% if is_admin and auto_sync_settings %}
{# 자동 업데이트 일정(2026-10-26, 마이그레이션 011 perf_settings) — 매출 실적·광고비 따로: 사용·요일·시작/끝 시각(5분 단위)·간격(5분 단위,
기본 30분). [저장] = PUT /api/auto-sync-schedule, 스레드(auto_sync.py)가 1분 안에 반영. #}
@@ -328,4 +347,4 @@
</section>
{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261030a" defer></script>{% endblock %}
{% block scripts %}<script src="/static/performance.js?v=20261102b" defer></script>{% endblock %}
@@ -6,11 +6,12 @@ import importlib
from datetime import date
import pytest
from fastapi import FastAPI
from fastapi import FastAPI, HTTPException
from fastapi.testclient import TestClient
from app.modules.performance import common, dashboard
from app.modules.performance.adapters.registry import get_adapter
from app.modules.performance.db import SettingsMigrationNeeded
TODAY = date(2026, 10, 7)
@@ -36,6 +37,13 @@ class _Store:
(date(2026, 10, 6), "custom_a"): 7_000}
self.order = None
self.deleted = []
self.settings = {}
def get_setting(self, key):
return self.settings.get(key)
def set_setting(self, key, value, *, user=""):
self.settings[key] = value
def list_marketplaces(self):
return sorted((dict(r) for r in self.rows), key=lambda r: (r["sort_order"], r["code"]))
@@ -113,8 +121,8 @@ def test_dashboard_group_column_sums_children_without_double_count():
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY)
assert ctx["codes"] == ["cafe24", "naver", "custom_b", "custom_a", "custom_c"]
assert [(c["code"], c["kind"]) for c in ctx["cols"]] == [
("cafe24", "shop"), ("naver", "shop"), ("group_x", "group"), ("custom_b", "child"), ("custom_a", "child"),
("custom_c", "shop")]
("cafe24", "shop"), (dashboard.CAFE24_EX_GB, "diff"), ("naver", "shop"), ("group_x", "group"), ("custom_b", "child"),
("custom_a", "child"), ("custom_c", "shop")]
assert ctx["group_members"] == {"group_x": ["custom_b", "custom_a"]}
assert ctx["names"]["group_x"] == "오프라인"
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
@@ -127,7 +135,7 @@ def test_dashboard_group_column_sums_children_without_double_count():
def test_dashboard_filter_hides_group_when_no_child_selected():
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY, selected=["cafe24", "custom_c"])
assert [c["code"] for c in ctx["cols"]] == ["cafe24", "custom_c"] and ctx["group_members"] == {}
assert [c["code"] for c in ctx["cols"]] == ["cafe24", dashboard.CAFE24_EX_GB, "custom_c"] and ctx["group_members"] == {}
ctx = dashboard.build_dashboard(_Store(), kind="week", anchor=TODAY, today=TODAY, selected=["custom_a"])
assert [c["kind"] for c in ctx["cols"]] == ["group", "child"]
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
@@ -223,36 +231,152 @@ def test_dashboard_page_renders_group_header_and_child_cells(client):
assert 'data-group-child="group_x" data-manual-code="custom_a" data-date="2026-10-05"' in body
def test_cafe24_minus_groupbuy_column():
"""'카페24 공동구매' 바로 오른쪽 = 카페24 − 공동구매(2026-10-30). 표 열만 — 일 합계엔 안 더함."""
def _real(ctx, date_iso):
return next(r for r in ctx["table"] if r.get("date") == date_iso)["cells"][dashboard.CAFE24_EX_GB]
def test_cafe24_real_column():
"""카페24(실적) = 카페24(전체) 바로 오른쪽, 카페24 − 자사몰(공동구매). 표 열만 — 일 합계엔 안 더함."""
st = _Store()
st._find("custom_c")["name"] = "카페24 공동구매"
# 공동구매 없음 = 전체 그대로
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
assert _real(ctx, "2026-10-05")["gross"] == 1_000_000
assert ctx["short_names"]["cafe24"] == "카페24(전체)" and ctx["short_names"][dashboard.CAFE24_EX_GB] == "카페24(실적)"
st._find("custom_c")["name"] = "자사몰 (공동구매)"
st._find("custom_c")["parent_code"] = "group_x"
st.manual[(date(2026, 10, 5), "custom_c")] = 300_000
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
assert [c["code"] for c in ctx["cols"]][-2:] == ["custom_c", dashboard.CAFE24_EX_GB]
assert [c["code"] for c in ctx["cols"]][:2] == ["cafe24", dashboard.CAFE24_EX_GB]
assert ctx["cols"][1] == {"code": dashboard.CAFE24_EX_GB, "kind": "diff", "group": "", "base": "cafe24", "minus": "custom_c"}
assert _real(ctx, "2026-10-05") == {"gross": 700_000, "commission": 0, "net": 700_000}
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert day5["cells"][dashboard.CAFE24_EX_GB] == {"gross": 700_000, "commission": 0, "net": 700_000}
assert day5["total"]["gross"] == 1_450_000 # 카페24 + 매장 150,000 + 공동구매 300,000
# 일 합계 = 카페24(실적) 700,000 + 공동구매 300,000 + 매장 150,000 — 카페24(전체) 1,000,000 은 안 더함
assert day5["total"] == {"gross": 1_150_000, "commission": 10_000, "net": 1_140_000}
week = next(r for r in ctx["table"] if r["kind"] == "week")
assert week["cells"][dashboard.CAFE24_EX_GB]["gross"] == 700_000
assert week["total"]["gross"] == 1_157_000 # 주간합계도 같은 규칙(매장 157,000)
# 카페24 를 고르지 않으면 열 없음, 공동구매가 그룹 하위면 같은 그룹으로 접힘
# 공동구매를 필터로 빼도 실적에서는 뺀다 — 일 합계 = 실적 + 나머지
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY, selected=["cafe24"])
assert _real(ctx, "2026-10-05")["gross"] == 700_000
assert next(r for r in ctx["table"] if r.get("date") == "2026-10-05")["total"]["gross"] == 700_000
# 카페24 를 고르지 않으면 열 없음, 일 합계에 공동구매 그대로
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY, selected=["custom_c"])
assert dashboard.CAFE24_EX_GB not in [c["code"] for c in ctx["cols"]]
st._find("custom_c")["parent_code"] = "group_x"
assert next(r for r in ctx["table"] if r.get("date") == "2026-10-05")["total"]["gross"] == 300_000
def test_summaries_match_day_total():
"""KPI·추이·비중·월/연 누적도 일 합계와 같은 기준 — 공동구매가 두 번 안 들어감, 카페24 줄 = 카페24(실적)."""
st = _Store()
st._find("custom_c")["name"] = "자사몰(공동구매)"
st.manual[(date(2026, 10, 5), "custom_c")] = 300_000
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
assert ctx["cols"][-1] == {"code": dashboard.CAFE24_EX_GB, "kind": "diff", "group": "group_x",
"base": "cafe24", "minus": "custom_c"}
week_total = next(r for r in ctx["table"] if r["kind"] == "week")["total"]
assert week_total["gross"] == 1_157_000 # 카페24(전체) 1,000,000 + 매장 157,000
assert ctx["kpis"][0]["value"] == week_total["net"]
assert next(p for p in ctx["chart_daily"] if p["date"] == "2026-10-05")["gross"] == 1_150_000
assert sum(s["gross"] for s in ctx["chart_share"]) == 1_157_000
assert next(s for s in ctx["chart_share"] if s["code"] == "cafe24")["name"] == "카페24(실적)"
assert ctx["month"]["total"]["gross"] == 1_157_000 and ctx["year"]["total"]["gross"] == 1_157_000
assert next(r for r in ctx["month"]["rows"] if r["code"] == "cafe24")["gross"] == 700_000
assert ctx["year"]["rows"][9]["gross"] == 1_157_000
# 카페24(전체) 열은 원래 값 그대로, 공동구매 열도 그대로
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert day5["cells"]["cafe24"]["gross"] == 1_000_000 and day5["cells"]["custom_c"]["gross"] == 300_000
def test_dashboard_page_renders_cafe24_minus_groupbuy(client):
client.store._find("custom_c")["name"] = "카페24 공동구매"
def test_total_sales_codes_drops_groupbuy_only_with_cafe24():
m = lambda c, n: {"code": c, "name": n} # noqa: E731
assert dashboard.total_sales_codes([m("cafe24", "카페24"), m("x", "자사몰 (공동구매)"), m("y", "네이버")]) == ["cafe24", "y"]
assert dashboard.total_sales_codes([m("x", "자사몰(공동구매)"), m("y", "네이버")]) == ["x", "y"]
assert dashboard.total_sales_codes([m("cafe24", "카페24"), m("y", "네이버")]) == ["cafe24", "y"]
def test_day_total_roas_uses_real_total():
"""일 합계 ROAS = 일 합계 금액(공동구매 중복 없음) ÷ 일 합계 광고비."""
st = _Store()
st._find("custom_c")["name"] = "자사몰(공동구매)"
st.manual[(date(2026, 10, 5), "custom_c")] = 300_000
st.ad_amounts = lambda s, e: ({(date(2026, 10, 5), "google"): 115_000}, {})
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
day5 = next(r for r in ctx["table"] if r.get("date") == "2026-10-05")
assert day5["ads_total"]["amount"] == 115_000 and day5["ads_total"]["roas"] == 1000 # 1,150,000 ÷ 115,000
def test_hidden_columns_only_hide_table_columns():
"""열 숨기기(모든 사용자 공통 설정) — 열만 숨김, 일 합계·그래프 그대로. 하위를 다 숨기면 그룹 열도 없음."""
st = _Store()
st.settings[dashboard.HIDDEN_SETTING] = ["cafe24", "custom_a", "custom_b"]
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
assert [c["code"] for c in ctx["cols"]] == [dashboard.CAFE24_EX_GB, "naver", "custom_c"]
assert _real(ctx, "2026-10-05")["gross"] == 1_000_000 # 전체를 숨겨도 실적은 계산됨
assert next(r for r in ctx["table"] if r.get("date") == "2026-10-05")["total"]["gross"] == 1_150_000
assert ctx["codes"] == ["cafe24", "naver", "custom_b", "custom_a", "custom_c"]
st.settings[dashboard.HIDDEN_SETTING] = [dashboard.CAFE24_EX_GB]
ctx = dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)
assert dashboard.CAFE24_EX_GB not in [c["code"] for c in ctx["cols"]]
def test_hidden_setting_missing_migration_shows_everything():
st = _Store()
def raises(key):
raise SettingsMigrationNeeded()
st.get_setting = raises
assert dashboard.load_hidden(st) == set()
assert "naver" in [c["code"] for c in dashboard.build_dashboard(st, kind="week", anchor=TODAY, today=TODAY)["cols"]]
def test_api_hidden_marketplaces(client):
"""저장값이 그대로 다른 사용자 화면에도 — 쿠키가 아니라 서버 설정(모르는 코드는 버림)."""
r = client.put("/performance/api/hidden-marketplaces", json={"codes": ["naver", "ghost", dashboard.CAFE24_EX_GB, "naver"]})
assert r.status_code == 200 and r.json()["codes"] == [dashboard.CAFE24_EX_GB, "naver"]
assert client.store.settings[dashboard.HIDDEN_SETTING] == [dashboard.CAFE24_EX_GB, "naver"]
head = TestClient(client.app).get("/performance/?period=week&d=2026-10-07").text.split("<thead>", 1)[1].split("</thead>", 1)[0]
assert 'data-col="naver"' not in head and 'data-col="cafe24"' in head
assert client.put("/performance/api/hidden-marketplaces", json={"codes": "naver"}).status_code == 400
assert client.put("/performance/api/hidden-marketplaces", json={"codes": []}).json()["codes"] == []
def raises(key, value, *, user=""):
raise SettingsMigrationNeeded()
client.store.set_setting = raises
assert client.put("/performance/api/hidden-marketplaces", json={"codes": []}).status_code == 503
def test_api_hidden_marketplaces_admin_only(client, monkeypatch):
def require_store(request, admin=False):
if admin:
raise HTTPException(status_code=403)
return client.store, {"email": "u@x"}
monkeypatch.setattr(common, "require_store", require_store)
assert client.put("/performance/api/hidden-marketplaces", json={"codes": ["naver"]}).status_code == 403
assert dashboard.HIDDEN_SETTING not in client.store.settings
def test_dashboard_page_renders_cafe24_real(client):
client.store._find("custom_c")["name"] = "자사몰(공동구매)"
client.store.manual[(date(2026, 10, 5), "custom_c")] = 300_000
client.store.settings[dashboard.HIDDEN_SETTING] = ["naver"]
html = client.get("/performance/?period=week&d=2026-10-07").text
head = html.split("<thead>", 1)[1].split("</thead>", 1)[0]
assert head.index('data-col="custom_c"') < head.index(f'data-col="{dashboard.CAFE24_EX_GB}"')
assert "카페24(공구 제외)" in head
# 날짜 → 일 합계 → 카페24(전체) → 카페24(실적)
assert head.index('data-col="label"') < head.index('data-col="total"') < head.index('data-col="cafe24"') < head.index(f'data-col="{dashboard.CAFE24_EX_GB}"')
assert "카페24(전체)" in head and "카페24(실적)" in head and 'data-col="naver"' not in head
body = html.split("<tbody>", 1)[1].split("</tbody>", 1)[0]
assert "700,000" in body
# 일 행만 화면 즉시 계산용 값(카페24 총매출,수수료,차감) — performance.js saveManual
assert 'data-diff-minus="custom_c" data-base="1000000,0,1000000"' in body
def test_cafe24_real_shows_same_ad_lines(client):
"""카페24(전체)의 구글·메타 광고비 줄이 카페24(실적) 칸에도 그대로."""
client.store.ad_amounts = lambda s, e: ({(date(2026, 10, 5), "google"): 11_000, (date(2026, 10, 5), "meta"): 22_000}, {})
body = client.get("/performance/?period=week&d=2026-10-07").text.split("<tbody>", 1)[1]
row = next(tr for tr in body.split("<tr ") if 'data-date="2026-10-05"' in tr)
assert row.count("<i>구글</i>11,000") == 2 and row.count("<i>메타</i>22,000") == 2
assert row.index("<i>구글</i>") < row.index("data-code=\"naver\"")
@@ -121,15 +121,51 @@ def test_dashboard_page_renders_unit_and_ad_lines(monkeypatch):
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")
# 매출 단위 = 서버 공통 설정(2026-11-02) — 예전 브라우저 쿠키는 안 봄
client.cookies.set("perf_unit", "million")
assert "단위:" not in client.get("/performance/?period=week&d=2026-10-07").text
client.cookies.delete("perf_unit")
store.get_setting = lambda key: "thousand" if key == dashboard.UNIT_SETTING else None
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")
store.get_setting = lambda key: "million" if key == dashboard.UNIT_SETTING else None
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_api_display_unit(monkeypatch):
import importlib
from fastapi import FastAPI, HTTPException
from fastapi.testclient import TestClient
from app.modules.performance import common
perf_router = importlib.import_module("app.modules.performance.router")
saved = {}
store = _Store()
store.set_setting = lambda key, value, *, user="": saved.__setitem__(key, (value, user))
monkeypatch.setattr(common, "require_store", lambda request, admin=False: (store, {"email": "king@x"}))
app = FastAPI()
app.include_router(perf_router.router)
client = TestClient(app)
assert client.put("/performance/api/display-unit", json={"unit": "thousand"}).json()["unit"] == "thousand"
assert saved[dashboard.UNIT_SETTING] == ("thousand", "king@x")
assert client.put("/performance/api/display-unit", json={"unit": "nope"}).status_code == 400
assert client.put("/performance/api/display-unit", json={"unit": ["won"]}).status_code == 400
def not_admin(request, admin=False):
if admin:
raise HTTPException(status_code=403)
return store, {"email": "u@x"}
monkeypatch.setattr(common, "require_store", not_admin)
assert client.put("/performance/api/display-unit", json={"unit": "won"}).status_code == 403
assert saved[dashboard.UNIT_SETTING] == ("thousand", "king@x")
def test_total_roas_uses_whole_day_total():
"""일 합계 ROAS = 그날 일 합계 금액(광고비 없는 쇼핑몰 매출 포함) ÷ 일 합계 광고비 — 예전엔 광고비 있는 쇼핑몰 매출만 더했다."""
class _S(_Store):
+20 -5
View File
@@ -6,11 +6,26 @@
- 월간 달력(구글식 bar) / 연차·반차 신청 / 승인 워크플로 / 옵션(승인자·통보자·잔여 연차).
- **설정 화면 없음**(2026-10-27 삭제 — [설정] 버튼·공휴일 추가/삭제 기능 포함). `GET /vacation/settings` 는 옵션으로 넘김, 공휴일 저장 주소 없음.
- 권한키 `vacation`(사용)·`vacation_approver`(승인).
- **신청 화면 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업**(2026-10-27, 공용 `app/static/erp-datepop.js`·`.css` — project.js `openDatePopover`·
`enhanceDateInput` 을 떼어 낸 것). 시작일·종료일 input 은 숨긴 값 저장소, 옆 날짜 버튼 둘(`ErpDatePop.enhanceRange`) — 어느 쪽을 눌러도 같은
기간 팝업(누른 칸이 먼저, 시작일 고르면 종료일 칸으로, 종료일 고르면 닫힘, 지우기 없음), 반차는 하루짜리 팝업(시작=종료). 직접 입력(10/27·1027 Enter).
공휴일 = 국경일·대체공휴일(`router._red_holidays` → `db.holiday_map`, 작년~내년, `#vac-holidays`) — 팝업 빨강·이름 + 예상 일수에서도 뺀다(서버 compute_days 와 같은 표).
테스트 `tests/js/vacation_datepop.browser.test.js`(`render_vacation.py`).
- **신청 화면**(2026-11-02, `form.html`) = 위 휴가 종류 라디오(고르면 검은 배경·흰 굵은 글씨) · 왼쪽 붙박이 달력(공용 `ErpDatePop.mountRange` — 팝업과 같은 `.pj-dp-*` 서식,
첫 클릭 시작일·둘째 클릭 종료일·셋째 새로, 하루 = 동그라미, 기간 = 둥근 막대, 반차 = 클릭마다 하루) · 오른쪽 시작일·종료일(읽기 전용, 달력이 채움)·구분·예상 일수·사유 · 아래 결재 라인.
하루짜리는 종료 구분을 숨기고 보내지 않는다(서버 compute_days 도 시작 구분만 씀). 시작일·종료일 숨긴 칸은 브라우저 필수 검사가 안 돼 `vacation.js` 가 제출 전 확인.
공휴일 = 국경일·대체공휴일(`router._red_holidays` → `db.holiday_map`, 작년~내년, `#vac-holidays`) — 달력 빨강·이름(10.5px, 달력 폭 380px 라야 "석가탄신일"이 안 잘림) + 예상 일수에서도 뺀다(서버 compute_days 와 같은 표).
옵션의 입사일 버튼은 그대로 `ErpDatePop.enhance`(팝업). 테스트 `tests/js/vacation_datepop.browser.test.js`(`render_vacation.py`).
## 협의자 결재 (2026-11-02, 마이그레이션 `vacation_db_003_consults.sql`)
- 흐름: 작성중 → (협의자 있으면) **협의중** → 모두 승인 → **제출**(결재자 승인 대기) → 승인. 협의자 한 명이 반려하면 신청도 반려(`approver_email` = 그 협의자). 수정·재제출하면 협의가 처음부터(`db.submit`).
협의중에는 결재자가 승인·반려 못 함(`approve`·`reject` 가 status='제출' 만). 일수·연차 차감은 그대로 승인 때만. 마지막 두 명 동시 처리는 `decide_consult` 가 신청 줄을 잠가 막음.
- 표 `vacation_consults`(신청 삭제 시 CASCADE) — 이메일·이름·협의 내용·상태 대기|승인|반려·반려 사유·처리 시각. 003 전이면 `consults_ready()` False → 협의자 칸 잠김, 예전처럼 제출.
- 신청 화면: [구성원 선택] = **ERP 등록 구성원 전체**(`router._people`, 휴가 권한 무관, 본인 제외) 아이콘 + 이름, 복수. 고른 사람마다 협의 내용 칸(`consult_email`·`consult_message` 같은 순서 — 빈 내용도 자리 유지).
[협의자 없음] 체크 = 칸 잠김·전송 안 함. 제출인데 둘 다 없으면 400(작성중 저장은 통과). 통보자·결재자 = 옵션 값, 아이콘 + 이름 표시만.
- 메일(`notify.py`): 제출 = 협의자마다 따로 한 통(자기 내용만, `consult_request`) + 결재자·통보자(전체 협의자·내용). 모두 승인 = `consulted`(결재자·통보자·신청자). 협의 반려 = `rejected`. 한 명 승인만으로는 메일 없음.
- 화면: 달력 위 [내 신청 내역] `/vacation/mine`(협의자별 상태 → 결재 상태), [협의 대기 N] → `/vacation/pending#consults`(이 화면은 이제 누구나, 승인 대기 표는 결재자만, 표에 협의 내용).
상세 = 결재 진행·협의자별 내용·협의 승인/반려. **보기 권한**: 신청자·결재자·통보자 = 전체, 협의자 = 자기 줄만(서버가 거름, 메일 기록도 안 보임).
- **휴가 권한 없는 협의자**: 사이드바에 휴가 메뉴가 없어 메일 링크로 상세(`_guard(consult_of=…)`)에 들어와 처리한다. 달력·내역·대기 화면은 권한이 있어야 함.
- **메일 실패 → Gmail 연결·다시 보내기**(2026-11-02): 처리는 먼저 저장(메일 때문에 결재가 막히지 않음). Gmail 미연결이면 `_notify` 가 메일을 바로 시도해 실패 기록을 남기고, 상세 위에 안내(`router._failed_mail` — 그 신청의 마지막 메일이 내가 보내다 실패한 것이고 상태가 그대로일 때, 협의자·신청자·결재자 공통).
[Gmail 연결] → `/vacation/gmail/connect?next=/vacation/{id}` → 구글 → 상세로 복귀 → [메일 다시 보내기] `POST /vacation/{id}/mail-retry`. 협의자는 휴가 권한이 없어도 연결(세션 `_gmail_consultant`, 콜백은 `inout/router.py`). 다시 보낼 때 이미 처리한 협의자에게는 협의 요청을 안 보냄.
- 테스트 `tests/test_vacation_options_mail.py`(메일 내용·폼·권한), `tests/test_vacation_db.py`(실제 PG 흐름).
## 공휴일 · 연차 (2026-10-27)
+101 -11
View File
@@ -337,15 +337,96 @@ class VacationDBStore:
).fetchone()
return self._req_serialize(row) if row else None
# ── 협의자(마이그레이션 003, 2026-11-02) — 테이블이 없으면 협의자 없음 ──
def consults_ready(self) -> bool:
with self._pool.connection() as conn:
row = conn.execute("SELECT to_regclass('public.vacation_consults') AS r").fetchone()
return bool(row and row["r"])
@staticmethod
def _consult_serialize(row: dict[str, Any]) -> dict[str, Any]:
out = dict(row)
if isinstance(out.get("decided_at"), datetime):
out["decided_at"] = out["decided_at"].astimezone(KST).isoformat(timespec="seconds")
return out
def consults_for(self, request_ids: list[str]) -> dict[str, list[dict[str, Any]]]:
"""{신청 id: [협의자…]} — 지정한 순서대로."""
if not request_ids or not self.consults_ready():
return {}
with self._pool.connection() as conn:
rows = conn.execute("SELECT * FROM vacation_consults WHERE request_id = ANY(%s) ORDER BY id",
(list(request_ids),)).fetchall()
out: dict[str, list[dict[str, Any]]] = {}
for r in rows:
out.setdefault(r["request_id"], []).append(self._consult_serialize(r))
return out
def list_consults(self, *, request_id: str) -> list[dict[str, Any]]:
return self.consults_for([request_id]).get(request_id, [])
def my_consults(self, *, email: str) -> list[dict[str, Any]]:
"""내 협의 차례인 신청(협의중 + 내 줄 대기) — 시작일 순, 줄마다 my_message."""
if not self.consults_ready():
return []
with self._pool.connection() as conn:
rows = conn.execute(
"SELECT r.*, c.message AS my_message FROM vacation_consults c JOIN vacation_requests r ON r.id = c.request_id "
"WHERE c.email = %s AND c.state = '대기' AND r.status = '협의중' ORDER BY r.start_date, r.created_at",
(email.lower().strip(),)).fetchall()
return [self._req_serialize(r) for r in rows]
@staticmethod
def _replace_consults(conn: Any, request_id: str, consults: list[dict[str, Any]]) -> None:
conn.execute("DELETE FROM vacation_consults WHERE request_id = %s", (request_id,))
for c in consults:
conn.execute("INSERT INTO vacation_consults (request_id, email, name, message) VALUES (%s, %s, %s, %s)",
(request_id, c["email"], c.get("name") or "", c.get("message") or ""))
def decide_consult(self, *, request_id: str, email: str, approve: bool, reason: str = "") -> tuple[dict[str, Any], str | None]:
"""협의자 한 명의 승인·반려. 반환 (신청, 알릴 일): 모두 승인 → 제출로 넘어감("consulted"), 반려 → 신청도 반려("rejected"),
아직 남은 협의자가 있으면 None. 신청 줄을 잠가 마지막 두 명이 동시에 눌러도 한 번만 넘어간다."""
email = email.lower().strip()
reason = (reason or "").strip()
if not approve and not reason:
raise ValueError("반려 사유는 필수입니다.")
with self._pool.connection() as conn, conn.transaction():
head = conn.execute("SELECT status FROM vacation_requests WHERE id = %s FOR UPDATE", (request_id,)).fetchone()
if not head:
raise KeyError(request_id)
mine = conn.execute("SELECT state FROM vacation_consults WHERE request_id = %s AND email = %s",
(request_id, email)).fetchone()
if not mine:
raise PermissionError("이 신청의 협의자만 처리할 수 있습니다.")
if head["status"] != "협의중" or mine["state"] != "대기":
raise ValueError("협의 대기 중이 아닙니다(이미 처리됨).")
conn.execute("UPDATE vacation_consults SET state = %s, comment = %s, decided_at = now() WHERE request_id = %s AND email = %s",
("승인" if approve else "반려", reason, request_id, email))
event: str | None = None
if not approve:
event = "rejected"
row = conn.execute("UPDATE vacation_requests SET status = '반려', approver_email = %s, decided_at = now(), "
"reject_reason = %s WHERE id = %s RETURNING *", (email, reason, request_id)).fetchone()
elif conn.execute("SELECT 1 FROM vacation_consults WHERE request_id = %s AND state <> '승인' LIMIT 1", (request_id,)).fetchone():
row = conn.execute("SELECT * FROM vacation_requests WHERE id = %s", (request_id,)).fetchone()
else:
event = "consulted"
row = conn.execute("UPDATE vacation_requests SET status = '제출' WHERE id = %s RETURNING *", (request_id,)).fetchone()
return self._req_serialize(row), event
def create_request(
self, *, owner: str, owner_name: str, payload: dict[str, Any], status: str = "작성중"
self, *, owner: str, owner_name: str, payload: dict[str, Any], status: str = "작성중",
consults: list[dict[str, Any]] | None = None,
) -> dict[str, Any]:
"""consults = [{email, name, message}] — 제출이면서 협의자가 있으면 협의중으로 시작."""
h = self._normalize_payload(payload)
if status not in STATUSES:
status = "작성중"
if status == "제출" and consults:
status = "협의중"
days = self._calc_days(h)
req_id = uuid.uuid4().hex[:12]
with self._pool.connection() as conn:
with self._pool.connection() as conn, conn.transaction():
row = conn.execute(
"""
INSERT INTO vacation_requests
@@ -368,12 +449,14 @@ class VacationDBStore:
status,
),
).fetchone()
if consults:
self._replace_consults(conn, req_id, consults)
return self._req_serialize(row)
def update_request(
self, *, request_id: str, owner: str, payload: dict[str, Any]
self, *, request_id: str, owner: str, payload: dict[str, Any], consults: list[dict[str, Any]] | None = None
) -> dict[str, Any]:
"""작성중/반려 상태에서만 본인이 수정 가능."""
"""작성중/반려 상태에서만 본인이 수정 가능. consults 를 넘기면 협의자를 그 목록으로 바꾼다(003 전이면 None)."""
owner = owner.lower().strip()
current = self.get_request(request_id=request_id)
if not current:
@@ -384,7 +467,7 @@ class VacationDBStore:
raise ValueError(f"{current['status']} 상태에서는 수정할 수 없습니다.")
h = self._normalize_payload(payload)
days = self._calc_days(h)
with self._pool.connection() as conn:
with self._pool.connection() as conn, conn.transaction():
row = conn.execute(
"""
UPDATE vacation_requests
@@ -407,25 +490,32 @@ class VacationDBStore:
owner,
),
).fetchone()
if row and consults is not None:
self._replace_consults(conn, request_id, consults)
if not row:
raise KeyError(request_id)
return self._req_serialize(row)
# ── 워크플로 ──
def submit(self, *, request_id: str, owner: str) -> dict[str, Any]:
"""작성중/반려 → 제출 (본인)."""
"""작성중/반려 → 제출(본인). 협의자가 있으면 협의중으로, 다시 제출하면 협의도 처음부터."""
owner = owner.lower().strip()
with self._pool.connection() as conn:
ready = self.consults_ready() # 트랜잭션 전에 — 안에서 두 번째 연결을 잡지 않게
with self._pool.connection() as conn, conn.transaction():
has = ready and conn.execute("SELECT 1 FROM vacation_consults WHERE request_id = %s LIMIT 1", (request_id,)).fetchone()
row = conn.execute(
"""
UPDATE vacation_requests
SET status = '제출', reject_reason = '',
SET status = %s, reject_reason = '',
approver_email = NULL, decided_at = NULL
WHERE id = %s AND owner = %s AND status IN ('작성중', '반려')
RETURNING *
""",
(request_id, owner),
("협의중" if has else "제출", request_id, owner),
).fetchone()
if row and has:
conn.execute("UPDATE vacation_consults SET state = '대기', comment = '', decided_at = NULL WHERE request_id = %s",
(request_id,))
if not row:
raise ValueError("작성중/반려 상태에서만 제출할 수 있습니다.")
return self._req_serialize(row)
@@ -487,7 +577,7 @@ class VacationDBStore:
"""완전 삭제.
- 관리자(is_admin): 모든 상태 삭제 가능.
- 일반 사용자: 본인 + 승인 전(작성중/제출/반려)만. 승인/취소 건은 불가.
- 일반 사용자: 본인 + 승인 전(작성중/협의중/제출/반려)만. 승인/취소 건은 불가.
"""
user_email = user_email.lower().strip()
current = self.get_request(request_id=request_id)
@@ -496,7 +586,7 @@ class VacationDBStore:
if not is_admin:
if current["owner"] != user_email:
raise PermissionError("본인 신청만 삭제할 수 있습니다.")
if current["status"] not in ("작성중", "제출", "반려"):
if current["status"] not in ("작성중", "협의중", "제출", "반려"):
raise ValueError("승인/취소된 휴가는 삭제할 수 없습니다. (관리자 문의)")
with self._pool.connection() as conn:
cur = conn.execute(
+47 -15
View File
@@ -4,7 +4,9 @@
제출 = 승인자 + 승인 통보자
승인 = 승인자 + 승인 통보자 + 신청자
반려 = 승인자 + 승인 통보자 + 신청자
협의 완료(협의자 모두 승인) = 승인자 + 승인 통보자 + 신청자
승인자 = 휴가 옵션의 승인자(없으면 vacation_approver 권한자 — ERP 관리자는 자동으로 넣지 않는다).
협의자(2026-11-02)가 있으면 제출 때 협의자마다 따로 한 통 — 자기 협의 내용만. 그 밖의 메일은 협의자 전체와 협의 내용을 싣는다.
보내는 사람 = 그 일을 한 사람(제출 = 신청자, 승인·반려 = 처리한 승인자)의 **본인 Gmail** — 입출고 발주 메일과 같은
Gmail 연결(inout_db `inout_gmail_tokens`, gmail.send 만, 사람마다 한 번 연결). 연결이 없거나 끊겼거나 Gmail 이 실패하면
회사 알림 메일(SMTP, app/mail.py)로 보내고 보낸 사람 이름·답장 주소를 그 사람으로 한다.
@@ -22,13 +24,16 @@ from .store import HALF_LABELS
logger = logging.getLogger("app.vacation.notify")
EVENTS = ("submitted", "approved", "rejected")
EVENT_WORD = {"submitted": "제출", "approved": "승인", "rejected": "반려"}
EVENTS = ("submitted", "approved", "rejected", "consulted")
EVENT_WORD = {"submitted": "제출", "approved": "승인", "rejected": "반려", "consult_request": "협의 요청", "consulted": "협의 완료"}
EVENT_LEAD = {
"submitted": "휴가 신청이 제출되었습니다. 확인 후 승인해 주세요.",
"approved": "휴가가 승인되었습니다.",
"rejected": "휴가가 반려되었습니다.",
"consult_request": "휴가 협의 요청이 왔습니다. 내용을 확인하고 ERP 휴가 메뉴에서 협의 결재를 진행해 주세요.",
"consulted": "협의가 모두 끝났습니다. 확인 후 승인해 주세요.",
}
LEAD_WITH_CONSULTS = "휴가 신청이 제출되었습니다. 협의자가 모두 승인하면 결재할 수 있습니다."
_WEEKDAYS = "월화수목금토일"
@@ -55,7 +60,7 @@ def approver_emails(options: dict[str, Any], users: list[dict[str, Any]]) -> lis
def recipients(event: str, req: dict[str, Any], options: dict[str, Any], users: list[dict[str, Any]]) -> list[str]:
people = approver_emails(options, users) + _uniq(options.get("notifiers") or [])
if event in ("approved", "rejected"):
if event in ("approved", "rejected", "consulted"):
people.append(req.get("owner") or "")
return _uniq(people)
@@ -87,29 +92,39 @@ def _days(v: Any) -> str:
def build(event: str, req: dict[str, Any], *, actor_name: str, actor_email: str, link: str,
name_of: Any = None) -> dict[str, str]:
"""제목·글·HTML. 사용자 글(사유·반려 사유·이름)은 HTML 에서 늘 escape."""
name_of: Any = None, consult: dict[str, Any] | None = None) -> dict[str, str]:
"""제목·글·HTML. 사용자 글(사유·반려 사유·이름)은 HTML 에서 늘 escape.
협의 요청(consult_request)은 받는 협의자 한 명 몫(consult)만, 나머지 메일은 협의자 전체(req["consults"])와 협의 내용을 싣는다."""
name_of = name_of or (lambda e: e)
owner = req.get("owner_name") or name_of(req.get("owner") or "")
word = EVENT_WORD[event]
consults = req.get("consults") or []
subject = f"[휴가 {word}] {owner} · {req.get('vacation_type', '')} {period_text(req)} ({_days(req.get('days'))}일)"
rows = [("신청자", f"{owner} ({req.get('owner', '')})"), ("종류", req.get("vacation_type") or ""),
("기간", period_text(req)), ("일수", f"{_days(req.get('days'))}일"), ("사유", req.get("reason") or "-")]
if event == "submitted":
rows.append(("상태", "제출 — 승인 대기"))
if event == "consult_request":
rows += [("상태", "협의 대기"), ("협의 내용", (consult or {}).get("message") or "-")]
elif event == "consulted":
rows.append(("상태", "협의 완료 — 승인 대기"))
elif event == "submitted":
rows.append(("상태", "협의 진행 중" if consults else "제출 — 승인 대기"))
else:
rows.append(("상태", word))
rows.append((f"{word}자", f"{actor_name} ({actor_email})"))
if event == "rejected":
rows.append(("반려 사유", req.get("reject_reason") or "-"))
text = "\n".join([EVENT_LEAD[event], ""] + [f"{k}: {v}" for k, v in rows] + ["", f"휴가 신청 보기: {link}"])
if event != "consult_request":
rows += [(f"협의자 {c.get('name') or name_of(c.get('email') or '')}",
f"{c.get('state') or '대기'} — {c.get('message') or '협의 내용 없음'}") for c in consults]
lead = LEAD_WITH_CONSULTS if event == "submitted" and consults else EVENT_LEAD[event]
text = "\n".join([lead, ""] + [f"{k}: {v}" for k, v in rows] + ["", f"휴가 신청 보기: {link}"])
tr = "".join(
f'<tr><th style="text-align:left;padding:6px 12px 6px 0;color:#666;font-weight:600;white-space:nowrap;vertical-align:top">'
f'{escape(k)}</th><td style="padding:6px 0;white-space:pre-wrap">{escape(str(v))}</td></tr>' for k, v in rows)
color = {"submitted": "#1a56db", "approved": "#0f8a3a", "rejected": "#c22b10"}[event]
color = {"approved": "#0f8a3a", "rejected": "#c22b10"}.get(event, "#1a56db")
html = (
'<div style="font-family:Pretendard,\'Malgun Gothic\',sans-serif;font-size:14px;color:#111;line-height:1.5">'
f'<p style="margin:0 0 12px;font-size:16px;font-weight:700;color:{color}">{escape(EVENT_LEAD[event])}</p>'
f'<p style="margin:0 0 12px;font-size:16px;font-weight:700;color:{color}">{escape(lead)}</p>'
f'<table style="border-collapse:collapse;margin:0 0 16px">{tr}</table>'
f'<p style="margin:0"><a href="{escape(link, quote=True)}" style="display:inline-block;padding:8px 14px;border-radius:6px;'
f'background:{color};color:#fff;text-decoration:none;font-weight:600">휴가 신청 보기</a></p>'
@@ -156,9 +171,8 @@ def _send_gmail(inout_store: Any, *, email: str, name: str, to: list[str], mail:
def deliver(store: Any, inout_store: Any, *, event: str, req: dict[str, Any], actor: dict[str, Any],
users: list[dict[str, Any]], link: str) -> dict[str, Any]:
"""받는 사람을 정해 한 통 보내고 기록한다. 반환 {ok, via, to, error} (테스트·로그용)."""
from app import mail as smtp # noqa: WPS433
"""받는 사람을 정해 한 통 보내고 기록한다. 제출이면 협의자마다 자기 몫 협의 요청도 따로 한 통씩.
반환 {ok, via, to, error} (테스트·로그용, 협의 요청 제외)."""
if event not in EVENTS:
raise ValueError(event)
try:
@@ -169,13 +183,31 @@ def deliver(store: Any, inout_store: Any, *, event: str, req: dict[str, Any], ac
names = {_norm(u.get("email")): u.get("name") or "" for u in users}
email = _norm(actor.get("email"))
name = actor.get("name") or names.get(email) or email.split("@")[0]
def name_of(e: Any) -> str:
return names.get(_norm(e)) or str(e).split("@")[0]
if event == "submitted":
for c in req.get("consults") or []:
if c.get("state", "대기") != "대기": # 다시 보내기 — 이미 처리한 협의자에게는 안 보냄
continue
mail = build("consult_request", req, actor_name=name, actor_email=email, link=link, name_of=name_of, consult=c)
_send_and_log(store, inout_store, "consult_request", req, _uniq([c.get("email")]), mail, email, name)
result: dict[str, Any] = {"ok": False, "via": "", "to": to, "error": ""}
if not to:
result["error"] = "받는 사람 없음(승인자·통보자 미지정)"
logger.info("휴가 메일 받는 사람 없음 — %s %s", event, req.get("id"))
return result
mail = build(event, req, actor_name=name, actor_email=email, link=link,
name_of=lambda e: names.get(_norm(e)) or str(e).split("@")[0])
mail = build(event, req, actor_name=name, actor_email=email, link=link, name_of=name_of)
return _send_and_log(store, inout_store, event, req, to, mail, email, name)
def _send_and_log(store: Any, inout_store: Any, event: str, req: dict[str, Any], to: list[str], mail: dict[str, str],
email: str, name: str) -> dict[str, Any]:
"""한 통 보내기 — 본인 Gmail, 안 되면 회사 SMTP. 결과는 vacation_mail_log 에."""
from app import mail as smtp # noqa: WPS433
result: dict[str, Any] = {"ok": False, "via": "", "to": to, "error": ""}
ok, gmail_err = _send_gmail(inout_store, email=email, name=name, to=to, mail=mail)
if ok:
result.update(ok=True, via="gmail")
+233 -32
View File
@@ -3,6 +3,7 @@
- 경로: /vacation
- 권한: 로그인 + `vacation` 모듈 권한 (관리자는 항상 통과). 서버 측 검사.
승인/반려 = admin + (휴가 옵션에 승인자를 지정했으면 그 사람들, 아니면 `vacation_approver` 권한자) — 2026-10-27.
- 협의자(2026-11-02, 마이그레이션 003): 신청자가 지정(복수) → 모두 승인해야 결재자에게 넘어감(상태 협의중 → 제출). 협의자는 휴가 권한이 없어도 자기 신청은 볼 수 있다.
- 휴가 옵션(`/vacation/options`, 수정 = admin·승인자·통보자): 승인자·승인 통보자·잔여 연차. 공휴일 = 국경일 표(설정 화면 없음). 제출·승인·반려 메일은 `notify.py`
(처리한 사람 본인 Gmail — 입출고와 같은 Gmail 연결, 없으면 회사 SMTP).
- 데이터: VacationDBStore (vacation_db / PostgreSQL) 전용.
@@ -61,6 +62,16 @@ def _require_approver(request: Request) -> dict[str, Any]:
return user
def _require_login(request: Request) -> dict[str, Any]:
"""로그인만 — 협의 결재처럼 휴가 모듈 권한이 없어도 되는 곳(협의자 여부는 저장소가 확인)."""
from app.main import get_current_user_record # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
return user
def _options(request: Request) -> dict[str, Any]:
"""휴가 옵션(승인자·통보자, 마이그레이션 001). DB·001 이 없으면 빈 옵션."""
st = _store(request)
@@ -111,9 +122,42 @@ def _vacation_users() -> list[dict[str, Any]]:
return out
def _people() -> dict[str, dict[str, str]]:
"""전체 구성원(휴가 권한과 무관) {이메일: 이메일·이름·사진} — 협의자 후보·결재 라인 아이콘. 이름 순."""
from app.main import user_store # noqa: WPS433
rows = [{"email": u["email"].lower(), "name": u.get("name") or u["email"].split("@")[0], "picture": u.get("picture") or ""}
for u in user_store.list_all()]
rows.sort(key=lambda p: p["name"].lower())
return {p["email"]: p for p in rows}
def _form_consults(store: Any, owner: str, emails: list[str], messages: list[str], no_consult: str, action: str) -> list[dict[str, Any]] | None:
"""폼의 협의자 줄 → [{email, name, message}]. 003 전이면 None(협의자 없음). 제출인데 협의자도 "협의자 없음"도 없으면 400."""
if not store.consults_ready():
return None
if no_consult:
return []
if len(emails) != len(messages):
raise HTTPException(status_code=400, detail="협의자 칸이 맞지 않습니다.")
known = _people()
out: dict[str, dict[str, Any]] = {}
for raw, message in zip(emails, messages):
email = raw.strip().lower()
if email == owner.lower():
continue
if email not in known:
raise HTTPException(status_code=400, detail=f"등록된 구성원만 협의자로 고를 수 있습니다: {email}")
out[email] = {"email": email, "name": known[email]["name"], "message": message.strip()[:2000]}
if action == "submit" and not out:
raise HTTPException(status_code=400, detail="협의자를 고르거나 '협의자 없음'을 체크하세요.")
return list(out.values())
def _notify(bg: BackgroundTasks, request: Request, event: str, req: dict[str, Any] | None,
actor: dict[str, Any]) -> None:
"""제출·승인·반려 메일을 응답 뒤 백그라운드로(notify.deliver — 받는 사람·보내는 사람 규칙은 그쪽)."""
actor: dict[str, Any], now: bool = False) -> None:
"""제출·승인·반려 메일을 응답 뒤 백그라운드로(notify.deliver — 받는 사람·보내는 사람 규칙은 그쪽).
Gmail 연결이 없거나 now 면 바로 — 실패 기록이 다음 화면에 보여 [Gmail 연결]·[다시 보내기]를 띄울 수 있게."""
from app.main import env # noqa: WPS433
from . import notify # noqa: WPS433
@@ -121,10 +165,20 @@ def _notify(bg: BackgroundTasks, request: Request, event: str, req: dict[str, An
st = _store(request)
if st is None or not req:
return
try:
req = {**req, "consults": st.list_consults(request_id=req["id"])}
except Exception: # noqa: BLE001 — 협의자 조회 실패가 처리 결과를 뒤집지 않게(메일만 협의 내용 없이)
req = {**req, "consults": []}
base = (env("PUBLIC_BASE_URL") or str(request.base_url)).rstrip("/")
inout_store = getattr(request.app.state, "inout_store", None)
bg.add_task(notify.deliver, st, inout_store, event=event, req=req, actor=dict(actor),
users=_vacation_users(), link=f"{base}/vacation/{req['id']}")
args = {"event": event, "req": req, "actor": dict(actor), "users": _vacation_users(), "link": f"{base}/vacation/{req['id']}"}
if not now and _gmail_state(request, actor)["connected"]:
bg.add_task(notify.deliver, st, inout_store, **args)
return
try:
notify.deliver(st, inout_store, **args)
except Exception: # noqa: BLE001 — 메일이 실패해도 휴가 처리는 그대로
notify.logger.exception("휴가 메일 처리 실패 — %s %s", event, req.get("id"))
def _render_config_needed(request: Request, user: dict[str, Any]) -> HTMLResponse:
@@ -147,23 +201,26 @@ def _render_config_needed(request: Request, user: dict[str, Any]) -> HTMLRespons
def _guard(
request: Request,
request: Request, consult_of: str = "",
) -> tuple[Any, dict[str, Any]] | HTMLResponse | RedirectResponse:
"""로그인+권한+store 점검. 페이지 핸들러 진입부에서 사용."""
"""로그인+권한+store 점검. 페이지 핸들러 진입부에서 사용.
consult_of = 신청 id — 휴가 권한이 없어도 그 신청의 협의자면 통과(메일 링크로 들어와 협의 결재)."""
from app.main import get_current_user_record, render_template # noqa: WPS433
from app.store import has_module, is_admin, login_redirect # noqa: WPS433
user = get_current_user_record(request)
if user is None:
return login_redirect(request)
if not has_module(user, "vacation"):
store = _store(request)
allowed = has_module(user, "vacation") or (store is not None and consult_of and any(
c["email"] == user["email"].lower() for c in store.list_consults(request_id=consult_of)))
if not allowed:
return render_template(
request,
"denied.html",
{"reason": "휴가 관리 모듈 접근 권한이 없습니다.", "is_admin": is_admin(user)},
status_code=403,
)
store = _store(request)
if store is None:
return _render_config_needed(request, user)
return store, user
@@ -184,6 +241,7 @@ def _ym(request: Request) -> tuple[int, int]:
# 상태별 bar 스타일 클래스 (CSS 와 매핑)
_STATUS_CLASS = {
"작성중": "vac-bar-draft",
"협의중": "vac-bar-submit",
"제출": "vac-bar-submit",
"승인": "vac-bar-approve",
"반려": "vac-bar-reject",
@@ -323,6 +381,7 @@ def index(request: Request) -> HTMLResponse:
"is_admin": is_admin(user),
"is_approver": is_approver,
"pending_count": pending_count,
"consult_count": len(store.my_consults(email=user["email"])),
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 관리",
"page_subtitle": f"{year}년 {month}월 휴가 달력",
@@ -344,11 +403,29 @@ def index(request: Request) -> HTMLResponse:
# ════════════════════════════════════════════════════════════
# 휴가 신청 — 등록 / 수정 / 상세
# ════════════════════════════════════════════════════════════
def _form_context(request: Request, user: dict[str, Any]) -> dict[str, Any]:
def _approval_line(request: Request, people: dict[str, dict[str, str]]) -> dict[str, list[dict[str, str]]]:
"""옵션에 세팅된 결재자·통보자(아이콘 + 이름) — 신청 화면·상세의 결재 라인."""
from . import notify # noqa: WPS433
opts = _options(request)
def who(emails: list[str]) -> list[dict[str, str]]:
return [people.get(e) or {"email": e, "name": e.split("@")[0], "picture": ""} for e in emails]
return {"approvers": who(notify.approver_emails(opts, _vacation_users())), "notifiers": who(opts.get("notifiers") or [])}
def _form_context(request: Request, user: dict[str, Any], req: dict[str, Any] | None = None) -> dict[str, Any]:
from app.main import build_erp_nav # noqa: WPS433
from app.store import is_admin # noqa: WPS433
people = _people()
st = _store(request)
return {
"members": [p for e, p in people.items() if e != user["email"].lower()],
"consult_ready": bool(st is not None and st.consults_ready()),
"consult_chosen": {c["email"]: c["message"] for c in st.list_consults(request_id=req["id"])} if req and st is not None else {},
"line": _approval_line(request, people),
"user": user,
"is_admin": is_admin(user),
"is_approver": _is_approver(request, user),
@@ -422,6 +499,9 @@ def create(
end_half: str = Form("full"),
reason: str = Form(""),
action: str = Form("submit"), # "draft" | "submit"
consult_email: list[str] = Form(default=[]),
consult_message: list[str] = Form(default=[]),
no_consult: str = Form(""),
user: dict[str, Any] = Depends(_require_user),
) -> RedirectResponse:
store = _store(request)
@@ -431,12 +511,14 @@ def create(
payload = _payload_from_form(
vacation_type, start_date, end_date, start_half, end_half, reason
)
consults = _form_consults(store, user["email"], consult_email, consult_message, no_consult, action)
try:
req = store.create_request(
owner=user["email"],
owner_name=user.get("name") or user["email"],
payload=payload,
status=status,
consults=consults,
)
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc))
@@ -454,26 +536,57 @@ def pending_page(request: Request) -> HTMLResponse:
if not isinstance(guard, tuple):
return guard
store, user = guard
if not _is_approver(request, user):
return render_template(
request,
"denied.html",
{"reason": "휴가 승인자 권한이 없습니다.", "is_admin": is_admin(user)},
status_code=403,
)
pending = store.list_pending()
is_approver = _is_approver(request, user)
pending = store.list_pending() if is_approver else []
consults = store.my_consults(email=user["email"])
by_req = store.consults_for([r["id"] for r in pending])
for r in pending:
r["consults"] = by_req.get(r["id"], [])
return render_template(
request,
"vacation/pending.html",
{
"user": user,
"is_admin": is_admin(user),
"is_approver": True,
"is_approver": is_approver,
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 — 승인 대기",
"page_subtitle": f"제출 상태 {len(pending)}건",
"page_title": "휴가 — 결재 대기",
"page_subtitle": f"협의 {len(consults)}건" + (f" · 승인 {len(pending)}건" if is_approver else ""),
"items": pending,
"consult_items": consults,
"half_labels": HALF_LABELS,
"people": _people(),
},
)
@router.get("/mine", response_class=HTMLResponse)
def mine_page(request: Request) -> HTMLResponse:
"""내 휴가 신청 내역 — 협의·결재 진행 상황(2026-11-02)."""
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
guard = _guard(request)
if not isinstance(guard, tuple):
return guard
store, user = guard
items = store.list_for(user["email"])
by_req = store.consults_for([r["id"] for r in items])
for r in items:
r["consults"] = by_req.get(r["id"], [])
return render_template(
request,
"vacation/mine.html",
{
"user": user,
"is_admin": is_admin(user),
"is_approver": _is_approver(request, user),
"nav_items": build_erp_nav(user, active="vacation"),
"page_title": "휴가 — 내 신청 내역",
"page_subtitle": f"{len(items)}건",
"items": items,
"half_labels": HALF_LABELS,
"people": _people(),
},
)
@@ -729,22 +842,33 @@ def options_save(
@router.get("/gmail/connect")
async def gmail_connect(request: Request) -> Any:
"""내 Gmail 연결 — 입출고와 같은 연결(같은 OAuth 클라이언트·같은 구글 리디렉션 주소 /inout/gmail/callback).
콜백은 세션 표시(_gmail_origin=vacation)를 보고 휴가 권한으로 처리한 뒤 휴가 옵션으로 돌아온다."""
콜백은 세션 표시(_gmail_origin=vacation)를 보고 휴가 권한으로 처리한 뒤 휴가 옵션으로 돌아온다.
?next=/vacation/{신청 id} = 그 상세로 돌아옴 — 그 신청의 협의자면 휴가 권한이 없어도 연결(콜백에 _gmail_consultant 로 알림)."""
import re # noqa: WPS433
from urllib.parse import urlencode # noqa: WPS433
from app.main import ALLOWED_DOMAIN, public_url_for # noqa: WPS433
from app.modules.inout import gmail # noqa: WPS433
from app.store import has_module # noqa: WPS433
user = _require_user(request)
user = _require_login(request)
nxt = request.query_params.get("next", "")
back = nxt if re.fullmatch(r"/vacation/[0-9a-z]+", nxt) else "/vacation/options"
st = _store(request)
consultant = back != "/vacation/options" and st is not None and any(
c["email"] == user["email"].lower() for c in st.list_consults(request_id=back.rsplit("/", 1)[1]))
if not consultant and not has_module(user, "vacation"):
raise HTTPException(status_code=403, detail="휴가 관리 모듈 권한이 없습니다.")
if getattr(request.app.state, "inout_store", None) is None:
return RedirectResponse(url="/vacation/options?" + urlencode(
return RedirectResponse(url=back + "?" + urlencode(
{"msg": "Gmail 연결 저장소(입출고 DB)가 설정되지 않아 연결할 수 없습니다 — 회사 메일로 보냅니다."}), status_code=303)
try:
client = gmail.oauth_client()
except gmail.GmailError as exc:
return RedirectResponse(url="/vacation/options?" + urlencode({"msg": str(exc)}), status_code=303)
return RedirectResponse(url=back + "?" + urlencode({"msg": str(exc)}), status_code=303)
request.session["_gmail_origin"] = "vacation"
request.session["_gmail_next"] = "/vacation/options"
request.session["_gmail_next"] = back
request.session["_gmail_consultant"] = bool(consultant)
return await client.authorize_redirect(
request, public_url_for(request, "inout_gmail_callback"),
access_type="offline", prompt="consent", include_granted_scopes="true",
@@ -776,7 +900,7 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
from app.store import is_admin # noqa: WPS433
guard = _guard(request)
guard = _guard(request, consult_of=request_id)
if not isinstance(guard, tuple):
return guard
store, user = guard
@@ -787,14 +911,21 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
{"reason": "휴가 신청을 찾을 수 없습니다.", "is_admin": is_admin(user)},
status_code=404,
)
email = user["email"].lower()
is_owner = req["owner"] == user["email"]
is_approver = _is_approver(request, user)
if not (is_owner or is_approver):
consults = store.list_consults(request_id=request_id)
mine = next((c for c in consults if c["email"] == email), None)
see_all = is_owner or is_approver or email in (_options(request).get("notifiers") or [])
if not (see_all or mine):
return render_template(
request, "denied.html",
{"reason": "본인 또는 승인자만 조회할 수 있습니다.", "is_admin": is_admin(user)},
{"reason": "본인·승인자·통보자·협의자만 조회할 수 있습니다.", "is_admin": is_admin(user)},
status_code=403,
)
req["consults"] = consults if see_all else [mine] # 협의자는 자기 몫 협의 내용만
people = _people()
failed_mail = _failed_mail(store, req, email)
return render_template(
request,
"vacation/detail.html",
@@ -809,12 +940,31 @@ def detail(request: Request, request_id: str) -> HTMLResponse:
"req": req,
"half_labels": HALF_LABELS,
"can_edit": is_owner and req["status"] in ("작성중", "반려"),
"mail_log": _mail_log(store, request_id),
"event_words": {"submitted": "제출", "approved": "승인", "rejected": "반려"},
"can_consult": bool(mine and mine["state"] == "대기" and req["status"] == "협의중"),
"failed_mail": failed_mail,
"gmail": _gmail_state(request, user) if failed_mail else None,
"msg": request.query_params.get("msg", ""),
"people": people,
"line": _approval_line(request, people),
"mail_log": _mail_log(store, request_id) if see_all else [],
"event_words": {"submitted": "제출", "approved": "승인", "rejected": "반려", "consult_request": "협의 요청", "consulted": "협의 완료"},
},
)
# 다시 보낼 의미가 있는 신청 상태 — 일이 더 진행됐거나 수정 중이면 예전 메일은 다시 보내지 않는다
_RETRY_STATUS = {"submitted": ("협의중", "제출"), "consulted": ("제출",), "approved": ("승인",), "rejected": ("반려",)}
def _failed_mail(store: Any, req: dict[str, Any], email: str) -> dict[str, Any] | None:
"""내가 보내다 실패한 메일 — 그 신청의 마지막 메일(협의 요청은 제출과 함께 다루므로 뺌)이 실패이고 상태가 그대로일 때."""
logs = [m for m in _mail_log(store, req["id"]) if m["event"] != "consult_request"]
last = logs[-1] if logs else None
if last and not last["ok"] and last["sender"] == email and req["status"] in _RETRY_STATUS.get(last["event"], ()):
return last
return None
def _mail_log(store: Any, request_id: str) -> list[dict[str, Any]]:
"""그 신청의 휴가 메일 기록(001) — 실패해도 상세 화면은 그대로."""
try:
@@ -851,7 +1001,7 @@ def edit_form(request: Request, request_id: str) -> HTMLResponse:
{"reason": f"{req['status']} 상태에서는 수정할 수 없습니다.", "is_admin": is_admin(user)},
status_code=409,
)
ctx = _form_context(request, user)
ctx = _form_context(request, user, req)
ctx.update(
{
"page_title": "휴가 신청 수정",
@@ -876,6 +1026,9 @@ def update(
end_half: str = Form("full"),
reason: str = Form(""),
action: str = Form("save"), # "save" | "submit"
consult_email: list[str] = Form(default=[]),
consult_message: list[str] = Form(default=[]),
no_consult: str = Form(""),
user: dict[str, Any] = Depends(_require_user),
) -> RedirectResponse:
store = _store(request)
@@ -884,8 +1037,9 @@ def update(
payload = _payload_from_form(
vacation_type, start_date, end_date, start_half, end_half, reason
)
consults = _form_consults(store, user["email"], consult_email, consult_message, no_consult, action)
try:
store.update_request(request_id=request_id, owner=user["email"], payload=payload)
store.update_request(request_id=request_id, owner=user["email"], payload=payload, consults=consults)
if action == "submit":
_notify(bg, request, "submitted", store.submit(request_id=request_id, owner=user["email"]), user)
except KeyError:
@@ -914,6 +1068,53 @@ def submit(
return RedirectResponse(url=f"/vacation/{request_id}", status_code=303)
@router.post("/{request_id}/consult")
def consult_decide(
request: Request,
request_id: str,
bg: BackgroundTasks,
decision: str = Form(...), # "approve" | "reject"
reject_reason: str = Form(""),
user: dict[str, Any] = Depends(_require_login),
) -> RedirectResponse:
"""협의 결재 — 모두 승인하면 제출(결재자 승인 대기)로, 한 명이 반려하면 신청도 반려."""
store = _store(request)
if store is None:
raise HTTPException(status_code=503, detail="vacation_db 미설정")
try:
req, event = store.decide_consult(request_id=request_id, email=user["email"], approve=decision == "approve",
reason=reject_reason)
except KeyError:
raise HTTPException(status_code=404, detail="휴가 신청을 찾을 수 없습니다.")
except PermissionError as exc:
raise HTTPException(status_code=403, detail=str(exc))
except ValueError as exc:
raise HTTPException(status_code=409, detail=str(exc))
if event:
_notify(bg, request, event, req, user)
return RedirectResponse(url=f"/vacation/{request_id}", status_code=303)
@router.post("/{request_id}/mail-retry")
def mail_retry(
request: Request,
request_id: str,
bg: BackgroundTasks,
user: dict[str, Any] = Depends(_require_login),
) -> RedirectResponse:
"""내가 보내다 실패한 메일 다시 보내기(Gmail 을 연결한 뒤 등) — 결과가 바로 화면에 나오게 기다렸다 돌아간다."""
store = _store(request)
if store is None:
raise HTTPException(status_code=503, detail="vacation_db 미설정")
req = store.get_request(request_id=request_id)
if not req:
raise HTTPException(status_code=404, detail="휴가 신청을 찾을 수 없습니다.")
failed = _failed_mail(store, req, user["email"].lower())
if failed:
_notify(bg, request, failed["event"], req, user, now=True)
return RedirectResponse(url=f"/vacation/{request_id}", status_code=303)
@router.post("/{request_id}/approve")
def approve(
request: Request,
+2 -1
View File
@@ -24,7 +24,8 @@ VACATION_TYPES: tuple[str, ...] = (
)
# 신청 상태 워크플로
STATUSES: tuple[str, ...] = ("작성중", "제출", "승인", "반려", "취소")
# 협의중 = 협의자 승인 대기(2026-11-02, 마이그레이션 003) — 협의자가 모두 승인하면 제출(결재자 승인 대기)
STATUSES: tuple[str, ...] = ("작성중", "협의중", "제출", "승인", "반려", "취소")
# 시작/종료일 구분
HALVES: tuple[str, ...] = ("full", "am", "pm")
@@ -0,0 +1,36 @@
{#- 결재 라인 공용 조각(2026-11-02) — 아이콘 + 이름, 협의·결재 진행 상황 -#}
{% macro face(p) -%}
{% if p.picture %}<img class="vac-opt-face" src="{{ p.picture }}" alt="" referrerpolicy="no-referrer" />
{%- else %}<span class="vac-opt-face is-ini">{{ (p.name or p.email)[:1] }}</span>{% endif %}
{%- endmacro %}
{% macro person(p) -%}
<span class="vac-person">{{ face(p) }}<span class="vac-opt-name">{{ p.name or p.email }}</span></span>
{%- endmacro %}
{% macro status_badge(status) -%}
{% set badge = 'erp-badge-neutral' %}
{% if status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }}">{{ status }}</span>
{%- endmacro %}
{#- 협의자별 상태 → 결재 상태. r.consults 필요 -#}
{% macro progress(r, people) -%}
{% set rejected_in_consult = r.consults | selectattr('state', 'equalto', '반려') | list %}
<span class="vac-steps">
{% for c in r.consults %}
{% set p = people.get(c.email) or {'email': c.email, 'name': c.name, 'picture': ''} %}
<span class="vac-step is-{{ {'대기': 'wait', '승인': 'ok', '반려': 'no'}[c.state] }}" title="협의 {{ c.state }}">{{ face(p) }}{{ p.name or p.email }} <b>{{ c.state }}</b></span>
{% endfor %}
{% if r.consults %}<span class="vac-step-arrow" aria-hidden="true">→</span>{% endif %}
{% if r.status == '협의중' %}<span class="vac-step is-wait">결재 <b>협의 후</b></span>
{% elif r.status == '제출' %}<span class="vac-step is-wait">결재 <b>대기</b></span>
{% elif r.status == '승인' %}<span class="vac-step is-ok">결재 <b>승인</b></span>
{% elif r.status == '반려' and not rejected_in_consult %}<span class="vac-step is-no">결재 <b>반려</b></span>
{% elif r.status == '반려' %}<span class="vac-step">결재 <b>안 넘어감</b></span>
{% elif r.status == '작성중' %}<span class="vac-step">결재 <b>제출 전</b></span>
{% else %}<span class="vac-step">{{ r.status }}</span>{% endif %}
</span>
{%- endmacro %}
@@ -1,10 +1,28 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />{% endblock %}
{% block content %}
<section class="vac">
<div class="erp-card vac-detail-card">
{% if msg %}<p class="vac-opt-msg" role="status">{{ msg }}</p>{% endif %}
{#- 내가 보내다 실패한 메일(2026-11-02) — Gmail 을 연결하고 다시 보낸다 -#}
{% if failed_mail %}
<div class="vac-opt-msg is-warn vac-mail-retry" role="alert">
<b>{{ event_words.get(failed_mail.event, failed_mail.event) }} 메일을 보내지 못했습니다.</b>
{% if gmail.connected or gmail.smtp %}
<form method="post" action="/vacation/{{ req.id }}/mail-retry" class="vac-inline-form">
<button type="submit" class="erp-btn erp-btn-primary">메일 다시 보내기</button>
</form>
{% elif gmail.available %}
<span>내 Gmail 이 연결되어 있지 않습니다. 연결한 뒤 다시 보낼 수 있습니다.</span>
<a class="erp-btn erp-btn-primary" href="/vacation/gmail/connect?next=/vacation/{{ req.id }}">Gmail 연결</a>
{% else %}
<span>메일을 보낼 방법이 설정되어 있지 않습니다. 관리자에게 알려 주세요.</span>
{% endif %}
</div>
{% endif %}
<div class="vac-detail-head">
<div>
@@ -13,7 +31,7 @@
</div>
{% set badge = 'erp-badge-neutral' %}
{% if req.status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif req.status == '제출' %}{% set badge = 'erp-badge-inverse' %}
{% elif req.status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif req.status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }} vac-detail-status">{{ req.status }}</span>
</div>
@@ -24,7 +42,7 @@
<div><dt>시작일</dt><dd>{{ req.start_date }} ({{ half_labels[req.start_half] }})</dd></div>
<div><dt>종료일</dt><dd>{{ req.end_date }} ({{ half_labels[req.end_half] }})</dd></div>
{% if req.approver_email %}
<div><dt>승인자</dt><dd>{{ req.approver_email }}</dd></div>
<div><dt>{{ '반려자' if req.status == '반려' else '승인자' }}</dt><dd>{{ req.approver_email }}</dd></div>
<div><dt>결재일시</dt><dd>{{ req.decided_at }}</dd></div>
{% endif %}
</dl>
@@ -43,6 +61,42 @@
</div>
{% endif %}
{#- 결재 라인(2026-11-02) — 협의자별 상태·협의 내용(협의자에게는 자기 줄만, 서버가 거름), 통보자·결재자 -#}
<div class="vac-detail-block vac-line">
<div class="vac-detail-label">결재 진행</div>
<p class="vac-line-progress">{{ vm.progress(req, people) }}</p>
{% for c in req.consults %}
{% set p = people.get(c.email) or {'email': c.email, 'name': c.name, 'picture': ''} %}
<div class="vac-line-consult">
<div>{{ vm.person(p) }} <span class="erp-muted">협의 {{ c.state }}{% if c.decided_at %} · {{ c.decided_at[5:16] | replace('T', ' ') }}{% endif %}</span></div>
{% if c.message %}<p>{{ c.message }}</p>{% endif %}
{% if c.comment %}<p class="vac-line-comment">반려 사유: {{ c.comment }}</p>{% endif %}
</div>
{% endfor %}
<div class="vac-line-row">
<span class="vac-line-label">통보자</span>
<div class="vac-line-body">{% for p in line.notifiers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">없음</span>{% endfor %}</div>
</div>
<div class="vac-line-row">
<span class="vac-line-label">결재자</span>
<div class="vac-line-body">{% for p in line.approvers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">ERP 관리자</span>{% endfor %}</div>
</div>
</div>
{% if can_consult %}
<div class="vac-approve-box">
<form method="post" action="/vacation/{{ req.id }}/consult" class="vac-inline-form">
<input type="hidden" name="decision" value="approve" />
<button type="submit" class="erp-btn erp-btn-primary">협의 승인</button>
</form>
<form method="post" action="/vacation/{{ req.id }}/consult" class="vac-reject-form">
<input type="hidden" name="decision" value="reject" />
<input class="erp-input" type="text" name="reject_reason" placeholder="반려 사유" required />
<button type="submit" class="erp-btn erp-btn-danger">협의 반려</button>
</form>
</div>
{% endif %}
<!-- ── 승인자 액션 (제출 상태) ── -->
{% if is_approver and req.status == '제출' %}
<div class="vac-approve-box">
@@ -91,7 +145,7 @@
</form>
{% endif %}
{% if req.status in ('작성중', '제출', '반려') and (is_owner or is_admin) %}
{% if req.status in ('작성중', '협의중', '제출', '반려') and (is_owner or is_admin) %}
<form method="post" action="/vacation/{{ req.id }}/delete" class="vac-inline-form"
onsubmit="return confirm('이 휴가 신청을 삭제할까요? (복구 불가)');">
<button type="submit" class="erp-btn erp-btn-danger">삭제</button>
+105 -43
View File
@@ -1,9 +1,10 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
{#- 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop) -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />
{#- 달력 = ERP 공용 달력 서식(2026-11-02, erp-datepop mountRange) -#}
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %}
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac">
@@ -11,51 +12,112 @@
{% set action = '/vacation/new' if mode == 'new' else '/vacation/' ~ req.id ~ '/edit' %}
<form id="vac-form" method="post" action="{{ action }}" class="erp-card vac-form-card">
<div class="vac-form-grid">
<label class="erp-field"><span>휴가 종류 *</span>
<select class="erp-select" name="vacation_type" id="vac-type" required>
{% for t in vacation_types %}
<option value="{{ t }}" {% if req and req.vacation_type == t %}selected{% endif %}>{{ t }}</option>
{% endfor %}
</select>
</label>
<fieldset class="vac-types">
<legend>휴가 종류</legend>
{% for t in vacation_types %}
<label class="vac-type"><input type="radio" name="vacation_type" value="{{ t }}"
{% if (req and req.vacation_type == t) or (not req and loop.first) %}checked{% endif %} /><span>{{ t }}</span></label>
{% endfor %}
</fieldset>
<label class="erp-field"><span>시작일 *</span>
<input class="erp-input" type="date" name="start_date" id="vac-start" required
value="{{ req.start_date if req else default_date }}" />
</label>
<div class="vac-form-main">
<div class="vac-range-cal" id="vac-cal"></div>
<label class="erp-field" id="vac-start-half-field"><span>시작 구분</span>
<select class="erp-select" name="start_half" id="vac-start-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.start_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<div class="vac-form-side">
<input type="hidden" name="start_date" id="vac-start" value="{{ req.start_date if req else '' }}" />
<input type="hidden" name="end_date" id="vac-end" value="{{ req.end_date if req else '' }}" />
<div class="vac-form-grid">
<label class="erp-field"><span>시작일</span>
<input class="erp-input" type="text" id="vac-start-show" readonly placeholder="달력에서 선택" />
</label>
<label class="erp-field" id="vac-end-field"><span>종료일</span>
<input class="erp-input" type="text" id="vac-end-show" readonly placeholder="달력에서 선택" />
</label>
<label class="erp-field" id="vac-start-half-field"><span>시작 구분</span>
<select class="erp-select" name="start_half" id="vac-start-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.start_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<label class="erp-field" id="vac-end-half-field"><span>종료 구분</span>
<select class="erp-select" name="end_half" id="vac-end-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.end_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
</div>
<label class="erp-field" id="vac-end-field"><span>종료일 *</span>
<input class="erp-input" type="date" name="end_date" id="vac-end"
value="{{ req.end_date if req else default_date }}" />
</label>
<div class="vac-days-preview">
예상 사용 일수: <strong id="vac-days-out">—</strong>
<span class="erp-muted">(주말 · 공휴일 제외)</span>
</div>
<label class="erp-field" id="vac-end-half-field"><span>종료 구분</span>
<select class="erp-select" name="end_half" id="vac-end-half">
{% for h in halves %}
<option value="{{ h }}" {% if req and req.end_half == h %}selected{% endif %}>{{ half_labels[h] }}</option>
{% endfor %}
</select>
</label>
<label class="erp-field vac-reason"><span>휴가 사유</span>
<textarea class="erp-input" name="reason" rows="5"
placeholder="휴가 사유를 입력하세요.">{{ req.reason if req else '' }}</textarea>
</label>
</div>
</div>
<label class="erp-field vac-full"><span>사유</span>
<textarea class="erp-input" name="reason" rows="3"
placeholder="휴가 사유를 입력하세요.">{{ req.reason if req else '' }}</textarea>
</label>
{#- 결재 라인 — 협의자(구성원 전체에서 복수, 사람마다 협의 내용) · 통보자·결재자(옵션 값, 고칠 수 없음) -#}
<section class="vac-line" aria-label="결재 라인">
<h3>결재 라인</h3>
<div class="vac-days-preview">
예상 사용 일수: <strong id="vac-days-out">—</strong>
<span class="erp-muted">(주말 · 공휴일 제외)</span>
</div>
<div class="vac-line-row">
<span class="vac-line-label">협의자</span>
<div class="vac-line-body">
<button type="button" class="erp-btn erp-btn-outline" id="vac-pick-btn" aria-expanded="false"
{% if not consult_ready %}disabled{% endif %}>구성원 선택</button>
<label class="vac-check"><input type="checkbox" name="no_consult" id="vac-no-consult" value="1"
{% if not consult_ready %}checked disabled{% endif %} /> 협의자 없음</label>
{% if not consult_ready %}<span class="erp-muted">협의자 기능은 DB 마이그레이션 003 적용 뒤에 쓸 수 있습니다.</span>{% endif %}
</div>
</div>
<ul class="vac-pick" id="vac-pick" hidden>
{% for m in members %}
<li>
<label class="vac-opt-person">
<input type="checkbox" data-email="{{ m.email }}" {% if m.email in consult_chosen %}checked{% endif %} />
{{ vm.person(m) }}
</label>
</li>
{% else %}
<li class="erp-muted">고를 수 있는 구성원이 없습니다.</li>
{% endfor %}
</ul>
<div class="vac-consult-box" id="vac-consult-box" hidden>
<p class="vac-line-sub">협의자 전달 사항 <span class="erp-muted">— 협의자마다 자기 내용만 메일로 받습니다.</span></p>
{% for m in members %}
{% set on = m.email in consult_chosen %}
<div class="vac-consult-row" data-email="{{ m.email }}" {% if not on %}hidden{% endif %}>
<input type="hidden" name="consult_email" value="{{ m.email }}" {% if not on %}disabled{% endif %} />
{{ vm.person(m) }}
<textarea class="erp-input" name="consult_message" rows="2" placeholder="{{ m.name }}님에게 전달할 내용"
aria-label="{{ m.name }} 협의 내용" {% if not on %}disabled{% endif %}>{{ consult_chosen.get(m.email, '') }}</textarea>
<button type="button" class="vac-consult-x" aria-label="{{ m.name }} 빼기">✕</button>
</div>
{% endfor %}
</div>
<div class="vac-line-row">
<span class="vac-line-label">통보자</span>
<div class="vac-line-body">
{% for p in line.notifiers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">없음(옵션에서 지정)</span>{% endfor %}
</div>
</div>
<div class="vac-line-row">
<span class="vac-line-label">결재자</span>
<div class="vac-line-body">
{% for p in line.approvers %}{{ vm.person(p) }}{% else %}<span class="erp-muted">ERP 관리자(옵션에서 지정)</span>{% endfor %}
</div>
</div>
</section>
<p class="vac-form-err" id="vac-form-err" role="alert" hidden></p>
<div class="erp-page-actions vac-form-actions">
<button type="submit" class="erp-btn erp-btn-primary" name="action" value="submit">제출</button>
@@ -72,5 +134,5 @@
{% endblock %}
{% block scripts %}<script type="application/json" id="vac-holidays">{{ holidays | tojson }}</script>
<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
<script src="/static/erp-datepop.js?v=20261102a" defer></script>
<script src="/static/vacation.js?v=20261102a" defer></script>{% endblock %}
@@ -1,6 +1,6 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />{% endblock %}
{% block content %}
<section class="vac">
@@ -9,6 +9,12 @@
<div class="vac-actions">
<div class="vac-actions-main">
<a class="erp-btn erp-btn-primary" href="/vacation/new">+ 휴가 신청</a>
<a class="erp-btn erp-btn-outline" href="/vacation/mine">내 신청 내역</a>
{% if consult_count %}
<a class="erp-btn erp-btn-outline" href="/vacation/pending#consults">협의 대기
<span class="erp-badge erp-badge-inverse vac-mini">{{ consult_count }}</span>
</a>
{% endif %}
{% if is_approver %}
<a class="erp-btn erp-btn-outline" href="/vacation/pending">승인 대기
{% if pending_count %}<span class="erp-badge erp-badge-inverse vac-mini">{{ pending_count }}</span>{% endif %}
@@ -85,7 +91,7 @@
</div>
<div class="vac-legend">
<span class="vac-leg"><i class="vac-dot vac-bar-submit"></i>제출</span>
<span class="vac-leg"><i class="vac-dot vac-bar-submit"></i>협의·제출</span>
<span class="vac-leg"><i class="vac-dot vac-bar-approve"></i>승인</span>
<span class="vac-leg"><i class="vac-dot vac-bar-reject"></i>반려</span>
<span class="vac-leg"><i class="vac-dot vac-bar-cancel"></i>취소</span>
@@ -108,7 +114,7 @@
<strong>{{ r.owner_name or r.owner }}</strong>
{% set badge = 'erp-badge-neutral' %}
{% if r.status == '승인' %}{% set badge = 'erp-badge-success' %}
{% elif r.status == '제출' %}{% set badge = 'erp-badge-inverse' %}
{% elif r.status in ('제출', '협의중') %}{% set badge = 'erp-badge-inverse' %}
{% elif r.status == '반려' %}{% set badge = 'erp-badge-danger' %}{% endif %}
<span class="erp-badge {{ badge }}">{{ r.status }}</span>
</div>
@@ -0,0 +1,37 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />{% endblock %}
{% block content %}
<section class="vac vac-options">
<div class="vac-actions">
<div class="vac-actions-main">
<a class="erp-btn erp-btn-outline" href="/vacation/">◀ 달력</a>
<a class="erp-btn erp-btn-primary" href="/vacation/new">+ 휴가 신청</a>
</div>
</div>
<div class="erp-card">
{% if items %}
<div class="erp-table-wrap">
<table class="erp-table">
<thead><tr><th>휴가종류</th><th>기간</th><th>일수</th><th>상태</th><th>결재 진행</th></tr></thead>
<tbody>
{% for r in items %}
<tr>
<td><a href="/vacation/{{ r.id }}">{{ r.vacation_type }}</a></td>
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td>{{ vm.status_badge(r.status) }}</td>
<td>{{ vm.progress(r, people) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-muted">휴가 신청 내역이 없습니다.</p>
{% endif %}
</div>
</section>
{% endblock %}
@@ -1,10 +1,10 @@
{% extends "erp_base.html" %}
{#- 휴가 옵션(2026-10-27) — 승인자·승인 통보자·잔여 연차(수정 = ERP 관리자·승인자·통보자, 나머지는 보기만) + 내 Gmail 연결(누구나).
메일: 제출 = 승인자·통보자, 승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />
메일: 제출 = 승인자·통보자(+ 협의자마다 자기 몫), 협의 완료·승인·반려 = 승인자·통보자·신청자. 보내는 사람 = 처리한 사람 본인 Gmail(없으면 회사 메일). -#}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />
<link rel="stylesheet" href="/static/vendor/material-symbols/material-symbols.css" />
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261027a" />{% endblock %}
<link rel="stylesheet" href="/static/erp-datepop.css?v=20261102a" />{% endblock %}
{% block content %}
<section class="vac vac-options">
@@ -149,5 +149,5 @@
</section>
{% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261027b" defer></script>
<script src="/static/vacation.js?v=20261027c" defer></script>{% endblock %}
{% block scripts %}<script src="/static/erp-datepop.js?v=20261102a" defer></script>
<script src="/static/vacation.js?v=20261102a" defer></script>{% endblock %}
@@ -1,17 +1,60 @@
{% extends "erp_base.html" %}
{% import "vacation/_macros.html" as vm %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261027e" />{% endblock %}
{% block head_extra %}<link rel="stylesheet" href="/static/vacation.css?v=20261102c" />{% endblock %}
{% block content %}
<section class="vac">
<div class="erp-card">
<section class="vac vac-options">
{#- 협의 대기(2026-11-02) — 내가 협의자인 신청. 내 몫 협의 내용만 -#}
<div class="erp-card" id="consults">
<div class="vac-card-head"><h2>협의 대기 <span class="erp-muted vac-opt-count">{{ consult_items | length }}건</span></h2></div>
{% if consult_items %}
<div class="erp-table-wrap">
<table class="erp-table vac-pending-table">
<thead>
<tr><th>신청자</th><th>휴가종류</th><th>기간</th><th>일수</th><th>협의 내용</th><th class="vac-act-col">동작</th></tr>
</thead>
<tbody>
{% for r in consult_items %}
<tr>
<td><a href="/vacation/{{ r.id }}">{{ r.owner_name or r.owner }}</a></td>
<td>{{ r.vacation_type }}</td>
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td class="vac-reason-cell">{{ r.my_message or '-' }}</td>
<td class="vac-act-col">
<div class="vac-pending-acts">
<form method="post" action="/vacation/{{ r.id }}/consult" class="vac-inline-form">
<input type="hidden" name="decision" value="approve" />
<button type="submit" class="erp-btn erp-btn-primary erp-btn-sm">승인</button>
</form>
<form method="post" action="/vacation/{{ r.id }}/consult" class="vac-reject-form">
<input type="hidden" name="decision" value="reject" />
<input class="erp-input erp-input-sm" type="text" name="reject_reason" placeholder="반려 사유" required />
<button type="submit" class="erp-btn erp-btn-danger erp-btn-sm">반려</button>
</form>
</div>
</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-muted">협의할 휴가 신청이 없습니다.</p>
{% endif %}
</div>
{% if is_approver %}
<div class="erp-card" id="approvals">
<div class="vac-card-head"><h2>승인 대기 <span class="erp-muted vac-opt-count">{{ items | length }}건</span></h2></div>
{% if items %}
<div class="erp-table-wrap">
<table class="erp-table vac-pending-table">
<thead>
<tr>
<th>신청자</th><th>휴가종류</th><th>기간</th><th>일수</th>
<th>사유</th><th class="vac-act-col">동작</th>
<th>사유</th><th>협의</th><th class="vac-act-col">동작</th>
</tr>
</thead>
<tbody>
@@ -22,6 +65,11 @@
<td>{{ r.start_date }}{% if r.end_date != r.start_date %} ~ {{ r.end_date }}{% endif %}</td>
<td>{{ r.days }}</td>
<td class="vac-reason-cell erp-muted">{{ r.reason }}</td>
<td class="vac-reason-cell">
{% for c in r.consults %}
<div class="vac-consult-brief"><b>{{ (people.get(c.email) or c).name or c.email }}</b> {{ c.state }}{% if c.message %} — {{ c.message }}{% endif %}</div>
{% else %}<span class="erp-muted">없음</span>{% endfor %}
</td>
<td class="vac-act-col">
<div class="vac-pending-acts">
<form method="post" action="/vacation/{{ r.id }}/approve" class="vac-inline-form">
@@ -43,5 +91,6 @@
<p class="erp-muted">승인 대기 중인 휴가 신청이 없습니다.</p>
{% endif %}
</div>
{% endif %}
</section>
{% endblock %}
+37 -1
View File
@@ -278,7 +278,6 @@
.cf24-shortcuts {
font-size: var(--text-caption, 12px);
color: #79a6dd;
white-space: nowrap;
}
/* 편집 폼과 코드 칸은 **줄어들지 않는다.** 아래 「예약 적용」·「버전 이력」을 펼치면
@@ -467,6 +466,43 @@
.cf24-t-com { color: #6e7781; font-style: italic; } /* 주석 */
.cf24-t-doc { color: #6639ba; } /* DOCTYPE 등 선언 */
/* 색칠 층 안에서 <img> 태그만 마우스 판정을 받는다(미리보기용). 평소에는 위의 textarea 가 가린다. */
.cf24-t-img { pointer-events: auto; }
.cf24-t-img-on { background: #ffa500; }
/* 마우스를 통과시킨다 — 미리보기가 소스를 덮어도 hover 가 끊기지 않게. */
.cf24-img-preview {
position: fixed;
top: 0;
right: 0;
z-index: 1100;
box-sizing: border-box;
width: 500px;
border-left: 1px solid var(--color-subtle-ash, #e5e5e5);
background: var(--color-canvas-white, #fff);
pointer-events: none;
}
/* 한 줄 고정 높이 — 아래 이미지 높이가 이 값을 뺀 만큼이다. */
.cf24-img-preview-name {
box-sizing: border-box;
height: 40px;
padding: 0 12px;
font-size: 16px;
font-weight: 700;
line-height: 40px;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}
.cf24-img-preview img {
display: block;
width: 100%;
height: calc(100vh - 40px);
object-fit: contain;
}
.cf24-code-hint {
font-size: var(--text-caption, 12px);
color: var(--color-midtone-gray, #737373);
+10
View File
@@ -102,6 +102,16 @@
.pj-dp-day { isolation: isolate; }
.pj-dp-day::before { z-index: -1; }
/* 붙박이 기간 달력(mountRange) — 시작~종료 둥근 막대, 양 끝은 선택 원. 줄이 바뀌는 곳도 둥글게 */
.pj-dp-day.is-band::after {
content: ""; position: absolute; top: 2px; height: 30px; left: 0; right: 0; z-index: -2; background: #dbe6fb;
}
.pj-dp-day.is-band-start::after { left: 50%; }
.pj-dp-day.is-band-end::after { right: 50%; }
.pj-dp-day.is-row-first::after { left: 4px; border-radius: 15px 0 0 15px; }
.pj-dp-day.is-row-last::after { right: 4px; border-radius: 0 15px 15px 0; }
.pj-dp-day.is-band-start.is-row-last::after, .pj-dp-day.is-band-end.is-row-first::after { display: none; }
.pj-dp-foot {
display: flex; justify-content: space-between; align-items: center;
margin-top: 8px; padding-top: 8px; border-top: 1px solid #eef0f2;
+88 -28
View File
@@ -4,7 +4,7 @@
· 브라우저 기본 달력(input[type=date])은 숨기고 그 옆에 날짜 버튼을 둔다 — input 은 값 저장소(.value 읽기/쓰기·change 이벤트 그대로).
· 팝업: 위 칸(시작일·종료일 — 직접 입력 2026-10-27 / 10.27 / 10월 27일 / 1027, Enter), 월 달력(일·공휴일 빨강, 토 파랑,
공휴일 이름은 숫자 밑, 오늘 테두리, 기간 옅은 파랑), 오늘 · 지우기. 바깥 클릭·Esc 로 닫힘, 앵커 아래(자리 없으면 위).
window.ErpDatePop = { open(anchor, opts), close(), enhance(input, opts), enhanceRange(startInput, endInput, opts), fmt(iso), fmtFull(iso) } */
window.ErpDatePop = { open(anchor, opts), close(), enhance(input, opts), enhanceRange(startInput, endInput, opts), mountRange(box, opts), fmt(iso), fmtFull(iso) } */
(function () {
"use strict";
@@ -62,6 +62,34 @@
}
const HOLIDAY_SHORT = { "부처님오신날": "석가탄신일", "추석·개천절": "추석" };
// 요일 줄 + 6주 날짜 칸(팝업·붙박이 달력 공용). extra(iso) = 그 칸에 더할 클래스 목록
function gridHtml(viewY, viewM, holidays, today, extra) {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
cls.push.apply(cls, extra(iso, d));
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '<button type="button" class="' + cls.join(" ") + '" data-iso="' + iso + '"' +
(holName ? ' title="' + esc(holName) + '"' : "") + ">" +
'<span class="pj-dp-num">' + d.getDate() + "</span>" +
(holName ? '<span class="pj-dp-hol">' + esc(holShort) + "</span>" : "") + "</button>";
}
return '<div class="pj-dp-grid">' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '<span class="pj-dp-wd' + (i === 0 ? " is-sun" : i === 6 ? " is-sat" : "") + '">' + w + "</span>";
}).join("") + days + "</div>";
}
let popEl = null, cleanup = null;
function close() {
if (cleanup) cleanup();
@@ -100,27 +128,6 @@
'" data-kind="' + kind + '" placeholder="' + esc(labels[kind]) + '" value="' + esc(fmtField(val)) + '" autocomplete="off" />';
}
function render() {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
if (iso === due || (showStart && iso === start)) cls.push("is-selected");
if (showStart && start && due && iso > start && iso < due) cls.push("is-inrange");
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '<button type="button" class="' + cls.join(" ") + '" data-iso="' + iso + '"' +
(holName ? ' title="' + esc(holName) + '"' : "") + ">" +
'<span class="pj-dp-num">' + d.getDate() + "</span>" +
(holName ? '<span class="pj-dp-hol">' + esc(holShort) + "</span>" : "") + "</button>";
}
pop.innerHTML =
'<div class="pj-dp-fields">' +
(opts.allowStart ? (showStart ? field("start", start) : '<button type="button" class="pj-dp-addstart">+ ' + esc(labels.start) + "</button>") : "") +
@@ -133,11 +140,12 @@
'<button type="button" class="pj-dp-navbtn" data-nav="1" title="다음 달"><span class="material-symbols-outlined">chevron_right</span></button>' +
(opts.yearNav ? '<button type="button" class="pj-dp-navbtn" data-nav="12" title="1년 뒤"><span class="material-symbols-outlined">keyboard_double_arrow_right</span></button>' : "") +
"</div>" +
'<div class="pj-dp-grid">' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '<span class="pj-dp-wd' + (i === 0 ? " is-sun" : i === 6 ? " is-sat" : "") + '">' + w + "</span>";
}).join("") + days +
"</div>" +
gridHtml(viewY, viewM, holidays, today, function (iso) {
const c = [];
if (iso === due || (showStart && iso === start)) c.push("is-selected");
if (showStart && start && due && iso > start && iso < due) c.push("is-inrange");
return c;
}) +
'<div class="pj-dp-foot">' +
'<button type="button" class="pj-dp-link pj-dp-today">오늘</button>' +
(opts.clear === false ? "" : '<button type="button" class="pj-dp-link pj-dp-clear">지우기</button>') +
@@ -345,5 +353,57 @@
return { sync: sync, buttons: btns };
}
window.ErpDatePop = { open: open, close: close, enhance: enhance, enhanceRange: enhanceRange, fmt: fmt, fmtFull: fmtFull, parse: parseTyped };
// 화면에 붙박이는 기간 달력(2026-11-02, 휴가 신청) — 팝업과 같은 달력 서식(.pj-dp-*).
// 첫 클릭 = 시작일(동그라미), 다음 클릭 = 종료일(둥근 막대), 그다음 클릭 = 새로 시작. 시작일보다 앞을 누르면 그 날이 새 시작일.
// opts: { start, end, holidays, single() — true 면 클릭마다 하루, onChange(start, end) }. 반환 { set(start, end) }
function mountRange(box, opts) {
const holidays = opts.holidays || {};
const today = isoToday();
let start = opts.start || "", end = opts.end || opts.start || "", picking = false;
const base = new Date((start || today) + "T00:00:00");
let viewY = base.getFullYear(), viewM = base.getMonth();
function bandClasses(iso, d) {
if (!start || iso < start || iso > end) return [];
if (start === end) return ["is-selected"];
const c = ["is-band"];
if (iso === start) c.push("is-selected", "is-band-start");
else if (iso === end) c.push("is-selected", "is-band-end");
if (d.getDay() === 0) c.push("is-row-first");
if (d.getDay() === 6) c.push("is-row-last");
return c;
}
function render() {
box.innerHTML =
'<div class="pj-dp-nav">' +
'<button type="button" class="pj-dp-navbtn" data-nav="-1" title="이전 달"><span class="material-symbols-outlined">chevron_left</span></button>' +
'<span class="pj-dp-title">' + viewY + "년 " + (viewM + 1) + "월</span>" +
'<button type="button" class="pj-dp-navbtn" data-nav="1" title="다음 달"><span class="material-symbols-outlined">chevron_right</span></button>' +
"</div>" + gridHtml(viewY, viewM, holidays, today, bandClasses);
}
box.addEventListener("click", function (e) {
const nav = e.target.closest(".pj-dp-navbtn");
if (nav) {
const d = new Date(viewY, viewM + +nav.dataset.nav, 1);
viewY = d.getFullYear(); viewM = d.getMonth();
render();
return;
}
const day = e.target.closest(".pj-dp-day");
if (!day) return;
const iso = day.dataset.iso;
if (!picking || iso < start || (opts.single && opts.single())) {
start = end = iso;
picking = !(opts.single && opts.single());
} else {
end = iso;
picking = false;
}
render();
if (opts.onChange) opts.onChange(start, end);
});
render();
return { set: function (s, e) { start = s; end = e; picking = false; render(); } };
}
window.ErpDatePop = { open: open, close: close, enhance: enhance, enhanceRange: enhanceRange, mountRange: mountRange, fmt: fmt, fmtFull: fmtFull, parse: parseTyped };
})();
+4
View File
@@ -256,6 +256,8 @@
.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-rot { display: inline-flex; align-items: center; padding: 5px 9px; }
.io-viewer-rot:disabled { opacity: .5; cursor: wait; }
.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;
@@ -273,6 +275,7 @@
.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-part-title { padding: 10px 12px 6px; font-size: 13.2px; font-weight: 700; }
.io-prod-table col.w-code { width: 128px; }
.io-prod-table col.w-num { width: 120px; }
.io-prod-table col.w-ag { width: 92px; }
@@ -460,6 +463,7 @@
.io-box-pick { border: 1px solid #cfe0fb; background: #f0f6ff; color: #1d4f91; border-radius: 6px; padding: 0 6px; height: 20px; font-size: 11.5px; cursor: pointer; }
.io-box-pick:hover { background: #dce9ff; }
.io-pallet { margin-top: 8px; display: flex; flex-wrap: wrap; align-items: baseline; gap: 6px 14px; font-size: 13px; }
.io-pallet[hidden] { display: none; }
.io-pallet b { font-variant-numeric: tabular-nums; }
.io-pallet-main { font-size: 14px; font-weight: 600; }
.io-pallet-main b { font-size: 16px; color: #1d4f91; }
+79 -21
View File
@@ -56,6 +56,7 @@
// 힌트 = 통·뚜껑 입수의 최소공배수(둘 다 박스가 꽉 차는 수량 단위)와 지금 수량에 가까운 그 배수(누르면 수량 칸에 넣음).
const palletBoxes = parseInt(form.dataset.palletBoxes || "0", 10);
const pallet = document.getElementById("io-pallet");
const bagPallet = document.getElementById("io-pallet-bag");
const gcd = function (a, b) { while (b) { const t = a % b; a = b; b = t; } return a; };
const lcm = function (a, b) { return a / gcd(a, b) * b; };
function boxCell(tr, n, has) {
@@ -64,13 +65,14 @@
const out = { body: 0, lid: 0, unset: has && !body };
if (!cell) return out;
if (!has) { cell.innerHTML = "-"; return out; }
if (!body) { cell.innerHTML = '<span class="erp-muted" title="옵션 → 상품 정보에서 통 수량(박스)을 넣으면 계산합니다">박스 입수 미설정</span>'; return out; }
const bag = tr.dataset.bag === "1"; // 봉투·백 — 통·뚜껑 구분 없음
if (!body) { cell.innerHTML = '<span class="erp-muted" title="옵션 → 상품 정보에서 ' + (bag ? "박스당 수량" : "통 수량(박스)") + '을 넣으면 계산합니다">박스 입수 미설정</span>'; return out; }
out.body = n ? Math.ceil(n / body) : 0;
out.lid = n && lid ? Math.ceil(n / lid) : 0;
const unit = lid ? lcm(body, lid) : body; // 통·뚜껑이 모두 꽉 차는 수량 단위
let html = '<div class="io-box-main">통 <b>' + fmt(out.body) + "</b>박스" +
(lid ? ' · 뚜껑 <b>' + fmt(out.lid) + "</b>박스" : ' · <span class="erp-muted">뚜껑 없음</span>') + "</div>";
const per = "통 " + fmt(body) + "개/박스" + (lid ? " · 뚜껑 " + fmt(lid) + "개/박스" : "");
let html = '<div class="io-box-main">' + (bag ? "" : "통 ") + "<b>" + fmt(out.body) + "</b>박스" +
(bag ? "" : lid ? ' · 뚜껑 <b>' + fmt(out.lid) + "</b>박스" : ' · <span class="erp-muted">뚜껑 없음</span>') + "</div>";
const per = (bag ? "" : "통 ") + fmt(body) + "개/박스" + (lid ? " · 뚜껑 " + fmt(lid) + "개/박스" : "");
let hint;
if (n && n % unit === 0) {
hint = '<span class="io-box-ok">✓ ' + (lid ? "통·뚜껑 박스가 모두 꽉 찹니다" : "박스가 꽉 찹니다") + "</span>";
@@ -105,22 +107,25 @@
'<rect class="io-pal-base" x="1" y="' + (H + 3) + '" width="5" height="3"/><rect class="io-pal-base" x="' + (W / 2 - 2.5) + '" y="' + (H + 3) + '" width="5" height="3"/>' +
'<rect class="io-pal-base" x="' + (W - 6) + '" y="' + (H + 3) + '" width="5" height="3"/></svg>';
}
function palletVis(all) {
// cap = 1파렛트 박스 수. mixed = 1파렛트 박스 수가 다른 봉투·백이 섞임 — all 은 cap 기준 환산값이라 잔량은 %만 보여 준다.
function palletVis(all, cap, mixed) {
if (!all) return "";
const full = Math.floor(all / palletBoxes), rem = all % palletBoxes, MAX = 10;
const full = Math.floor(all / cap), rem = all % cap, MAX = 10;
const cells = Math.min(cap, 60); // cap 은 입력값 — 아주 커도 그림 칸 수는 60칸까지(비율로 칠함)
let html = "";
if (full) {
let icons = "";
for (let i = 0; i < Math.min(full, MAX); i++) icons += palletSvg(palletBoxes, palletBoxes);
for (let i = 0; i < Math.min(full, MAX); i++) icons += palletSvg(cells, cells);
html += '<span class="io-pal-group" title="꽉 찬 파렛트 ' + full + '개">' + icons +
(full > MAX ? '<span class="io-pal-more">+' + (full - MAX) + "</span>" : "") +
'<span class="io-pal-cap">꽉 찬 파렛트 <b>' + fmt(full) + "</b></span></span>";
}
if (rem) {
const pct = Math.round(rem / palletBoxes * 100);
html += '<span class="io-pal-group is-rem" title="잔량 파렛트 ' + rem + "/" + palletBoxes + '박스">' + palletSvg(rem, palletBoxes) +
'<span class="io-pal-cap">잔량 <b>' + rem + "</b>박스 · <b>" + pct + "%</b><br>" +
'<span class="io-pal-need">' + (palletBoxes - rem) + "박스 더 실으면 한 파렛트</span></span></span>";
const pct = Math.round(rem / cap * 100);
const drawn = Math.min(cells - 1, Math.max(1, Math.round(rem / cap * cells)));
html += '<span class="io-pal-group is-rem" title="잔량 파렛트 ' + (mixed ? pct + "%" : rem + "/" + cap + "박스") + '">' + palletSvg(drawn, cells) +
'<span class="io-pal-cap">잔량 ' + (mixed ? "<b>" + pct + "%</b></span></span>" : "<b>" + rem + "</b>박스 · <b>" + pct + "%</b><br>" +
'<span class="io-pal-need">' + (cap - rem) + "박스 더 실으면 한 파렛트</span></span></span>");
} else {
html += '<span class="io-pal-ok">✓ 모든 파렛트가 꽉 찹니다</span>';
}
@@ -129,6 +134,7 @@
function renumber() {
let q = 0, k = 0, amount = 0, missing = 0;
let bodyBoxes = 0, lidBoxes = 0, unset = 0;
let bagLines = 0, bagBoxes = 0, bagCapped = 0, bagShare = 0, bagCap = 0, bagMixed = false, bagUnset = 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);
@@ -137,9 +143,22 @@
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; }
if (has) { k++; q += n; if (price !== null) amount += price * n; else if (tr.dataset.bag !== "1") missing++; } // 봉투·백은 단가가 원래 없음
const bx = boxCell(tr, n, has);
bodyBoxes += bx.body; lidBoxes += bx.lid; if (bx.unset) unset++;
if (has && tr.dataset.bag === "1") {
const cap = parseInt(tr.dataset.palletBox || "0", 10) || 0;
bagLines++;
bagBoxes += bx.body;
if (cap) { // 1파렛트 박스 수가 다른 봉투·백은 차지하는 비율로 더함
bagCapped += bx.body;
bagShare += bx.body / cap;
if (bagCap && cap !== bagCap) bagMixed = true;
bagCap = Math.max(bagCap, cap);
}
if (bx.unset || !cap) bagUnset++;
} else {
bodyBoxes += bx.body; lidBoxes += bx.lid; if (bx.unset) unset++;
}
const unit = unitOf(tr); // ◀ ▶ = 공배수만큼(입수가 없으면 누를 수 없음)
tr.querySelectorAll(".io-step").forEach(function (b) {
b.disabled = !unit || (b.dataset.step === "-1" && !n);
@@ -150,9 +169,19 @@
const all = bodyBoxes + lidBoxes, pallets = Math.ceil(all / palletBoxes);
const set = function (key, v) { pallet.querySelector('[data-k="' + key + '"]').textContent = v; };
set("body", fmt(bodyBoxes)); set("lid", fmt(lidBoxes)); set("boxes", fmt(all)); set("pallets", fmt(pallets));
pallet.querySelector('[data-k="vis"]').innerHTML = palletVis(all);
pallet.querySelector('[data-k="vis"]').innerHTML = palletVis(all, palletBoxes);
set("note", "1파렛트 = " + palletBoxes + "박스" + (unset ? " · 박스 입수 미설정 " + unset + "종 제외" : ""));
}
if (bagPallet) {
bagPallet.hidden = !bagLines;
const setBag = function (key, v) { bagPallet.querySelector('[data-k="' + key + '"]').textContent = v; };
setBag("boxes", fmt(bagBoxes));
// 섞이면 가장 큰 1파렛트 박스 수로 환산(소수 오차로 한 파렛트 더 나오지 않게 반올림 후 올림)
const bagAll = bagMixed ? Math.ceil(Math.round(bagShare * bagCap * 1e6) / 1e6) : bagCapped;
setBag("pallets", fmt(bagCap ? Math.ceil(bagAll / bagCap) : 0));
bagPallet.querySelector('[data-k="vis"]').innerHTML = palletVis(bagAll, bagCap, bagMixed);
setBag("note", bagUnset ? "박스당 수량·1파렛트당 박스 수량 미설정 " + bagUnset + "종 제외" : "");
}
totalQty.textContent = fmt(q);
totalLines.textContent = fmt(k);
if (totalAmount) totalAmount.textContent = (Math.round(amount * 100) / 100).toLocaleString("ko-KR");
@@ -284,7 +313,10 @@
const row = input.closest("tr");
if (row) { // 단가(상품 정보) — 금액 계산용, 박스 입수(007) — 박스·파렛트 계산용
row.dataset.price = it.price === null || it.price === undefined ? "" : String(it.price);
if ("bodyBox" in row.dataset) { row.dataset.bodyBox = it.body_per_box || ""; row.dataset.lidBox = it.lid_per_box || ""; }
if ("bodyBox" in row.dataset) {
row.dataset.bodyBox = it.body_per_box || ""; row.dataset.lidBox = it.lid_per_box || "";
row.dataset.bag = it.is_bag ? "1" : ""; row.dataset.palletBox = it.boxes_per_pallet || "";
}
const pc = row.querySelector(".io-price");
if (pc) pc.textContent = it.unit_price || "-";
}
@@ -490,13 +522,13 @@
const opt = sel.options[sel.selectedIndex];
const grouped = !!sel.value;
tr.classList.toggle("is-grouped", grouped);
const vals = tr.querySelectorAll(".io-group-val");
if (vals[0]) vals[0].textContent = (opt && opt.dataset.silver) || "-";
if (vals[1]) {
const silverVal = tr.querySelector(".io-group-val.io-r"), colorVal = tr.querySelector(".io-color.io-group-val"); // 봉투·백 줄엔 은 칸 없음
if (silverVal) silverVal.textContent = (opt && opt.dataset.silver) || "-";
if (colorVal) {
const key = (opt && opt.dataset.color) || "none";
const csel = tr.querySelector(".io-color-select");
const copt = csel && Array.from(csel.options).find(function (o) { return o.value === key; });
const sw = vals[1].querySelector(".io-swatch"), nm = vals[1].querySelector(".io-color-name");
const sw = colorVal.querySelector(".io-swatch"), nm = colorVal.querySelector(".io-color-name");
if (sw) { sw.style.background = (copt && copt.dataset.hex) || "#fff"; sw.classList.toggle("is-none", !(copt && copt.dataset.hex)); }
if (nm) nm.textContent = copt ? copt.textContent : "";
}
@@ -531,6 +563,9 @@
tr.hidden = !hit;
if (hit) shown++;
});
body.querySelectorAll(".io-prod-part").forEach(function (part) { // 찾은 줄이 없는 표는 제목째 숨김
part.hidden = !part.querySelector("tbody tr:not([hidden])");
});
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;
@@ -561,7 +596,8 @@
const v = function (k) { return tr.querySelector('[data-key="' + k + '"]').value.trim(); };
const row = { code: tr.dataset.code, unit_price: v("unit_price"), weight_g: v("weight_g"), silver_pct: v("silver_pct") };
if (tr.querySelector('[data-key="group_id"]')) { row.group_id = v("group_id"); row.color = v("color"); } // 006
if (tr.querySelector('[data-key="body_per_box"]')) { row.body_per_box = v("body_per_box"); row.lid_per_box = v("lid_per_box"); } // 007
if (tr.querySelector('[data-key="boxes_per_pallet"]')) { row.body_per_box = v("body_per_box"); row.boxes_per_pallet = v("boxes_per_pallet"); } // 008 봉투·백
else if (tr.querySelector('[data-key="body_per_box"]')) { row.body_per_box = v("body_per_box"); row.lid_per_box = v("lid_per_box"); } // 007
return row;
});
if (rows.length) await act("/inout/settings/products/save", { rows: rows });
@@ -694,13 +730,15 @@
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");
const rots = viewer.querySelectorAll("[data-rotate]");
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;
rots.forEach(function (r) { r.hidden = isHeic; });
if (!isHeic) img.src = "/inout/photos/" + id + (b.dataset.v ? "?v=" + b.dataset.v : "");
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";
@@ -714,10 +752,30 @@
viewer.showModal();
viewer.focus({ preventScroll: true }); // [원본]에 초점 테두리가 생기지 않게(←/→ 는 창에서 받음)
});
// 회전 = 서버가 저장된 사진 자체를 돌림(2026-11-02) — 창은 그대로 두고 큰 사진·썸네일만 새로 받는다
async function rotate(degrees) {
const b = list[at];
rots.forEach(function (r) { r.disabled = true; });
try {
const res = await fetch("/inout/orders/" + viewer.dataset.order + "/photos/" + b.dataset.photo + "/rotate?degrees=" + degrees, { method: "POST" });
const data = await res.json().catch(function () { return {}; });
if (!res.ok) throw new Error(data.error || "사진을 돌리지 못했습니다.");
b.dataset.v = String(Date.now());
const thumb = b.querySelector("img");
if (thumb) thumb.src = "/inout/photos/" + b.dataset.photo + "?v=" + b.dataset.v;
show(at);
} catch (err) {
alertMsg(err.message || "사진을 돌리지 못했습니다.");
} finally {
rots.forEach(function (r) { r.disabled = false; });
}
}
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));
const rot = e.target.closest("[data-rotate]");
if (rot) rotate(rot.dataset.rotate);
});
viewer.addEventListener("keydown", function (e) {
if (e.key === "ArrowLeft") show(at - 1);
+103
View File
@@ -0,0 +1,103 @@
/* 라이브 커머스(2026-11-04) — 스케줄표·호스트 설정 */
.erp-page:has(> .lv) { box-sizing: border-box; } /* 공용 .erp-page 는 폭 100% + 안쪽 여백이라 그대로면 화면보다 넓어진다 */
.lv { display: flex; flex-direction: column; gap: 14px; min-width: 0; }
.lv *, .lv-dlg *, .lv-dlg *::before, .lv-dlg *::after { box-sizing: border-box; }
.lv-dlg [hidden] { display: none !important; }
.lv-bar { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.lv-gap { flex: 1 1 auto; }
.lv-month { margin: 0 6px; font-size: 18px; font-weight: 600; white-space: nowrap; }
.lv-note { margin: 0; padding: 10px 14px; border-radius: 8px; background: #eef6ff; color: #0b4a8b; border: 1px solid #cfe3fb; font-size: 13px; }
.lv-table td { vertical-align: middle; overflow-wrap: anywhere; }
.lv-table th { white-space: nowrap; }
.lv-table tr.lv-off td { color: var(--color-midtone-gray, #666); }
.lv-r { text-align: right; }
.lv-table th.lv-r { text-align: right; }
.lv-num { font-variant-numeric: tabular-nums; }
.lv-nowrap { white-space: nowrap; }
.lv-sub { margin: 0; font-size: 12px; color: var(--color-midtone-gray, #666); }
.lv-actions { white-space: nowrap; text-align: right; }
.lv-thumbs { display: flex; flex-wrap: wrap; gap: 4px; }
.lv-thumbs img { display: block; width: 44px; height: 44px; object-fit: cover; border-radius: 6px; border: 1px solid var(--color-subtle-ash, #e5e5e5); }
/* 공용 .erp-table 은 640px 아래에서 제목 줄을 숨기고 카드로 바뀐다 — 칸 이름을 칸마다 보여 준다 */
@media (max-width: 640px) {
.lv-table td[data-label]::before { content: attr(data-label); display: block; font-size: 12px; font-weight: 400; color: var(--color-midtone-gray, #666); text-align: left; }
.lv-table td.lv-r { text-align: left; }
}
.lv-views { display: inline-flex; gap: 4px; margin-left: 10px; }
.lv-lang { display: inline-flex; padding: 2px; border: 1px solid var(--color-subtle-ash, #e5e5e5); border-radius: 999px; background: #fff; }
.lv-lang button { min-width: 40px; padding: 4px 10px; border: 0; border-radius: 999px; background: none; font-size: 12px; font-weight: 600; color: #4b5563; cursor: pointer; }
.lv-lang button.is-active { background: #111; color: #fff; }
/* 영문 화면은 받은 화면처럼 대문자 */
.lv[lang="en"] .lv-kpi span, .lv[lang="en"] .lv-card-nums span, .lv[lang="en"] .lv-cal thead .lv-cal-time, .lv[lang="en"] .lv-cal tfoot .lv-cal-time, .lv[lang="en"] .lv-total dt { text-transform: uppercase; }
/* ── 달력 보기 ── */
.lv-kpis { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 10px; }
.lv-kpi { display: flex; flex-direction: column; gap: 2px; padding: 10px 14px; border: 1px solid var(--color-subtle-ash, #e5e5e5); border-radius: 10px; background: #fff; }
.lv-kpi span { font-size: 11px; font-weight: 600; letter-spacing: .04em; color: var(--color-midtone-gray, #666); }
.lv-kpi b { font-size: 18px; font-variant-numeric: tabular-nums; }
.lv-jump { display: flex; flex-wrap: wrap; align-items: center; gap: 4px; padding: 8px 12px; border: 1px solid var(--color-subtle-ash, #e5e5e5); border-radius: 10px; background: #fff; }
.lv-jump-label { margin-right: 4px; font-size: 13px; font-weight: 600; color: #4b5563; }
.lv-jump-day { min-width: 28px; height: 28px; padding: 0 4px; border: 1px solid transparent; border-radius: 6px; background: #f1f3f6; color: #1f2937; font-size: 13px; font-weight: 600; cursor: pointer; }
.lv-jump-day:hover { background: #e2e6ec; }
.lv-jump-day.is-weekend { background: #fff6dc; border-color: #f3e2ae; color: #8a4b08; }
.lv-jump-day.is-today { outline: 2px solid #111; outline-offset: -2px; }
.lv-tip { margin: 0; padding: 8px 12px; border: 1px solid var(--color-subtle-ash, #e5e5e5); border-radius: 10px; background: #f6f8fb; font-size: 13px; color: #374151; }
.lv-cal-wrap { overflow: auto; max-height: calc(100vh - 150px); border: 1px solid #cfd4dc; border-radius: 10px; background: #fff; }
.lv-cal { border-collapse: separate; border-spacing: 0; min-width: max-content; }
.lv-cal th, .lv-cal td { border-right: 1px solid #e3e6eb; border-bottom: 1px solid #e3e6eb; }
.lv-cal thead th { position: sticky; top: 0; z-index: 2; width: 182px; min-width: 182px; padding: 8px 6px; background: #e4e8ee; text-align: center; font-weight: 700; }
.lv-cal thead th.is-weekend { background: #f5efd3; color: #7a5c00; }
.lv-cal thead th.is-today { box-shadow: inset 0 -3px 0 #111; }
.lv-cal-weekday { font-size: 13px; letter-spacing: .03em; }
.lv-cal-count { display: inline-block; min-width: 18px; padding: 0 4px; margin-left: 2px; border: 1px solid #cfd4dc; border-radius: 4px; background: #fff; color: #374151; font-size: 11px; font-weight: 600; }
.lv-cal-date { margin-top: 2px; font-size: 11px; font-weight: 600; color: #6b7280; }
.lv-cal .lv-cal-time { position: sticky; left: 0; z-index: 1; width: 132px; min-width: 132px; padding: 8px; background: #f6f7f9; text-align: center; font-size: 13px; font-weight: 700; white-space: nowrap; }
.lv-cal thead .lv-cal-time { z-index: 3; background: #d9dee6; }
.lv-cal .lv-cal-time small { display: block; margin-top: 2px; font-size: 10.5px; font-weight: 600; color: #6b7280; }
.lv-cell { min-height: 100px; padding: 4px; vertical-align: top; background: #fff; }
.lv-cell.is-weekend { background: #fffdf3; }
.lv-cell.is-drop { background: #e8f1ff; box-shadow: inset 0 0 0 2px #3b82f6; }
.lv-cell-add { display: block; width: 100%; min-height: 88px; border: 1px dashed #d8dce3; border-radius: 6px; background: transparent; color: #b0b6c0; font-size: 16px; cursor: pointer; }
.lv-cell-add:hover, .lv-cell-add:focus-visible { border-color: #6b7280; color: #374151; }
.lv-card { margin-bottom: 4px; border: 1.5px solid #1f2937; border-radius: 6px; background: #fff; overflow: hidden; }
.lv-card-head { display: flex; align-items: center; gap: 4px; padding: 3px 6px; border-bottom: 1px solid #1f2937; cursor: grab; }
.lv-card-head:active { cursor: grabbing; }
.lv-card-grip { font-size: 12px; color: #374151; }
.lv-card-name { flex: 1 1 auto; min-width: 0; overflow: hidden; text-align: center; text-overflow: ellipsis; white-space: nowrap; text-transform: uppercase; font-size: 13px; font-weight: 800; letter-spacing: .03em; color: #111; }
.lv-card-edit { padding: 0 2px; border: 0; background: none; color: #374151; font-size: 13px; cursor: pointer; }
.lv-card-nums { display: grid; grid-template-columns: 1fr 1fr; }
.lv-card-nums div { display: flex; flex-direction: column; text-align: center; }
.lv-card-nums div + div { border-left: 1px solid #e3e6eb; }
.lv-card-nums span { padding: 2px 0; background: #f6f7f9; font-size: 10px; font-weight: 600; color: #4b5563; }
.lv-card-nums b { padding: 3px 0; font-size: 14px; font-variant-numeric: tabular-nums; }
.lv-card-foot { display: flex; justify-content: space-between; gap: 4px; padding: 2px 6px; border-top: 1px solid #e3e6eb; background: #f6f7f9; font-size: 10.5px; font-weight: 600; color: #4b5563; }
.lv-card-foot b { color: #8a2c0d; }
.lv-card-foot a { color: #1d4f91; }
.lv-cal tfoot th, .lv-cal tfoot td { position: sticky; bottom: 0; z-index: 2; padding: 8px; background: #101a33; color: #fff; border-color: #2a3550; }
.lv-cal tfoot .lv-cal-time { z-index: 3; background: #101a33; font-size: 12px; }
.lv-total { display: flex; flex-direction: column; gap: 2px; margin: 0; font-size: 11px; font-weight: 600; }
.lv-total div { display: flex; justify-content: space-between; gap: 6px; }
.lv-total dt { color: #aab3c5; }
.lv-total dd { margin: 0; font-variant-numeric: tabular-nums; color: #fbbf72; white-space: nowrap; }
.lv-total dd.is-sales { color: #6ee7a8; }
.lv-total-edit { padding: 0 2px; border: 0; background: none; color: #cbd5e1; font-size: 11px; cursor: pointer; }
.lv-dlg { width: min(560px, calc(100vw - 32px)); max-height: calc(100vh - 40px); padding: 0; border: 1px solid var(--color-subtle-ash, #e5e5e5); border-radius: 12px; }
.lv-dlg::backdrop { background: rgba(0, 0, 0, .35); }
.lv-dlg form { display: flex; flex-direction: column; gap: 12px; padding: 20px 22px; }
.lv-dlg h3 { margin: 0; font-size: 17px; font-weight: 600; }
.lv-field { display: flex; flex: 1 1 0; flex-direction: column; gap: 4px; min-width: 0; font-size: 13px; font-weight: 500; }
.lv-field .erp-input, .lv-field .erp-select { width: 100%; min-width: 0; font-weight: 400; }
.lv-field textarea { resize: vertical; }
.lv-row { display: flex; flex-wrap: wrap; gap: 10px; }
.lv-row .lv-field { flex-basis: 140px; }
.lv-check { display: flex; align-items: center; gap: 6px; font-size: 13px; }
.lv-saved { display: flex; flex-direction: column; gap: 6px; margin: 0; padding: 0; list-style: none; font-size: 13px; }
.lv-saved li { display: flex; align-items: center; justify-content: space-between; gap: 8px; }
.lv-saved a { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.lv-msg { margin: 0; padding: 9px 12px; border-radius: 8px; background: #fbe9e6; color: #a1261b; border: 1px solid #efc6bf; font-size: 13px; }
.lv-foot { display: flex; justify-content: flex-end; gap: 8px; }
+191
View File
@@ -0,0 +1,191 @@
/* 라이브 커머스(2026-11-04) — 스케줄표·달력·호스트 설정 공용: 추가·고치기 창, 저장·지우기(fetch → JSON {ok, message}, 틀려도 입력한 값이 창에 남음).
달력: Jump to Date, 카드 끌어 옮기기·맞바꾸기, 날짜별 광고비. 다시 그린 뒤에도 보던 가로 위치 유지. */
(function () {
"use strict";
const calWrap = document.getElementById("lv-cal-wrap");
const CAL_POS = "lv_cal_left";
function tr(text) { return (window.LV_T && window.LV_T[text]) || text; }
const dialogText = function () { return { okText: tr("확인"), cancelText: tr("취소") }; };
function reload() {
if (calWrap) { try { sessionStorage.setItem(CAL_POS, String(calWrap.scrollLeft)); } catch (_) {} }
location.reload();
}
// 한글·영문 전환 — 브라우저마다 기억(쿠키, /live 안에서만), 서버가 그 언어로 그린다
document.addEventListener("click", function (e) {
const b = e.target.closest("button[data-lang]");
if (!b) return;
document.cookie = "live_lang=" + b.dataset.lang + "; path=/live; max-age=31536000; SameSite=Lax" + (location.protocol === "https:" ? "; Secure" : "");
reload();
});
const dlg = document.getElementById("lv-dlg");
const form = document.getElementById("lv-form");
if (!dlg || !form) return;
const title = dlg.querySelector("#lv-dlg-title");
const msg = form.querySelector("[data-msg]");
const saved = form.querySelector("[data-saved]");
const hostSelect = form.querySelector('select[name="host_id"]');
const fileInput = form.querySelector('input[type="file"]');
function say(text) {
msg.textContent = text || "";
msg.hidden = !text;
}
async function post(url, body) {
try {
const res = await fetch(url, { method: "POST", body: body, headers: { Accept: "application/json" } });
const data = await res.json().catch(function () { return {}; });
return { ok: res.ok && data.ok !== false, message: data.message || data.detail || "HTTP " + res.status };
} catch (_) {
return { ok: false, message: tr("서버에 연결하지 못했습니다. 입력한 값은 그대로 있으니 다시 저장해 보세요.") };
}
}
// 사용 안 함 호스트는 그 호스트로 이미 등록된 방송을 고칠 때만 보인다
function showHosts(current) {
if (!hostSelect) return;
Array.from(hostSelect.options).forEach(function (opt) {
const off = opt.dataset.inactive === "1" && opt.value !== String(current || "");
opt.hidden = off;
opt.disabled = off;
});
}
function showSaved(images) {
if (!saved) return;
saved.textContent = "";
(images || []).forEach(function (im) {
const li = document.createElement("li");
const link = document.createElement("a");
link.href = "/live/images/" + im.id;
link.target = "_blank";
link.rel = "noopener";
link.textContent = im.filename || "#" + im.id;
const del = document.createElement("button");
del.type = "button";
del.className = "erp-btn erp-btn-outline erp-btn-sm";
del.dataset.post = "/live/images/" + im.id + "/delete";
del.dataset.confirm = tr("{name} 를 지울까요?").replace("{name}", im.filename || tr("이 이미지"));
del.textContent = tr("지우기");
li.append(link, del);
saved.appendChild(li);
});
saved.hidden = !saved.children.length;
}
function open(row) {
form.reset();
say("");
const editing = !!(row && row.id);
title.textContent = editing ? title.dataset.edit : title.dataset.add;
form.elements.id.value = "";
Array.from(form.elements).forEach(function (el) {
if (!row || !el.name || !(el.name in row)) return;
if (el.type === "checkbox") el.checked = !!row[el.name];
else if (el.type !== "file") el.value = row[el.name];
});
showHosts(editing && row.host_id);
if (editing && hostSelect) hostSelect.value = String(row.host_id); // 위에서 보이게 한 뒤 다시 고름
showSaved(editing && row.images);
dlg.showModal();
}
const addBtn = document.getElementById("lv-add");
if (addBtn) addBtn.addEventListener("click", function () { open(null); });
dlg.addEventListener("click", function (e) {
if (e.target.closest("[data-close]")) dlg.close();
});
document.addEventListener("click", async function (e) {
const edit = e.target.closest("[data-edit]");
if (edit && edit.tagName === "BUTTON") { open(JSON.parse(edit.dataset.edit)); return; }
const fresh = e.target.closest("button[data-new]");
if (fresh) { open(JSON.parse(fresh.dataset.new)); return; }
const btn = e.target.closest("button[data-post]");
if (!btn) return;
if (!(await window.erpConfirm(btn.dataset.confirm, dialogText()))) return;
const r = await post(btn.dataset.post);
if (r.ok) { reload(); return; }
if (dlg.open) say(r.message); else window.erpAlert(r.message, dialogText());
});
form.addEventListener("submit", async function (e) {
e.preventDefault();
const save = form.querySelector('button[type="submit"]');
const body = new FormData(form);
if (fileInput && !fileInput.files.length) body.delete("images");
save.disabled = true;
say("");
const r = await post(form.getAttribute("action"), body);
if (r.ok) { reload(); return; }
save.disabled = false;
say(r.message);
});
if (!calWrap) return;
// ── 달력: 날짜로 가기(TIME 열이 고정이라 그 폭만큼 띄움) ──
function jumpTo(iso) {
const col = calWrap.querySelector('thead th[data-day="' + iso + '"]');
const time = calWrap.querySelector("thead .lv-cal-time");
if (col && time) calWrap.scrollLeft += col.getBoundingClientRect().left - time.getBoundingClientRect().right;
}
document.addEventListener("click", function (e) {
const b = e.target.closest("[data-jump]");
if (b) jumpTo(b.dataset.jump);
});
let left = null;
try { left = sessionStorage.getItem(CAL_POS); sessionStorage.removeItem(CAL_POS); } catch (_) {}
if (left !== null) calWrap.scrollLeft = Number(left);
else {
const today = calWrap.querySelector("thead th[data-today]");
if (today) jumpTo(today.dataset.day);
}
// ── 달력: 날짜별 광고비 ──
document.addEventListener("click", async function (e) {
const b = e.target.closest("button[data-spend]");
if (!b) return;
const value = await window.erpPrompt(tr("{day} 광고비 (RM) — 비우면 지웁니다").replace("{day}", b.dataset.spend), b.dataset.value || "", dialogText());
if (value === null || value === undefined) return;
const body = new FormData();
body.set("day", b.dataset.spend);
body.set("amount", value);
const r = await post("/live/ad-spend", body);
if (r.ok) reload(); else window.erpAlert(r.message, dialogText());
});
// ── 달력: 카드 머리를 끌어 빈 칸으로 옮기기, 다른 카드 위에 놓아 맞바꾸기 ──
let dragging = null;
calWrap.addEventListener("dragstart", function (e) {
const head = e.target.closest && e.target.closest(".lv-card-head");
if (!head) return;
dragging = head.closest("[data-card]").dataset.card;
e.dataTransfer.effectAllowed = "move";
e.dataTransfer.setData("text/plain", dragging);
});
calWrap.addEventListener("dragend", function () {
dragging = null;
calWrap.querySelectorAll(".is-drop").forEach(function (c) { c.classList.remove("is-drop"); });
});
calWrap.addEventListener("dragover", function (e) {
const cell = dragging && e.target.closest("[data-drop]");
if (!cell) return;
e.preventDefault();
calWrap.querySelectorAll(".is-drop").forEach(function (c) { if (c !== cell) c.classList.remove("is-drop"); });
cell.classList.add("is-drop");
});
calWrap.addEventListener("drop", async function (e) {
const cell = dragging && e.target.closest("[data-drop]");
if (!cell) return;
e.preventDefault();
const id = dragging;
const onto = e.target.closest("[data-card]");
if (onto && onto.dataset.card === id) return;
const body = new FormData();
if (onto) body.set("swap_with", onto.dataset.card);
else { body.set("broadcast_date", cell.dataset.day); body.set("start_time", cell.dataset.start); }
const r = await post("/live/broadcasts/" + id + "/move", body);
if (r.ok) reload(); else window.erpAlert(r.message, dialogText());
});
})();
+15 -10
View File
@@ -87,13 +87,12 @@ a.perf-tab.is-active:link, a.perf-tab.is-active:visited { color: #fff; }
.perf-seg:hover { background: var(--color-ghost-gray); }
.perf-seg.is-active { background: var(--color-deep-black); color: #fff; }
a.perf-seg.is-active, a.perf-seg.is-active:link, a.perf-seg.is-active:visited { color: #fff; }
.perf-nav { display: inline-flex; align-items: center; gap: 6px; }
.perf-nav-btn {
font-size: 12px; padding: 5px 9px; border: 1px solid var(--perf-line); border-radius: 8px; background: #fff;
white-space: nowrap;
}
.perf-nav { display: inline-flex; align-items: center; gap: 2px; }
/* 기간 이동 화살표(2026-11-02) — 진한 회색 SVG, 높이 = 날짜 글자 크기(1em) */
.perf-nav-btn { display: inline-flex; padding: 4px 5px; border-radius: 6px; font-size: 14px; }
.perf-nav-btn:hover { background: var(--color-ghost-gray); }
.perf-nav-label { font-weight: 600; font-size: 14px; min-width: 200px; text-align: center; }
.perf-nav-btn svg { display: block; height: 1em; width: auto; fill: none; stroke: #444; stroke-width: 2.6; stroke-linecap: round; stroke-linejoin: round; }
.perf-nav-label { font-weight: 600; font-size: 14px; text-align: center; }
.perf-custom { display: inline-flex; align-items: center; gap: 6px; }
.perf-custom[hidden] { display: none; }
/* 공통 .erp-input 의 min-width:240px 를 날짜칸에서만 푼다 */
@@ -368,6 +367,7 @@ td.is-link:hover { background: #eef2ff; text-decoration: underline; }
.perf-opt-row { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
.perf-opt-label { font-weight: 600; min-width: 72px; }
.perf-opt-row + .perf-opt-row { margin-top: 10px; }
.perf-hide-list { display: flex; flex-wrap: wrap; gap: 0 12px; }
/* 자동 업데이트 일정(2026-10-26) — 매출 실적·광고비 한 줄씩: 이름·사용 | 요일·시간·간격 | 다음 회차 */
.perf-auto-rows { display: flex; flex-direction: column; }
.perf-auto-row { display: grid; grid-template-columns: 130px 1fr; gap: 6px 16px; padding: 12px 0; border-top: 1px solid var(--perf-line); }
@@ -438,11 +438,15 @@ body.perf-dragging, body.perf-dragging * { cursor: grabbing !important; user-sel
/* ── 매출 실적 표(2026-10-22): 열 너비 = 내용 길이(모든 기간 같음), 날짜 열 고정, 그룹·하위 열 구분, 접기 애니메이션 ── */
.perf-main.perf-autofit { width: auto; }
.perf-main.perf-autofit thead th.perf-th-label, .perf-main.perf-autofit .perf-td-label { width: auto; min-width: 0; max-width: none; overflow: visible; }
/* 날짜 열 — 가로 스크롤해도 왼쪽에 고정(배경을 깔아 뒤로 지나가는 칸을 가림, 오른쪽 그림자로 경계) */
/* 날짜 열 + 일 합계 열(2026-11-02) — 가로 스크롤해도 왼쪽에 고정(배경을 깔아 뒤로 지나가는 칸을 가림, 일 합계 오른쪽 그림자로 경계).
일 합계 왼쪽 위치 = 날짜 열 너비(자동 너비라 performance.js stickyHead 가 --perf-label-w 로 넣는다) */
.perf-main.perf-autofit .perf-th-label, .perf-main.perf-autofit .perf-td-label {
position: sticky; left: 0; z-index: 2; box-shadow: inset -1px 0 0 #e3e3e3, 6px 0 6px -6px rgba(0, 0, 0, .22);
position: sticky; left: 0; z-index: 2; box-shadow: inset -1px 0 0 #e3e3e3;
}
.perf-main.perf-autofit thead th.perf-th-label { z-index: 4; }
.perf-main.perf-autofit .perf-th-total, .perf-main.perf-autofit .perf-td-total {
position: sticky; left: var(--perf-label-w, 0); z-index: 2; box-shadow: inset -1px 0 0 #e3e3e3, 6px 0 6px -6px rgba(0, 0, 0, .22);
}
.perf-main.perf-autofit thead th.perf-th-label, .perf-main.perf-autofit thead th.perf-th-total { z-index: 4; }
:where(.perf-main.perf-autofit) .perf-td-label { background: #fff; } /* 주간합계·기간 합계 줄 배경은 그 줄 규칙 그대로 */
/* 그룹 열 = 진한 보라 머리 + 왼쪽 묶음 선, 하위 열 = 옅은 보라 머리(위 띠) + 옅은 칸, 마지막 하위 열(접히면 그룹 열)이 오른쪽 묶음 선 */
.perf-main th.perf-th-group { background: #e6defa; color: #3d1d8a; font-weight: 800; box-shadow: inset 2px 0 0 #8a6fd8; }
@@ -491,9 +495,10 @@ body.perf-dragging, body.perf-dragging * { cursor: grabbing !important; user-sel
날짜 칸 가로 고정(sticky left)은 그대로. 연간 보기 "연간 합계"는 맨 아래 그대로(제목 행만 고정). */
.perf-main-wrap { overflow-x: auto; overflow-y: hidden; }
.perf-main-wrap .perf-main thead th { z-index: 3; }
.perf-main-wrap .perf-main thead th.perf-th-label { z-index: 5; }
.perf-main-wrap .perf-main thead th.perf-th-label, .perf-main-wrap .perf-main thead th.perf-th-total { z-index: 5; }
.perf-main-wrap .perf-main tbody tr.perf-row-total:first-child > * { position: relative; z-index: 2; }
.perf-main-wrap .perf-main tbody tr.perf-row-total:first-child > .perf-td-label { position: sticky; left: 0; z-index: 4; }
.perf-main-wrap .perf-main tbody tr.perf-row-total:first-child > .perf-td-total { position: sticky; left: var(--perf-label-w, 0); z-index: 4; }
/* 내려온 제목 행 아래 1px — 표 칸 사이 선(border-collapse)은 칸과 함께 안 움직여 그 틈으로 뒤 줄 글자가 비쳤다 → 칸이 직접 선을 그림 */
.perf-main-wrap.is-stuck .perf-main thead th::after { content: ""; position: absolute; left: 0; right: 0; bottom: -1px; height: 1px; background: var(--perf-line); }
/* 스크롤 막대 배경(트랙) 투명(2026-10-27) — 표 상자 가로 막대·실적 화면 세로 막대. 손잡이만 옅은 회색 */
+56 -11
View File
@@ -24,7 +24,7 @@
}
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 와 같은 표기(천원 정수, 백만원 소수 한 자리)
// 매출 단위(실적 설정 "공통 보기 설정", 모든 사용자 같음) — 서버 dashboard.amount_text 와 같은 표기(천원 정수, 백만원 소수 한 자리)
function unitWon(n, unit) {
if (!n) return won(0);
if (unit === "thousand") return Math.round(n / 1000).toLocaleString("ko-KR");
@@ -817,7 +817,7 @@
if (s && shown[cls] != null) s.innerHTML = unitWon(shown[cls], data.unit);
});
td.classList.toggle("is-stale", res.net == null);
// 카페24(공구 제외) 열(2026-10-30) — 공동구매 칸을 저장하면 같은 줄 차이 칸도 바로(카페24 − 새 값). 합계 줄은 새로고침 때.
// 카페24(실적) 열 — 공동구매 칸을 저장하면 같은 줄 칸도 바로(카페24 − 새 값). 합계 줄은 새로고침 때.
const diff = td.parentElement.querySelector('td[data-diff-minus="' + td.dataset.manualCode + '"]');
if (diff) {
const base = diff.dataset.base.split(",").map(Number);
@@ -1292,13 +1292,18 @@
}
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 () {
root.querySelectorAll("#perf-shared-view [data-unit]").forEach(function (b) {
b.addEventListener("click", async 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) {
try {
await api("PUT", "/performance/api/display-unit", { unit: u });
} catch (err) {
alertMsg("저장 실패: " + err.message);
return;
}
root.querySelectorAll("#perf-shared-view [data-unit]").forEach(function (x) {
x.classList.toggle("is-active", x === b);
x.setAttribute("aria-checked", x === b ? "true" : "false");
});
@@ -1331,6 +1336,20 @@
colwReset.textContent = "초기화했습니다";
setTimeout(function () { colwReset.textContent = "조절한 너비 초기화"; }, 1800);
});
// 공통 보기 설정 — 매출 실적 표 열 숨기기(2026-11-02, 관리자), 고르면 바로 저장(차례대로, 실패하면 그 칸만 되돌림)
const hideBoxes = Array.from(root.querySelectorAll("#perf-shared-view [data-hide]"));
let hideSave = Promise.resolve();
hideBoxes.forEach(function (c) {
c.addEventListener("change", function () {
const codes = hideBoxes.filter(function (x) { return x.checked; }).map(function (x) { return x.dataset.hide; });
hideSave = hideSave.then(function () {
return api("PUT", "/performance/api/hidden-marketplaces", { codes: codes });
}).catch(function (err) {
c.checked = !c.checked;
alertMsg("저장 실패: " + err.message);
});
});
});
initAutoSyncSettings(root);
// 사용 / 매출 집계 토글 — 바로 저장, 실패하면 되돌림
@@ -1744,16 +1763,42 @@
cells.forEach(function (c) { c.style.transform = v; });
wrap.classList.toggle("is-stuck", off > 0);
}
const labelHead = head.querySelector(".perf-th-label");
function layout() { // 일 합계 열 가로 고정 위치 = 날짜 열 너비(자동 너비라 CSS 만으로는 모른다)
if (labelHead) table.style.setProperty("--perf-label-w", labelHead.getBoundingClientRect().width + "px");
update();
}
window.addEventListener("scroll", update, true);
window.addEventListener("resize", update);
if (window.ResizeObserver) new ResizeObserver(update).observe(table);
update();
window.addEventListener("resize", layout);
if (window.ResizeObserver) new ResizeObserver(layout).observe(table);
layout();
});
}
// 새로고침해도 스크롤 위치 유지(2026-11-02) — 수기 입력·자동 새로 고침·업로드 뒤 새로고침 모두. 세로는 안쪽 스크롤 상자(.erp-page)라
// 브라우저가 복원하지 않고, 가로는 표 상자. 떠날 때 저장 → 새로고침으로 다시 열릴 때만 복원(메뉴·기간 이동으로 들어오면 맨 위부터).
function keepScroll(root) {
const wrap = root.querySelector(".perf-main-wrap");
if (!wrap) return;
const KEY = "perf_scroll";
const scroller = function () { return scrollParent(wrap) || document.scrollingElement; };
window.addEventListener("pagehide", function () {
try { sessionStorage.setItem(KEY, JSON.stringify({ url: location.href, top: scroller().scrollTop, left: wrap.scrollLeft })); } catch (_) { /* 기억만 못 함 */ }
});
let saved = null;
try {
saved = JSON.parse(sessionStorage.getItem(KEY) || "null");
sessionStorage.removeItem(KEY);
} catch (_) { saved = null; }
const nav = window.performance && performance.getEntriesByType ? performance.getEntriesByType("navigation")[0] : null;
if (!saved || saved.url !== location.href || !nav || nav.type !== "reload") return;
scroller().scrollTop = saved.top;
wrap.scrollLeft = saved.left;
}
document.addEventListener("DOMContentLoaded", function () {
const dash = document.getElementById("perf-dash");
if (dash) { initDashboard(dash); stickyHead(dash); }
if (dash) { initDashboard(dash); stickyHead(dash); keepScroll(dash); }
const set = document.getElementById("perf-settings");
if (set) initSettings(set);
});
+60 -5
View File
@@ -160,16 +160,70 @@
.vac-list-reason { font-size: 12px; margin-top: 4px; }
.vac-empty { padding: 12px 0; }
/* ── 신청 폼 ── */
.vac-form-card { padding: 16px; max-width: 760px; }
/* ── 신청 폼(2026-11-02) — 위 휴가 종류 · 왼쪽 달력 · 오른쪽 날짜·사유 · 아래 결재 라인 ── */
.vac [hidden] { display: none !important; }
.vac-form-card { padding: 20px; max-width: 1000px; flex-shrink: 0; display: flex; flex-direction: column; gap: 20px; }
.vac-types { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin: 0; padding: 0; border: 0; }
.vac-types legend { float: left; margin-right: 12px; padding: 0; font-size: 14px; font-weight: 600; line-height: 34px; }
.vac-type { display: inline-flex; cursor: pointer; }
.vac-type input { position: absolute; opacity: 0; width: 0; height: 0; }
.vac-type span { display: inline-flex; align-items: center; gap: 6px; height: 34px; padding: 0 14px; box-sizing: border-box;
border: 1px solid var(--vac-ash); border-radius: 9999px; font-size: 14px; color: var(--vac-black); background: #fff; }
.vac-type span::before { content: ""; width: 12px; height: 12px; box-sizing: border-box; border: 1.5px solid #a3a3a3; border-radius: 50%; }
.vac-type:hover span { background: var(--vac-ghost); }
.vac-type input:checked + span { background: #000; border-color: #000; color: #fff; font-weight: 700; }
.vac-type input:checked + span::before { border: 4px solid #fff; background: #000; }
.vac-type input:focus-visible + span { outline: 2px solid var(--vac-black); outline-offset: 2px; }
.vac-form-main { display: grid; grid-template-columns: 380px minmax(0, 1fr); gap: 24px; align-items: start; }
@media (max-width: 760px) { .vac-form-main { grid-template-columns: minmax(0, 1fr); } }
.vac-range-cal { border: 1px solid var(--vac-ash); border-radius: 12px; padding: 12px; font-size: 13px; }
/* 붙박이 달력은 팝업보다 칸이 넓다 — 공휴일 이름을 공용 9px 보다 크게 */
.vac-range-cal .pj-dp-hol { font-size: 10.5px; padding: 0; letter-spacing: -.6px; }
.vac-form-side { display: flex; flex-direction: column; min-width: 0; }
.vac-form-grid {
display: grid; grid-template-columns: repeat(2, minmax(0, 1fr));
gap: 12px; margin-bottom: 12px;
}
.vac-full { grid-column: 1 / -1; }
.vac-days-preview { margin: 12px 0; font-size: 14px; }
.vac-form-side .erp-input, .vac-form-side .erp-select { min-width: 0; width: 100%; box-sizing: border-box; }
.vac-form-side input[readonly] { background: var(--vac-ghost); cursor: default; }
.vac-reason textarea { resize: vertical; }
.vac-days-preview { margin: 0 0 12px; font-size: 14px; }
.vac-days-preview strong { font-size: 16px; font-weight: 600; }
.vac-form-actions { display: flex; gap: 8px; margin-top: 8px; }
.vac-form-err { margin: 0; color: var(--vac-red); font-size: 13px; font-weight: 600; }
.vac-form-actions { display: flex; gap: 8px; }
/* 결재 라인 — 신청 화면·상세 공용 */
.vac-line { border-top: 1px solid var(--vac-ash); padding-top: 16px; display: flex; flex-direction: column; gap: 12px; }
.vac-line h3 { margin: 0; font-size: 15px; font-weight: 600; }
.vac-line-row { display: flex; align-items: center; gap: 12px; }
.vac-line-label { flex: none; width: 56px; font-size: 13px; font-weight: 600; }
.vac-line-body { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 16px; min-width: 0; font-size: 14px; }
.vac-line-sub { margin: 0; font-size: 13px; font-weight: 600; }
.vac-line-progress { margin: 0; }
.vac-person { display: inline-flex; align-items: center; gap: 6px; min-width: 0; }
.vac-pick { list-style: none; margin: 0; padding: 8px; display: grid; grid-template-columns: repeat(auto-fill, minmax(150px, 1fr)); gap: 4px;
max-height: 260px; overflow-y: auto; border: 1px solid var(--vac-ash); border-radius: 10px; }
.vac-consult-box { display: flex; flex-direction: column; gap: 8px; }
.vac-consult-row { display: grid; grid-template-columns: 140px minmax(0, 1fr) 28px; gap: 8px; align-items: center; }
.vac-consult-row .erp-input { min-width: 0; width: 100%; box-sizing: border-box; resize: vertical; }
.vac-consult-x { width: 28px; height: 28px; border: 0; border-radius: 6px; background: none; color: var(--vac-muted); cursor: pointer; }
.vac-consult-x:hover { background: var(--vac-ghost); color: var(--vac-red); }
.vac-line-consult { padding: 8px 12px; border-radius: 10px; background: var(--vac-ghost); font-size: 14px; }
.vac-line-consult p { margin: 4px 0 0; white-space: pre-wrap; }
.vac-line-comment { color: var(--vac-red); }
.vac-consult-brief { font-size: 12.5px; white-space: pre-wrap; }
/* 협의·결재 진행 상황 */
.vac-steps { display: inline-flex; flex-wrap: wrap; align-items: center; gap: 4px 6px; }
.vac-step { display: inline-flex; align-items: center; gap: 4px; padding: 2px 8px 2px 4px; border-radius: 9999px; background: var(--vac-ghost);
font-size: 12.5px; white-space: nowrap; }
.vac-step b { font-weight: 700; }
.vac-step.is-ok b { color: var(--vac-green); }
.vac-step.is-no b { color: var(--vac-red); }
.vac-step.is-wait b { color: #b45309; }
.vac-step .vac-opt-face { width: 18px; height: 18px; font-size: 10px; }
.vac-step-arrow { color: var(--vac-muted); }
/* ── 상세 ── */
.vac-detail-card { padding: 16px; max-width: 760px; }
@@ -207,6 +261,7 @@
/* ── 휴가 옵션(2026-10-27) — 승인자·승인 통보자 · 메일 ── */
.vac-opt-msg { margin: 0 0 12px; padding: 8px 12px; border-radius: 8px; background: #eef6ff; color: #1a4fa0; font-size: 13px; }
.vac-opt-msg.is-warn { background: #fff7e6; color: #8a5a00; }
.vac-mail-retry { display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; }
.vac-opt-grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 16px; align-items: start; }
.vac-opt-card { padding: 16px; }
/* .erp-page > .vac 는 화면 높이 flex 라 카드가 줄어 내용이 잘렸다(잔여 연차 줄·메일 글) — 옵션 화면은 줄이지 않고 페이지 스크롤 */
+81 -23
View File
@@ -1,13 +1,12 @@
/* 휴가 신청 폼 — 종류에 따른 필드 토글 + 예상 일수 미리보기.
서버(store.compute_days)가 공휴일 포함 정확히 재계산한다. 여기선 주말만 제외한 근사치.
시작일·종료일 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop.js — 숨긴 input 옆 날짜 버튼, 둘 중 어느 쪽을 눌러도
같은 기간 팝업, 반차는 하루짜리 팝업). 공휴일 = 국경일·대체공휴일(#vac-holidays). 아래쪽은 옵션 잔여 연차 표. */
서버(store.compute_days)가 공휴일 포함 정확히 재계산한다. 여기선 주말·공휴일을 뺀 근사치.
시작일·종료일 = 왼쪽 붙박이 달력(2026-11-02, ErpDatePop.mountRange)에서 고르면 숨긴 칸·오른쪽 표시 칸이 따라옴, 반차는 하루.
공휴일 = 국경일·대체공휴일(#vac-holidays). 결재 라인 = 협의자 고르기·사람별 협의 내용. 아래쪽은 옵션 잔여 연차 표. */
(function () {
"use strict";
var form = document.getElementById("vac-form");
if (!form) return;
var type = document.getElementById("vac-type");
var start = document.getElementById("vac-start");
var startHalf = document.getElementById("vac-start-half");
var endField = document.getElementById("vac-end-field");
@@ -17,6 +16,11 @@
var startHalfField = document.getElementById("vac-start-half-field");
var out = document.getElementById("vac-days-out");
var startShow = document.getElementById("vac-start-show");
var endShow = document.getElementById("vac-end-show");
var err = document.getElementById("vac-form-err");
function typeValue() { var c = form.querySelector('input[name="vacation_type"]:checked'); return c ? c.value : ""; }
function isHalfType(t) { return t === "오전반차" || t === "오후반차"; }
// 휴가 설정의 공휴일(빨강) {날짜: 이름} — 날짜 팝업 표시 + 예상 일수에서 제외(서버 compute_days 와 같은 표)
@@ -26,12 +30,11 @@
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
if (window.ErpDatePop) {
window.ErpDatePop.enhanceRange(start, end, {
labels: { start: "시작일", due: "종료일" }, holidays: holidays, singleLabel: "날짜",
single: function () { return isHalfType(type.value); },
});
}
var cal = window.ErpDatePop.mountRange(document.getElementById("vac-cal"), {
start: start.value, end: end.value, holidays: holidays,
single: function () { return isHalfType(typeValue()); },
onChange: function (s, e) { start.value = s; end.value = e; err.hidden = true; recalc(); },
});
function parseDate(s) {
if (!s) return null;
@@ -56,12 +59,15 @@
}
function recalc() {
var t = type.value;
var half = isHalfType(t);
var half = isHalfType(typeValue());
var oneDay = !!start.value && start.value === end.value;
startShow.value = window.ErpDatePop.fmtFull(start.value);
endShow.value = window.ErpDatePop.fmtFull(end.value);
// 반차 종류면 종료일/구분 숨김, 단일 0.5
endField.style.display = half ? "none" : "";
endHalfField.style.display = half ? "none" : "";
endHalfField.style.display = half || oneDay ? "none" : "";
endHalf.disabled = half || oneDay; // 하루짜리는 시작 구분만 쓴다(서버 compute_days 와 같음)
startHalfField.style.display = half ? "none" : "";
if (half) {
@@ -86,19 +92,71 @@
out.textContent = total > 0 ? String(total) : "0";
}
// 시작일 변경 시 종료일이 비었거나 더 빠르면 맞춰줌
start.addEventListener("change", function () {
if (!end.value || parseDate(end.value) < parseDate(start.value)) {
end.value = start.value;
}
recalc();
});
[type, end, startHalf, endHalf].forEach(function (el) {
if (el) el.addEventListener("change", recalc);
// 반차로 바꾸면 기간을 시작일 하루로
form.querySelectorAll('input[name="vacation_type"]').forEach(function (r) {
r.addEventListener("change", function () {
if (isHalfType(typeValue()) && start.value && end.value !== start.value) {
end.value = start.value;
cal.set(start.value, start.value);
}
recalc();
});
});
[startHalf, endHalf].forEach(function (el) { el.addEventListener("change", recalc); });
recalc();
// ── 결재 라인 — 구성원 선택(복수) → 사람마다 협의 내용 칸, 협의자 없음이면 잠금 ──
var pickBtn = document.getElementById("vac-pick-btn");
var pick = document.getElementById("vac-pick");
var noConsult = document.getElementById("vac-no-consult");
var box = document.getElementById("vac-consult-box");
function rowOf(email) { return box.querySelector('.vac-consult-row[data-email="' + CSS.escape(email) + '"]'); }
function chosen() { return Array.from(pick.querySelectorAll("input[data-email]:checked")); }
function paintConsults() {
var off = noConsult.checked;
var on = {};
chosen().forEach(function (c) { on[c.dataset.email] = true; });
box.querySelectorAll(".vac-consult-row").forEach(function (row) {
var show = !off && !!on[row.dataset.email];
row.hidden = !show;
row.querySelectorAll("input, textarea").forEach(function (x) { x.disabled = !show; });
});
box.hidden = off || !chosen().length;
pickBtn.disabled = off;
if (off) { pick.hidden = true; pickBtn.setAttribute("aria-expanded", "false"); }
if (chosen().length || off) err.hidden = true;
}
pickBtn.addEventListener("click", function () {
pick.hidden = !pick.hidden;
pickBtn.setAttribute("aria-expanded", String(!pick.hidden));
});
document.addEventListener("click", function (e) {
if (!pick.hidden && !pick.contains(e.target) && e.target !== pickBtn) {
pick.hidden = true;
pickBtn.setAttribute("aria-expanded", "false");
}
});
pick.addEventListener("change", paintConsults);
noConsult.addEventListener("change", paintConsults);
box.addEventListener("click", function (e) {
var x = e.target.closest(".vac-consult-x");
if (!x) return;
var c = pick.querySelector('input[data-email="' + CSS.escape(x.closest(".vac-consult-row").dataset.email) + '"]');
if (c) c.checked = false;
paintConsults();
});
paintConsults();
// 숨긴 칸은 브라우저 필수 검사가 안 되므로 여기서 — 날짜는 저장에도, 협의자는 제출에만 필요
form.addEventListener("submit", function (e) {
var submitting = e.submitter && e.submitter.value === "submit";
var msg = !start.value ? "달력에서 휴가 날짜를 고르세요."
: submitting && !noConsult.checked && !chosen().length ? "협의자를 고르거나 '협의자 없음'을 체크하세요." : "";
err.textContent = msg;
err.hidden = !msg;
if (msg) e.preventDefault();
});
})();
/* 휴가 옵션 — 잔여 연차 표(2026-10-27, 입사일 기준): 이름 옆 입사일 = 날짜 버튼(erp-datepop). 고르면 근속·이번 연차 기간·생기는 연차
+1
View File
@@ -39,6 +39,7 @@ MODULE_KEYS: tuple[str, ...] = (
"asset",
"inout",
"outreach",
"live",
"expense_approver",
"vacation_approver",
)
+1 -1
View File
@@ -80,7 +80,7 @@
<div class="erp-card-head">
<div>
<div class="erp-card-title">{{ item.title }}</div>
<div class="erp-card-title">{{ item.card_title or item.title }}</div>
<div class="erp-card-subtitle">{{ item.subtitle }}</div>
</div>
{% if item.status == 'preparing' %}
+14
View File
@@ -272,6 +272,8 @@ docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 <
```bash
docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_002_hire_prior.sql
# 003(2026-11-02, 멱등) — vacation_consults(협의자 결재: 협의 내용·상태), vacation_mail_log.event 에 consult_request·consulted 추가. 미적용이면 협의자 칸 잠김.
docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_003_consults.sql
```
### 운영 서버 초기화 (1회, 사용자 승인 후)
@@ -303,6 +305,18 @@ DDL: `scripts/sql/outreach_db_init.sql` (멱등). DB·역할(`outreach_app`)·
| `outreach_logs` | 보낸 기록(메일·DM, 성공·오류) — 줄을 지워도 남음, 본문·토큰은 안 남김 |
| `outreach_dm_bodies` | DM 수동 보내기 탭의 저장한 본문({이름} 이 든 글, 최대 1000자, 제목 = 첫 줄) — 마이그레이션 `outreach_db_002_dm_bodies.sql`(2026-10-30) |
## live_db 스키마 / 초기화 (라이브 커머스, 2026-11-04)
DDL: `scripts/sql/live_db_init.sql` (멱등). DB·역할(`live_app`)·테이블·인덱스·트리거. **JSON 폴백 없음** — `LIVE_DB_URL` 미설정 시 "설정 필요" 안내.
생성·연결 명령은 `docs/DEPLOYMENT.md` "라이브 커머스 DB 생성". 호스트 계좌·주소 등 개인정보 포함(평문 저장, 화면은 ERP 관리자만).
| 테이블 | 용도 |
| --- | --- |
| `live_hosts` | 호스트 — Full Name (as per IC)·Phone Number·Email·Address·Bank Name·Bank Account Number·Tiktok Handle(@ 없이), `is_active` |
| `live_broadcasts` | 방송 스케줄 — `host_id`(FK RESTRICT)·`broadcast_date`·`start_time`·`end_time`(말레이시아 시간 그대로)·`venue`·`sales_amount`(RM, NULL = 미입력) |
| `live_broadcast_images` | 방송 결과 이미지(메타데이터 제거 후 BYTEA, 방송을 지우면 CASCADE) — 방송당 최대 10장(앱에서 확인) |
| `live_daily_ad_spend` | 날짜별 광고비(RM) — 달력 보기 AD SPEND·ROAS. 마이그레이션 `live_db_002_ad_spend.sql`(init 에도 포함) |
## malaysia_stock_db 스키마 / 초기화
DDL: `scripts/sql/malaysia_stock_db_init.sql` (멱등). DB·역할(`malaysia_app`)·테이블·인덱스·트리거·창고/아이템 seed 를 한 번에 생성. **JSON 폴백 없음** — `MALAYSIA_STOCK_DB_URL` 미설정 시 모듈이 "설정 필요" 안내만 표시. 상품명은 `itemcode_db` 읽기 전용 재사용.
+23
View File
@@ -375,6 +375,28 @@ docker exec dbx-main python -c "import os,psycopg; psycopg.connect(os.environ['O
백업: 매일 `docker exec postgres-db pg_dump -U postgres outreach_db > /var/backups/postgres/outreach_db_$(date +%F).sql`.
백업: 매일 `docker exec postgres-db pg_dump -U postgres inout_db > /var/backups/postgres/inout_db_$(date +%F).sql`.
## 라이브 커머스 DB 생성 (live_db, 2026-11-04)
입출고 DB 와 같은 방법(새 DB — 기존 DB·데이터는 건드리지 않음, 초기화 SQL 멱등, 비밀번호는 URL 인코딩). 호스트 계좌·주소 등 개인정보가 들어가므로 백업 파일 권한에 주의.
```bash
cd /opt/www/main && git pull
docker exec postgres-db psql -U postgres -lqt | cut -d'|' -f1 | grep -w live_db || echo "live_db 없음 — 새로 만든다"
read -s -p "live_app password: " APP_PWD; echo
docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -v app_password="$APP_PWD" < scripts/sql/live_db_init.sql
ENC=$(APP_PWD="$APP_PWD" python3 -c "import os,urllib.parse;print(urllib.parse.quote(os.environ['APP_PWD'],safe=''))")
grep -q "^LIVE_DB_URL=" .env && sed -i "s|^LIVE_DB_URL=.*|LIVE_DB_URL=postgresql://live_app:${ENC}@postgres-db:5432/live_db|" .env \
|| printf '\nLIVE_DB_URL=postgresql://live_app:%s@postgres-db:5432/live_db\n' "$ENC" >> .env
docker compose up --build -d --no-deps web
docker exec dbx-main python -c "import os,psycopg; psycopg.connect(os.environ['LIVE_DB_URL']).execute('select 1 from live_hosts limit 1'); print('DB OK')"
```
이미 만든 live_db 에는 `scripts/sql/live_db_002_ad_spend.sql`(날짜별 광고비 표 하나 추가, 다시 실행 가능)을 백업 뒤 적용한다 — 초기화 SQL 을 다시 돌리면 `live_app` 비밀번호를 다시 넣게 되므로 쓰지 않는다.
되돌리기 = `DROP TABLE live_daily_ad_spend;`(광고비 값만 사라짐).
그다음 ERP 관리자 화면에서 쓸 사람에게 **라이브 커머스** 권한 → ERP 관리자가 라이브 커머스 → 호스트 설정에서 호스트 등록.
백업: 매일 `docker exec postgres-db pg_dump -U postgres live_db > /var/backups/postgres/live_db_$(date +%F).sql`.
## 연간 목표 주차별 매출 목표 두 칸 마이그레이션 (project_db 030)
030은 `goal_week_targets` 에 `value_dist`(유통·인플)·`value_mall`(카페24·네이버) 열만 추가한다(다시 실행 가능, 기존 값 변경 없음, 새 환경변수 없음).
@@ -597,6 +619,7 @@ docker compose down # 컨테이너 제거 (볼륨 유지)
| `APP_ENCRYPTION_KEY_VERSION` | 현재 마스터 키 버전(기본 1). 교체 시 올리고 예전 키는 `APP_ENCRYPTION_KEY_V{n}` 로 남긴 뒤 설정 화면에서 재암호화(`docs/PERFORMANCE_MODULE.md`) |
| `PERFORMANCE_SYNC_DAYS` | [매출 업데이트] 수집 기간(오늘 포함 최근 N일, 기본 7, 최대 90) |
| `OUTREACH_DB_URL` | 안내문 발송 DB DSN (예: `postgresql://outreach_app:<pwd>@postgres-db:5432/outreach_db`, 비밀번호는 URL 인코딩). 미설정 시 모듈 비활성(설정 필요 안내). 권한키 `outreach`. 메일은 `INOUT_DB_URL` 의 Gmail 연결 재사용 |
| `LIVE_DB_URL` | 라이브 커머스 DB DSN (예: `postgresql://live_app:<pwd>@postgres-db:5432/live_db`, 비밀번호는 URL 인코딩). 미설정 시 모듈 비활성(설정 필요 안내). 권한키 `live` |
| `INOUT_DB_URL` | 입출고 관리 DB DSN (예: `postgresql://inout_app:<pwd>@postgres-db:5432/inout_db`). 미설정 시 입출고 모듈 비활성(설정 필요 안내). 권한키 `inout`. 제품은 `ITEMCODE_DB_URL`(단품) 재사용 |
---
+9
View File
@@ -119,6 +119,7 @@ cupang·malaysia 와 같은 DSN). 화면에서 코드·이름으로 검색(`GET
사람이 **[메일 발송]**을 눌러야만 보낸다(자동 발송 없음). 머리 **[발주 메일 보내기 / 다시 보내기]**로 언제든 다시 연다.
- **본문**(`store.order_mail`) = 인사(공장 담당자 이름) · 발주번호·발주일·입고 예정일·품목 수·총수량·요청 사항(메모) 표 ·
품목 표(No·제품 코드·제품명·수량·비고, 합계) · 보낸 사람. HTML + 글 본문(둘 다), 값은 모두 escape. 제목 `[발주] {번호} · {공장} · {첫 품목} 외 n종`.
- **간단 발주 메일**(2026-11-04, 사용자 요청): 공장 이름에 "대성화학"·"인천공장"이 들어가면(띄어쓰기 무시) 품목 표 = 번호·제품 코드·제품명·수량·박스당 수량·박스 수·비고, 요약 표·글 본문에서도 금액·무게·PP·은을 뺀다. 박스 값은 메일을 만들 때의 상품 정보(올림, 뚜껑 있으면 통·뚜껑 따로, 입수 없으면 `-`, 합계는 있는 줄만).
- **보내는 계정** = 누른 사람(발주 담당)의 Gmail — Gmail API `users.messages.send`(`gmail.py`).
사람마다 처음 한 번 **[Gmail 연결]**: 구글 동의 화면(로그인과 같은 OAuth 클라이언트, 범위 `openid email gmail.send` 만, `hd=` 회사 도메인,
`login_hint` = ERP 계정) → `/inout/gmail/callback` 에서 **고른 구글 계정 = ERP 로그인 계정**인지(다르면 거절), gmail.send 허락·갱신 토큰 확인 →
@@ -203,6 +204,14 @@ cupang·malaysia 와 같은 DSN). 화면에서 코드·이름으로 검색(`GET
- 옵션 상품 정보 표 제목 행 = 가운데·굵게·12px × 110%. 그룹 표는 같은 날 **상품 그룹** 탭으로 분리, 옵션 창 폭 1440px 까지.
- **달력 다시 그리기 줄이기**(같은 날): 화면을 옮겨도 마지막 달력을 sessionStorage 에서 바로 붙이고, 서버 값이 바뀐 때만 다시 그린다(보던 달 유지, [오늘]로 돌아옴).
## 6-3-3. 봉투·백 박스·파렛트(2026-11-04, 마이그레이션 008)
- 사용자 요청: 상품 정보에서 이름에 **"미라클 봉투"·"미라클백"** 이 들어간 상품은 **박스당 수량**·**1파렛트당 박스 수량**을 넣도록 일반 상품과 분리.
- 구분은 이름으로(`store.is_bag`, 저장 안 함). 옵션 → 상품 정보에 봉투·백 표를 따로 두고(위), 단가·무게·은 칸은 없다(같은 날 추가 요청 — 전에 넣은 값은 숨은 칸으로 유지). 그룹·색상 칸은 일반 상품과 같다.
- 저장: 박스당 수량 = 기존 `body_per_box`, 1파렛트당 박스 수량 = 새 열 `boxes_per_pallet`. 봉투·백을 저장하면 `lid_per_box` 는 NULL.
- 계산(새 발주서 합계 줄, `inout.js`, 요청에 명시되지 않아 구현 때 정함): 봉투·백은 통·뚜껑 파렛트(1파렛트 30박스)와 **따로** — 박스 = ⌈수량 ÷ 박스당 수량⌉, 파렛트 = ⌈Σ(박스 ÷ 그 상품의 1파렛트당 박스 수량)⌉. 값이 빠진 상품은 몇 종 빠졌는지 표시. 발주 메일에는 넣지 않음.
- 파렛트 그림(같은 날 추가 요청): 통과 같은 그림. 1파렛트 박스 수가 다른 상품이 섞이면 가장 큰 값으로 환산해 그리고 잔량은 %만 표시. 1파렛트 박스 수는 입력값이라 그림 칸은 60칸까지만 그리고 비율로 칠한다.
## 6-4. 입고 요청 메일 — 물류센터 전산 등록 부탁(2026-10-19, 마이그레이션 005)
- **왜**(사용자 요청): 물류에 들어온 입고를 물류센터 입고 담당자가 전산에 등록하도록, 입고 담당이 입고를 저장하면 메일로 알린다.
+10 -6
View File
@@ -284,11 +284,15 @@
10, 20, … 다시 매김(`reorder_marketplaces`). 드래그 단위는 tbody(그룹 없는 행 하나, 또는 그룹 + 하위) — 하위 쇼핑몰은 그 그룹 안에서만.
화면 순서 = `dashboard.ordered_marketplaces`(sort_order 순, 그룹 바로 뒤에 하위) — 설정 표·매출 실적 열·필터 공통. 설정 표도 예전
`registry` 순서 대신 이 순서(009 없어도 됨).
- **카페24(공구 제외) 열**(2026-10-30) — 직접 추가 쇼핑몰 이름이 "카페24 공동구매"(띄어쓰기 무시)면 그 열 바로 오른쪽에
카페24 − 카페24 공동구매(총매출·수수료·차감 매출 각각) 계산 열(`dashboard._cafe24_ex_gb_column`, 열 코드 `cafe24_ex_gb`, kind `diff`).
카페24·공동구매 둘 다 보일 때만, 표 열만(일 합계·KPI·그래프엔 안 더함), 클릭·메모 없음. 공동구매가 그룹 하위면 같은 그룹으로 접힘.
이름으로 찾으므로 설정에서 이름을 바꾸면 열이 사라진다. 공동구매 칸 저장 즉시 그 줄 차이 칸 = 카페24(td `data-base` 총매출,수수료,차감) − 저장 응답
(`performance.js saveManual`, 일 행만 — 주간·기간 합계 줄은 입력을 마친 뒤 새로고침 때). 테스트 `tests/js/perf_manual.test.js` "[공구 제외]".
- **카페24(전체)·카페24(실적) 열**(2026-11-02, 예전 2026-10-30 "공구 제외") — 카페24 열 이름 = 카페24(전체), 바로 오른쪽에 카페24(실적) =
카페24 − 직접 추가 쇼핑몰 "자사몰(공동구매)" 또는 "카페24 공동구매"(띄어쓰기 무시, 총매출·수수료·차감 매출 각각) 계산 열(`dashboard._cafe24_real_column`, 열 코드 `cafe24_ex_gb`, kind `diff`).
카페24가 보이면 늘 있고, 공동구매 쇼핑몰이 없으면(다른 이름으로 바꿔도) 전체 그대로. 쇼핑몰 필터·숨김으로 공동구매 열이 안 보여도 뺀다. 표 열만(일 합계·KPI·그래프엔 안 더함), 클릭·메모 없음.
칸 아래 광고비 줄 = 카페24(전체)의 구글·메타 그대로. 공동구매 칸 저장 즉시 그 줄 칸 = 카페24(td `data-base` 총매출,수수료,차감) − 저장 응답
(`performance.js saveManual`, 일 행만 — 주간·기간 합계 줄은 입력을 마친 뒤 새로고침 때). 테스트 `tests/js/perf_manual.test.js` "[공구 제외]", `test_custom_groups.py`.
- **합계 기준**(2026-11-02) — 일 합계 = 카페24(실적) + 공동구매 + 나머지 쇼핑몰(카페24(전체)는 공동구매가 들어 있어 안 더함). 공동구매를 필터로 뺐으면 실적 + 나머지, 카페24 를 안 골랐으면 고른 쇼핑몰 합.
일 합계·ROAS·KPI·추이·비중·월/연 누적 모두 같은 기준(`dashboard._summary_cells` — 카페24 칸을 실적으로 바꾼 값, 그래프·누적의 카페24 줄 이름 = 카페24(실적)), 표의 카페24(전체) 열만 원래 값.
광고비 탭 매출 대비 광고비·합계 ROAS 도 같은 금액(`total_sales_codes` — 카페24 가 있으면 공동구매 코드를 뺌). 프로젝트 회의록 머리 카드(`project/router.py`)는 아직 예전 합계.
- **매출 실적 표 열 숨기기**(2026-11-02) — 실적 설정 "공통 보기 설정" 카드(관리자), `PUT /performance/api/hidden-marketplaces`, `perf_settings` key `hidden_marketplaces`(코드 배열, 011 미적용이면 저장 503·표는 다 보임). 모든 사용자의 일자별 표에서 열만 숨김(일 합계·KPI·그래프·누적 그대로), 그룹 열은 보이는 하위 합계.
- 테스트: `app/modules/performance/tests/test_custom_groups.py`, 화면 `tests/js/perf_groups.browser.test.js`(render_performance.py 의 `perf_*_groups.html`).
### 연동 단계 체크리스트(쇼핑몰마다)
@@ -417,7 +421,7 @@
- **설정 진단 카드 삭제** — "쇼핑몰 원본 데이터 확인"·"카페24 매출 대조"·"일별 한 번에 비교" 카드와 그 화면 스크립트를 뺐다
(사용자 요청 — 쇼핑몰별 규칙 대조가 끝나 더 안 씀). 서버 API `GET /api/marketplaces/{code}/reconcile`·`daily-check` 와
어댑터 `reconcile`은 다시 대조가 필요할 때를 위해 남겼다(화면 진입점 없음). 아래 절의 "원본 데이터 확인"·"매출 대조" 설명은 그 당시 기록.
- **보기 설정 · 매출 단위** — 설정 화면 "보기 설정" 카드(모듈 권한자 누구나): 원·천원·백만원. 이 브라우저 쿠키 `perf_unit`(1년, path `/performance`)에 두고
- **공통 보기 설정 · 매출 단위**(2026-11-02 모든 사용자 공통, 예전엔 브라우저 쿠키 `perf_unit`) — 설정 화면 "공통 보기 설정" 카드(관리자): 원·천원·백만원. `perf_settings` key `display_unit`(`PUT /api/display-unit`, 저장 값 없음·011 미적용 = 원)에 두고
매출 실적 화면을 서버가 그 단위로 그린다(`dashboard.amount_text` — 천원 = 정수 반올림, 백만원 = 소수 한 자리, `router._unit_ctx` → 템플릿 `amt`·`money`).
표·월/연 누적 카드 머리에 "단위: 천원", KPI·연 누적은 "3,835천원". 수동 입력은 늘 원 단위로 넣는다(입력 직후 칸은 JS `unitWon`). 광고비 탭·그래프 말풍선은 원 그대로.
- **매출 칸 아래 광고비(ROAS%)** — 일자별 × 쇼핑몰 표의 매출 칸마다 그 쇼핑몰 광고비와 ROAS 를 광고비 색(`--perf-ad`) 작은 줄로(`dashboard._ad_lines`).
+3
View File
@@ -24,6 +24,7 @@
| 입출고 관리 | 본사 → 공장 제품 제작 발주, 물류 입고(여러 번 나눠), 발주 대비 미입고·초과 입고 관리 (`app/modules/inout/`, `inout_db`) — 발주 담당·입고 담당·공장은 모듈 옵션에서 지정, 제품은 `itemcode_db` 단품 읽기 전용. `docs/INOUT_MODULE.md` |
| 긴급 공지 | 수퍼관리자가 정한 시각에 전체/고른 사람의 ERP 화면 정가운데에 띄우는 공지(`app/modules/notice/`, project_db 024) — [확인] 전까지 다시 뜸, 확인 현황. `docs/NOTICE_MODULE.md` |
| 안내문 발송 | 리스트(이메일·인스타 주소 + 이름)에 `{이름}`을 넣은 안내문 — 메일 일괄 발송(보내는 사람 본인 Gmail)·인스타 DM 반자동(문구 복사 + DM 창) (`app/modules/outreach/`, `outreach_db`) |
| 라이브 커머스 | 말레이시아 라이브 방송의 호스트 정보(설정)와 스케줄표(호스트·날짜·시간·판매금액·장소·결과 이미지) (`app/modules/live/`, `live_db`) |
| 실적 | 쇼핑몰 통합 매출 (`app/modules/performance/`) — 쇼핑몰별 어댑터로 수집 → `performance_db` 저장 → 일자×쇼핑몰 표·KPI·월/연 누적·그래프. 수수료율 이력, API 인증정보는 설정 화면 입력 + AES-256-GCM 암호화 저장. 1단계는 모의 데이터·구조까지(실제 API 는 쇼핑몰별로 순차 연동). `docs/PERFORMANCE_MODULE.md` |
### 권한 키 (`MODULE_KEYS`)
@@ -39,6 +40,7 @@
| `expense_approver` | 결재 | 개인경비 승인/반려/정산 |
| `asset` | 접근 | 자산관리 조회·등록·수정·배정·반납·보고서 |
| `outreach` | 접근 | 안내문 발송 — 리스트·메일 발송·DM·설정 |
| `live` | 접근 | 라이브 커머스 스케줄표 보기·고치기(호스트 정보 설정은 ERP 관리자만) |
| `inout` | 접근 | 입출고 관리 조회. 발주·입고 입력은 모듈 옵션의 발주 담당·입고 담당(ERP 관리자는 둘 다 + 옵션) |
| `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) |
@@ -114,6 +116,7 @@ app/modules/<name>/
| `vacation_db` | 휴가 신청/공휴일/연차잔여 (`VACATION_DB_URL` 필수, JSON 폴백 없음) |
| `malaysia_stock_db` | 말레이시아 창고 재고/세트BOM/재고조사 (`MALAYSIA_STOCK_DB_URL` 필수, JSON 폴백 없음) |
| `outreach_db` | 안내문 발송 — 리스트·보낸 기록·제목/본문 설정·사진 (`OUTREACH_DB_URL` 필수, JSON 폴백 없음) |
| `live_db` | 라이브 커머스 — 호스트 정보·방송 스케줄·결과 이미지 (`LIVE_DB_URL` 필수, JSON 폴백 없음) |
| `performance_db` | 실적 — 쇼핑몰 설정/수수료 이력/인증정보(암호문)/매출 사건 (`PERFORMANCE_DB_URL` 필수, JSON 폴백 없음) |
> 신규 DB 생성은 서버 실행 명령을 제공하고 사용자가 직접 진행한다 (사용자 지시: 2026-10-06). 대상·상태·백업 확인 명령을 제공하고 이름은 `_db`로 끝낸다. 기존 DB 삭제·덮어쓰기는 별도 승인 대상이다. 상세는 `DATABASES.md`.
+18
View File
@@ -0,0 +1,18 @@
-- =====================================================================
-- inout_db 마이그레이션 008 — 봉투·백 1파렛트당 박스 수량(2026-11-04)
-- =====================================================================
-- 멱등(idempotent). 열 하나만 추가(기존 값 그대로). 007 다음에 적용. 운영: /opt/www/main 에서 기존 inout_db 에 적용(백업 먼저).
-- docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d inout_db < scripts/sql/inout_db_008_bag_pallet.sql
--
-- 왜(사용자 요청): 이름에 "미라클 봉투"·"미라클백"이 들어간 상품은 옵션 → 상품 정보에서 일반 상품과 따로,
-- 박스당 수량(기존 body_per_box 를 그대로 씀)과 1파렛트당 박스 수량(이 열)을 넣는다. 봉투·백 여부는 저장하지 않고 이름으로 판단.
-- 되돌리기: ALTER TABLE inout_products DROP COLUMN boxes_per_pallet; (1파렛트당 박스 수량만 사라짐 — 실행 전 백업)
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
ALTER TABLE inout_products ADD COLUMN IF NOT EXISTS boxes_per_pallet INT NULL CHECK (boxes_per_pallet IS NULL OR boxes_per_pallet > 0);
COMMENT ON COLUMN inout_products.boxes_per_pallet IS '1파렛트당 박스 수량(봉투·백만) — NULL = 미입력';
COMMIT;
SELECT 'inout_db 008 bag pallet ready' AS status;
+21
View File
@@ -0,0 +1,21 @@
-- =====================================================================
-- live_db 마이그레이션 002 — 날짜별 광고비(달력 보기 맨 아래 AD SPEND·ROAS)(2026-11-04)
-- =====================================================================
-- 멱등(idempotent). 표 하나만 추가(기존 표·값 변경 없음). 운영: /opt/www/main 에서 기존 live_db 에 적용(백업 먼저).
-- docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d live_db < scripts/sql/live_db_002_ad_spend.sql
-- 되돌리기: DROP TABLE live_daily_ad_spend; (광고비 값만 사라짐 — 실행 전 백업)
-- =====================================================================
\set ON_ERROR_STOP on
BEGIN;
CREATE TABLE IF NOT EXISTS live_daily_ad_spend (
ad_date DATE PRIMARY KEY,
ad_spend NUMERIC(14,2) NOT NULL CHECK (ad_spend >= 0),
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE live_daily_ad_spend IS '라이브 커머스 — 날짜별 광고비(RM)';
GRANT SELECT, INSERT, UPDATE, DELETE ON live_daily_ad_spend TO live_app;
COMMIT;
SELECT 'live_db 002 ad spend ready' AS status;
+127
View File
@@ -0,0 +1,127 @@
-- =====================================================================
-- live_db 초기화 스크립트 (PostgreSQL) — 라이브 커머스 모듈(2026-11-04)
-- =====================================================================
-- 말레이시아 라이브 커머스 방송 — 호스트 정보(설정)와 방송 스케줄(호스트·날짜·시간·판매금액·장소·결과 이미지).
-- 멱등(idempotent): 여러 번 실행해도 안전. 기존 데이터를 삭제하지 않는다. DROP/TRUNCATE 없음(트리거 다시 만들기만).
--
-- 실행 방법 (운영 PostgreSQL 컨테이너명: postgres-db, 백업 먼저):
--
-- 1) DB / 역할 / 테이블 생성 (superuser 로 1회)
-- read -s -p "live_app password: " APP_PWD; echo
-- docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/live_db_init.sql
--
-- 2) main-app .env 에 연결 정보 등록
-- LIVE_DB_URL=postgresql://live_app:<APP_PWD>@postgres-db:5432/live_db
--
-- 3) main-app 재기동
-- cd /opt/www/main && docker compose up -d --build --no-deps web
-- =====================================================================
\set ON_ERROR_STOP on
SELECT 'CREATE DATABASE live_db ENCODING ''UTF8'' TEMPLATE template0'
WHERE NOT EXISTS (SELECT 1 FROM pg_database WHERE datname = 'live_db')
\gexec
SELECT 'CREATE ROLE live_app LOGIN PASSWORD ' || quote_literal(:'app_password')
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'live_app')
\gexec
SELECT 'ALTER ROLE live_app WITH LOGIN PASSWORD ' || quote_literal(:'app_password')
\gexec
GRANT CONNECT ON DATABASE live_db TO live_app;
\connect live_db
CREATE OR REPLACE FUNCTION live_set_updated_at() RETURNS trigger AS $$
BEGIN
NEW.updated_at := now();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
-- ════════════════════════════════════════════════════════════
-- 1) 호스트 — 설정에서 미리 등록(개인정보·계좌 포함, 설정 화면은 ERP 관리자만)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS live_hosts (
id BIGSERIAL PRIMARY KEY,
full_name TEXT NOT NULL CHECK (char_length(full_name) BETWEEN 1 AND 200), -- Full Name (as per IC)
phone TEXT NOT NULL DEFAULT '',
email TEXT NOT NULL DEFAULT '',
address TEXT NOT NULL DEFAULT '',
bank_name TEXT NOT NULL DEFAULT '',
bank_account TEXT NOT NULL DEFAULT '',
tiktok_handle TEXT NOT NULL DEFAULT '', -- @ 없이
is_active BOOLEAN NOT NULL DEFAULT TRUE, -- FALSE = 새 방송에서 못 고름
created_by TEXT NOT NULL DEFAULT '',
updated_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE live_hosts IS '라이브 커머스 — 호스트 정보(개인정보·계좌 포함)';
DROP TRIGGER IF EXISTS trg_live_hosts_updated_at ON live_hosts;
CREATE TRIGGER trg_live_hosts_updated_at BEFORE UPDATE ON live_hosts
FOR EACH ROW EXECUTE FUNCTION live_set_updated_at();
-- ════════════════════════════════════════════════════════════
-- 2) 방송 스케줄 — 날짜·시간은 입력한 말레이시아 시간 그대로(시간대 변환 없음), 판매금액 단위 RM
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS live_broadcasts (
id BIGSERIAL PRIMARY KEY,
host_id BIGINT NOT NULL REFERENCES live_hosts(id) ON DELETE RESTRICT, -- 방송 기록이 있는 호스트는 못 지움
broadcast_date DATE NOT NULL,
start_time TIME NOT NULL,
end_time TIME,
venue TEXT NOT NULL DEFAULT '',
sales_amount NUMERIC(14,2) CHECK (sales_amount IS NULL OR sales_amount >= 0), -- NULL = 아직 입력 안 함
created_by TEXT NOT NULL DEFAULT '',
updated_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE live_broadcasts IS '라이브 커머스 — 방송 스케줄';
CREATE INDEX IF NOT EXISTS idx_live_broadcasts_date ON live_broadcasts (broadcast_date, start_time);
CREATE INDEX IF NOT EXISTS idx_live_broadcasts_host ON live_broadcasts (host_id);
DROP TRIGGER IF EXISTS trg_live_broadcasts_updated_at ON live_broadcasts;
CREATE TRIGGER trg_live_broadcasts_updated_at BEFORE UPDATE ON live_broadcasts
FOR EACH ROW EXECUTE FUNCTION live_set_updated_at();
-- ════════════════════════════════════════════════════════════
-- 3) 방송 결과 이미지 — 서버가 확인·메타데이터 제거 후 저장(방송을 지우면 함께 지워짐)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS live_broadcast_images (
id BIGSERIAL PRIMARY KEY,
broadcast_id BIGINT NOT NULL REFERENCES live_broadcasts(id) ON DELETE CASCADE,
filename TEXT NOT NULL DEFAULT '',
content_type TEXT NOT NULL,
data BYTEA NOT NULL,
width INTEGER NOT NULL DEFAULT 0,
height INTEGER NOT NULL DEFAULT 0,
created_by TEXT NOT NULL DEFAULT '',
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE live_broadcast_images IS '라이브 커머스 — 방송 결과 이미지';
CREATE INDEX IF NOT EXISTS idx_live_images_broadcast ON live_broadcast_images (broadcast_id, id);
-- ════════════════════════════════════════════════════════════
-- 3-1) 날짜별 광고비 — 마이그레이션 002 와 같음(달력 보기 AD SPEND·ROAS)
-- ════════════════════════════════════════════════════════════
CREATE TABLE IF NOT EXISTS live_daily_ad_spend (
ad_date DATE PRIMARY KEY,
ad_spend NUMERIC(14,2) NOT NULL CHECK (ad_spend >= 0),
updated_by TEXT NOT NULL DEFAULT '',
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
);
COMMENT ON TABLE live_daily_ad_spend IS '라이브 커머스 — 날짜별 광고비(RM)';
-- ════════════════════════════════════════════════════════════
-- 4) 권한 (live_app: CRUD only)
-- ════════════════════════════════════════════════════════════
GRANT USAGE ON SCHEMA public TO live_app;
GRANT SELECT, INSERT, UPDATE, DELETE ON live_hosts, live_broadcasts, live_broadcast_images, live_daily_ad_spend TO live_app;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO live_app;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO live_app;
ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT USAGE, SELECT ON SEQUENCES TO live_app;
SELECT 'live_db ready' AS status;
+32
View File
@@ -0,0 +1,32 @@
-- ════════════════════════════════════════════════════════════
-- vacation_db 003 — 협의자 결재 (2026-11-02)
-- ════════════════════════════════════════════════════════════
-- · vacation_consults: 휴가 신청마다 협의자 한 줄 — 이메일·이름·그 사람에게 쓴 협의 내용·상태(대기|승인|반려)·반려 사유·처리 시각.
-- 신청을 지우면 함께 지워진다. 협의자가 있으면 신청 상태가 '협의중' → 모두 승인하면 '제출'(결재자 승인 대기).
-- · vacation_mail_log.event 에 협의 메일 두 종류 추가(consult_request = 협의자에게, consulted = 협의 끝남).
-- 적용(운영, superuser, 1회 — 여러 번 돌려도 안전, 기존 데이터는 그대로):
-- docker exec -i postgres-db psql -U postgres -d vacation_db -v ON_ERROR_STOP=1 < scripts/sql/vacation_db_003_consults.sql
-- 미적용이면 앱은 협의자 없이 예전처럼 동작한다(신청 화면 협의자 칸 잠김).
\set ON_ERROR_STOP on
CREATE TABLE IF NOT EXISTS vacation_consults (
id BIGSERIAL PRIMARY KEY,
request_id TEXT NOT NULL REFERENCES vacation_requests (id) ON DELETE CASCADE,
email TEXT NOT NULL,
name TEXT NOT NULL DEFAULT '',
message TEXT NOT NULL DEFAULT '',
state TEXT NOT NULL DEFAULT '대기' CHECK (state IN ('대기', '승인', '반려')),
comment TEXT NOT NULL DEFAULT '',
decided_at TIMESTAMPTZ,
UNIQUE (request_id, email)
);
CREATE INDEX IF NOT EXISTS idx_vacation_consults_email ON vacation_consults (email, state);
ALTER TABLE vacation_mail_log DROP CONSTRAINT IF EXISTS vacation_mail_log_event_check;
ALTER TABLE vacation_mail_log ADD CONSTRAINT vacation_mail_log_event_check
CHECK (event IN ('submitted', 'approved', 'rejected', 'consult_request', 'consulted'));
GRANT SELECT, INSERT, UPDATE, DELETE ON vacation_consults TO vacation_app;
GRANT USAGE, SELECT ON SEQUENCE vacation_consults_id_seq TO vacation_app;
SELECT 'vacation_db 003 ready' AS status;
+1 -1
View File
@@ -35,7 +35,7 @@ function page(file) {
});
};
const h0 = await heads();
check("그룹 열이 하위 열 바로 앞", JSON.stringify(h0.slice(1, 7)) === JSON.stringify(["카페24", "네이버", "오프라인", "매장A ✎", "매장B ✎", "행사 ✎"]), h0);
check("그룹 열이 하위 열 바로 앞", JSON.stringify(h0.slice(1, 9)) === JSON.stringify(["일 합계", "카페24(전체)", "카페24(실적)", "네이버", "오프라인", "매장A ✎", "매장B ✎", "행사 ✎"]), h0);
const expanded = function () { return p.getAttribute('[data-group-toggle="group_off"]', "aria-expanded"); };
// 열 너비 = 내용 길이 — 표가 화면보다 좁으면 늘이지 않는다, 각 열은 그 열의 가장 긴 글자 + 여백 정도
const fit = await p.evaluate(function () {
+39 -5
View File
@@ -72,9 +72,9 @@ function gross(td) { return td.querySelector(".v-gross").textContent.trim(); }
const e = await env("perf_dash.html");
const heads = Array.from(e.d.querySelectorAll(".perf-main thead th")).map(function (th) { return th.textContent.replace("✎", "").trim(); });
check("[순서] 카페24·네이버·쿠팡·토스·GS샵·11번가 다음 나머지", heads.join(",") ===
"날짜,카페24,네이버,쿠팡,토스,GS샵,11번가,오늘의집,G마켓,카카오,롯데ON,일 합계", heads);
check("[수동] 수동 입력 쇼핑몰 제목에 ✎ 표시", /✎/.test(e.d.querySelectorAll(".perf-main thead th")[3].textContent) &&
!/✎/.test(e.d.querySelectorAll(".perf-main thead th")[1].textContent));
"날짜,일 합계,카페24(전체),카페24(실적),네이버,쿠팡,토스,GS샵,11번가,오늘의집,G마켓,카카오,롯데ON", heads);
check("[수동] 수동 입력 쇼핑몰 제목에 ✎ 표시", /✎/.test(e.d.querySelectorAll(".perf-main thead th")[5].textContent) &&
!/✎/.test(e.d.querySelectorAll(".perf-main thead th")[2].textContent));
// 2026-10-21 — 앞으로의 날도 입력 칸(사용자 요청). 주간합계 줄은 여전히 아님
check("[수동] 날짜 칸은 앞으로의 날도 입력 칸(주간합계 아님), 수동 값 칸은 파란 표시",
!!cell(e, "coupang", "2026-10-07") && !!cell(e, "coupang", "2026-10-08") && cell(e, "coupang", "2026-10-05").classList.contains("is-manual") &&
@@ -112,7 +112,7 @@ function gross(td) { return td.querySelector(".v-gross").textContent.trim(); }
check("[입력] 숫자가 아니면 저장 안 하고 안내", e.alerts.some(function (m) { return /숫자/.test(m); }) &&
e.calls.filter(function (c) { return c.method === "PUT"; }).length === 1, e.alerts);
}
// ── 카페24(공구 제외) 열(2026-10-30) — 공동구매 칸 저장 → 같은 줄 차이 칸 = 카페24 − 새 값(dashboard._cafe24_ex_gb_column) ──
// ── 카페24(실적) 열 — 공동구매 칸 저장 → 같은 줄 칸 = 카페24 − 새 값(dashboard._cafe24_real_column) ──
{
const e = await env("perf_dash.html");
const td5 = cell(e, "coupang", "2026-10-05");
@@ -182,7 +182,7 @@ function gross(td) { return td.querySelector(".v-gross").textContent.trim(); }
check("[광고비] 광고비 탭이 고른 탭", e.d.querySelector(".perf-tab-ads").classList.contains("is-active"));
const heads = Array.from(e.d.querySelectorAll(".perf-main thead th")).map(function (th) { return th.textContent.replace("✎", "").replace("table_view", "").trim(); });
check("[광고비] 열 = 구글·메타·네이버·쿠팡(윙)·쿠팡(로켓)·오늘의집·G마켓·카카오·GS샵·11번가·롯데ON·토스·애터미아자몰·기타광고비(2026-10-22)",
heads.join(",") === "날짜,구글,메타,네이버,쿠팡(윙),쿠팡(로켓),오늘의집,G마켓,카카오,GS샵,11번가,롯데ON,토스,애터미아자몰,기타광고비,일 합계", heads);
heads.join(",") === "날짜,일 합계,구글,메타,네이버,쿠팡(윙),쿠팡(로켓),오늘의집,G마켓,카카오,GS샵,11번가,롯데ON,토스,애터미아자몰,기타광고비", heads);
const wing = cell(e, "coupang_wing", "2026-10-05");
check("[광고비] 칸 = 광고비(ROAS%) — 쿠팡(윙) 29,000 · 쿠팡 매출 87,000 → 300%",
wing.textContent.trim() === "29,000(300%)" && !cell(e, "naver", "2026-10-05").querySelector(".perf-roas"), wing.textContent);
@@ -312,6 +312,40 @@ function gross(td) { return td.querySelector(".v-gross").textContent.trim(); }
await settle();
check("[설정] 저장 실패(002 미적용) → 되돌리고 안내", !box2.checked && e.alerts.some(function (m) { return /마이그레이션/.test(m); }), e.alerts);
}
// ── 설정: 공통 보기 설정 — 매출 단위·열 숨기기, 모든 사용자에게 적용(서버 저장, 쿠키 아님) ──
{
const e = await env("perf_settings.html");
check("[매출 단위] 공통 카드로 이동, 표 열 너비는 보기 설정에 그대로",
e.d.querySelectorAll("#perf-shared-view [data-unit]").length === 3 && !e.d.querySelector("#perf-view-opts [data-unit]") && !!e.d.querySelector("#perf-view-opts [data-colw]"));
const thousand = e.d.querySelector('#perf-shared-view [data-unit="thousand"]');
thousand.click();
await settle();
const unitPut = e.calls.find(function (c) { return c.method === "PUT"; });
check("[매출 단위] 누르면 서버에 저장·쿠키 안 씀", unitPut && unitPut.url === "/performance/api/display-unit" && unitPut.body.unit === "thousand" &&
thousand.classList.contains("is-active") && !/perf_unit/.test(e.d.cookie), e.calls);
e.status = 503;
const million = e.d.querySelector('#perf-shared-view [data-unit="million"]');
million.click();
await settle();
check("[매출 단위] 저장 실패 → 그대로·안내", !million.classList.contains("is-active") && thousand.classList.contains("is-active") && e.alerts.length > 0, e.alerts);
}
{
const e = await env("perf_settings.html");
const list = Array.from(e.d.querySelectorAll("#perf-shared-view [data-hide]")).map(function (x) { return x.dataset.hide; });
check("[숨기기] 목록 = 표 열(카페24 바로 뒤 카페24(실적))", list.slice(0, 3).join(",") === "cafe24,cafe24_ex_gb,naver", list);
const box = e.d.querySelector('#perf-shared-view [data-hide="naver"]');
box.checked = true;
box.dispatchEvent(new e.w.Event("change", { bubbles: true }));
await settle();
const put = e.calls.find(function (c) { return c.method === "PUT"; });
check("[숨기기] 체크 → 서버에 바로 저장", put && put.url === "/performance/api/hidden-marketplaces" && put.body.codes.join(",") === "naver", e.calls);
check("[숨기기] 쿠키에 안 남김", !/perf_hidden/.test(e.d.cookie), e.d.cookie);
e.status = 503;
box.checked = false;
box.dispatchEvent(new e.w.Event("change", { bubbles: true }));
await settle();
check("[숨기기] 저장 실패 → 되돌리고 안내", box.checked && e.alerts.length > 0, e.alerts);
}
console.log(fails.length ? "\n" + fails.length + " FAILED" : "\nALL PASS");
process.exit(fails.length ? 1 : 0);
})();
+41
View File
@@ -73,6 +73,23 @@ async function stickyFlow(browser, file, label) {
const g2 = await geo();
check(label + " 가로 스크롤해도 기간 합계 날짜 칸은 왼쪽 고정", Math.abs(g2.labelLeft - g2.wrapLeft) <= 1.5 && g2.hitLabel &&
Math.abs(g2.headTop - g2.pageTop) <= 1, g2);
// 일 합계 열 — 날짜 열 바로 오른쪽에 함께 고정(제목·기간 합계·일 행 모두), 위에 다른 칸이 안 겹침(2026-11-02)
const tg = await p.evaluate(function () {
const box = function (s) { return document.querySelector(s).getBoundingClientRect(); };
const hit = function (s) { const r = box(s), n = document.elementFromPoint(r.left + r.width / 2, r.top + r.height / 2); return !!n.closest(s); };
const label = box(".perf-main thead th.perf-th-label");
const rows = [".perf-main thead th.perf-th-total", ".perf-main tbody tr.perf-row-total:first-child > .perf-td-total", ".perf-main tbody tr.perf-row-day > .perf-td-total"];
return { labelRight: label.right, lefts: rows.map(function (s) { return box(s).left; }), hits: rows.slice(0, 2).map(hit), scrolled: document.querySelector(".perf-main-wrap").scrollLeft };
});
check(label + " 가로 스크롤해도 일 합계 열은 날짜 열 바로 옆 고정", tg.scrolled > 0 && tg.lefts.every(function (x) { return Math.abs(x - tg.labelRight) <= 1.5; }) && tg.hits.every(Boolean), tg);
// 기간 이동 — 날짜 바로 좌우 화살표 SVG(글자 높이), 글자 없음
const nv = await p.evaluate(function () {
const a = document.querySelectorAll(".perf-nav-btn"), lb = document.querySelector(".perf-nav-label").getBoundingClientRect();
const svg = a[0].querySelector("svg");
return { text: a[0].textContent.trim() + a[1].textContent.trim(), h: svg.getBoundingClientRect().height, size: parseFloat(getComputedStyle(document.querySelector(".perf-nav-label")).fontSize),
stroke: getComputedStyle(svg).stroke, gapL: lb.left - a[0].getBoundingClientRect().right, gapR: a[1].getBoundingClientRect().left - lb.right };
});
check(label + " 기간 이동 = 날짜 바로 옆 글자 높이 화살표(진한 회색)", nv.text === "" && Math.abs(nv.h - nv.size) <= 1 && nv.gapL <= 3 && nv.gapR <= 3 && nv.stroke === "rgb(68, 68, 68)", nv);
// 표 끝을 넘어가면 같이 올라간다(표 밖으로 나가지 않음)
await p.evaluate(function () { const pg = document.querySelector(".erp-page"); pg.scrollTop = pg.scrollHeight; });
await p.waitForTimeout(120);
@@ -84,6 +101,30 @@ async function stickyFlow(browser, file, label) {
await p.waitForTimeout(120);
const g4 = await geo();
check(label + " 맨 위로 돌아오면 제자리", Math.abs(g4.headTop - g0.headTop) <= 1 && Math.abs(g4.totalTop - g4.headBottom) <= 1, g4);
// 수기 입력 뒤 새로고침 — 세로·가로 스크롤 위치 그대로, 제목 행도 다시 화면 위(2026-11-02)
const pos = function () {
return p.evaluate(function () {
const wrap = document.querySelector(".perf-main-wrap"), page = document.querySelector(".erp-page");
return { top: page.scrollTop, left: wrap.scrollLeft, headTop: document.querySelector(".perf-main thead th").getBoundingClientRect().top, pageTop: page.getBoundingClientRect().top };
});
};
await p.evaluate(function () { document.querySelector(".erp-page").scrollTop = 500; document.querySelector(".perf-main-wrap").scrollLeft = 120; });
await p.waitForTimeout(80);
const before = await pos();
await Promise.all([p.waitForNavigation(), p.evaluate(function () {
document.querySelector('td.is-manual-cell[data-date="2026-10-20"]').click();
const input = document.querySelector(".perf-manual-input");
input.value = "5000";
input.blur();
})]);
await p.waitForTimeout(150);
const after = await pos();
check(label + " 수기 입력 뒤 새로고침해도 스크롤 위치 그대로", before.top === 500 && before.left > 0 && after.top === before.top && after.left === before.left &&
Math.abs(after.headTop - after.pageTop) <= 1, { before: before, after: after });
// 새로고침이 아닌 이동(같은 주소로 다시 들어옴)은 맨 위부터
await p.goto("http://perf.test/performance/");
await p.waitForTimeout(150);
check(label + " 새로 들어오면 맨 위부터", (await pos()).top === 0);
await ctx.close();
}
+6 -1
View File
@@ -26,7 +26,12 @@ def main() -> None:
ctx = {"user": {"email": "kim@test.local", "name": "김철수", "picture": ""}, "is_admin": False, "is_approver": False,
"nav_items": [], "page_title": "휴가 신청", "page_subtitle": "", "mode": "new", "req": None,
"default_date": "2026-10-27", "vacation_types": list(VACATION_TYPES), "halves": list(HALVES),
"half_labels": HALF_LABELS, "holidays": {"2026-10-03": "개천절", "2026-10-09": "한글날", "2026-12-25": "성탄절"}}
"half_labels": HALF_LABELS, "holidays": {"2026-10-01": "부처님오신날", "2026-10-03": "개천절", "2026-10-09": "한글날", "2026-12-25": "성탄절"}, # 10-01 = 가장 긴 이름(석가탄신일) 칸 맞춤 확인용
"consult_ready": True, "consult_chosen": {},
"members": [{"email": "lee@test.local", "name": "이팀장", "picture": ""}, {"email": "park@test.local", "name": "박과장", "picture": ""},
{"email": "choi@test.local", "name": "최대리", "picture": ""}],
"line": {"approvers": [{"email": "rj@test.local", "name": "RJ", "picture": ""}],
"notifiers": [{"email": "ellen@test.local", "name": "Ellen", "picture": ""}]}}
html = env.get_template("vacation/form.html").render(**ctx)
with open(os.path.join(OUT_DIR, "vac_form.html"), "w", encoding="utf-8") as f:
f.write(html)
+136 -74
View File
@@ -1,8 +1,8 @@
// 휴가 신청 날짜 칸 = 프로젝트와 같은 아사나식 날짜 팝업(2026-10-27, erp-datepop.js) — 실제 브라우저(Chromium).
// 휴가 신청 화면(2026-11-02) — 라디오 휴가 종류·붙박이 기간 달력·결재 라인 — 실제 브라우저(Chromium).
// python tests/js/render_vacation.py
// NODE_PATH=<playwright 경로> PJ_TEST_BROWSER=<Chrome 경로> node tests/js/vacation_datepop.browser.test.js
// 브라우저 기본 달력 없음(숨긴 input = 값 저장소), 시작일·종료일 날짜 버튼 → 기간 팝업(누른 칸이 먼저), 날짜를 고르면 시작 → 종료로 넘어가고
// 종료를 고르면 닫힘, 공휴일 빨강·이름, 직접 입력(Enter), 반차 = 하루짜리, 제출하면 고른 날짜가 그대로 서버로.
// 달력 클릭 → 시작일·종료일 자동, 같은 날 = 동그라미, 기간 = 둥근 막대, 반차 = 하루, 공휴일 빨강·이름, 일수.
// 협의자: 구성원 선택(복수) → 사람마다 협의 내용 칸, 협의자 없음 = 잠금, 제출 검사, 고른 사람과 내용이 어긋나지 않게 전송.
const fs = require("fs"), path = require("path");
const { chromium } = require("playwright");
const ROOT = path.join(__dirname, "..", "..");
@@ -33,89 +33,151 @@ function check(name, cond, extra) {
await p.waitForTimeout(200);
const state = function () {
return p.evaluate(function () {
const s = document.getElementById("vac-start"), e = document.getElementById("vac-end");
return { start: s.value, end: e.value, startShown: getComputedStyle(s).display !== "none", endShown: getComputedStyle(e).display !== "none",
btns: Array.from(document.querySelectorAll(".erp-date-btn")).map(function (b) { return b.textContent.replace("calendar_month", "").trim(); }),
want: [ErpDatePop.fmt(s.value), ErpDatePop.fmt(e.value)],
days: document.getElementById("vac-days-out").textContent, pop: !!document.querySelector(".pj-datepop") };
const v = function (id) { return document.getElementById(id).value; };
const shown = function (id) { return getComputedStyle(document.getElementById(id)).display !== "none"; };
return { start: v("vac-start"), end: v("vac-end"), startShow: v("vac-start-show"), endShow: v("vac-end-show"),
days: document.getElementById("vac-days-out").textContent, endField: shown("vac-end-field"), endHalf: shown("vac-end-half-field"),
startHalf: shown("vac-start-half-field"),
selected: Array.from(document.querySelectorAll("#vac-cal .pj-dp-day.is-selected")).map(function (b) { return b.dataset.iso; }),
band: Array.from(document.querySelectorAll("#vac-cal .pj-dp-day.is-band")).map(function (b) { return b.dataset.iso; }),
title: document.querySelector("#vac-cal .pj-dp-title").textContent };
});
};
// 달력은 오늘 달로 시작 — 테스트 날짜(2026-10)까지 옮긴다
const toMonth = async function (label) {
for (let i = 0; i < 60; i++) {
const t = (await state()).title;
if (t === label) return;
const [y, m] = t.match(/\d+/g).map(Number), [ty, tm] = label.match(/\d+/g).map(Number);
await p.click('#vac-cal .pj-dp-navbtn[data-nav="' + (y * 12 + m < ty * 12 + tm ? 1 : -1) + '"]');
}
};
const day = function (iso) { return p.click('#vac-cal .pj-dp-day[data-iso="' + iso + '"]'); };
// 휴가 종류 — 라디오, 고른 것만 검은 배경 + 흰 굵은 글씨
const look = function (value) {
return p.evaluate(function (val) {
const s = getComputedStyle(document.querySelector('input[name="vacation_type"][value="' + val + '"] + span'));
return [s.backgroundColor, s.color, s.fontWeight];
}, value);
};
const types = await p.evaluate(function () {
return Array.from(document.querySelectorAll('input[type="radio"][name="vacation_type"]')).map(function (r) { return r.value; });
});
check("휴가 종류 = 라디오(7가지), 드롭다운 없음", types.length === 7 && !(await p.$("select#vac-type")), types);
const on = await look("연차"), off = await look("병가");
check("고른 종류 = 검은 배경·흰 글씨·굵게, 나머지는 아님", on[0] === "rgb(0, 0, 0)" && on[1] === "rgb(255, 255, 255)" && +on[2] >= 700 && off[0] !== on[0], [on, off]);
const s0 = await state();
// 버튼 글자 = 프로젝트 날짜 버튼과 같은 규칙(오늘·내일·어제, 아니면 mm/dd(요일)) — 오늘 날짜에 따라 달라서 같은 함수로 비교
const fmtCheck = await p.evaluate(function () {
return [ErpDatePop.fmt("2026-10-29"), ErpDatePop.fmt("2027-01-04")];
check("처음엔 날짜 없음·브라우저 달력 없음", s0.start === "" && s0.end === "" && s0.selected.length === 0 && !(await p.$('input[type="date"]')), s0);
await p.waitForSelector('#vac-cal .pj-dp-grid');
await toMonth("2026년 10월");
const cal = await p.evaluate(function () {
const hol = document.querySelector('#vac-cal .pj-dp-day[data-iso="2026-10-09"]');
const box = document.getElementById("vac-cal").getBoundingClientRect(), side = document.querySelector(".vac-form-side").getBoundingClientRect();
return { hol: hol.classList.contains("is-sun") && hol.textContent, sat: document.querySelector('#vac-cal .pj-dp-day[data-iso="2026-10-24"]').classList.contains("is-sat"), left: box.right <= side.left };
});
check("기본 달력 input 숨김 · 날짜 버튼 두 개(시작·종료)", !s0.startShown && !s0.endShown && s0.btns.length === 2 &&
JSON.stringify(s0.btns) === JSON.stringify(s0.want) && s0.want[0] !== "", s0);
check("날짜 글자 mm/dd(요일), 다른 해는 연도", ["10/29(목)", "오늘", "내일", "어제"].indexOf(fmtCheck[0]) >= 0 &&
["2027/01/04(월)", "01/04(월)"].indexOf(fmtCheck[1]) >= 0, fmtCheck);
// 시작일 버튼 → 기간 팝업(시작일 칸 활성)
await p.click('.erp-date-btn[data-kind="start"]');
const pop = await p.evaluate(function () {
const el = document.querySelector(".pj-datepop");
const f = Array.from(el.querySelectorAll(".pj-dp-field")).map(function (x) { return [x.placeholder, x.value, x.classList.contains("is-active")]; });
const hol = el.querySelector('.pj-dp-day[data-iso="2026-10-09"]');
return { fields: f, title: el.querySelector(".pj-dp-title").textContent, hol: hol && hol.classList.contains("is-sun") && hol.textContent,
clear: !!el.querySelector(".pj-dp-clear"), parent: el.parentElement === document.body,
sat: document.querySelector('.pj-dp-day[data-iso="2026-10-24"]').classList.contains("is-sat") };
check("공용 달력 서식 — 공휴일 빨강·이름, 토 파랑, 달력은 왼쪽", cal.hol === "9한글날" && cal.sat && cal.left, cal);
const holName = await p.evaluate(function () {
const h = document.querySelector('#vac-cal .pj-dp-day[data-iso="2026-10-01"] .pj-dp-hol');
return { text: h.textContent, size: parseFloat(getComputedStyle(h).fontSize), clipped: h.scrollWidth > h.clientWidth };
});
check("시작일 버튼 → 기간 팝업(시작일·종료일 칸, 시작일 활성, body 에, 지우기 없음)", pop.parent && !pop.clear &&
JSON.stringify(pop.fields) === '[["시작일","10월 27일",true],["종료일","10월 27일",false]]' && pop.title === "2026년 10월", pop);
check("공휴일 빨강 + 이름(한글날), 토요일 파랑", pop.hol === "9한글날" && pop.sat, pop);
// 시작일 10/29 → 종료일(10/27)이 더 빨라 10/29 로 맞춤, 종료일 칸으로 넘어감(팝업 그대로)
await p.click('.pj-dp-day[data-iso="2026-10-29"]');
check("공휴일 이름 10.5px, 가장 긴 이름(석가탄신일)도 안 잘림", holName.text === "석가탄신일" && holName.size === 10.5 && !holName.clipped, holName);
// 하루 = 동그라미, 시작·종료 칸 자동, 종료 구분은 숨김(하루는 시작 구분만)
await day("2026-10-20");
const s1 = await state();
const act = await p.evaluate(function () { const a = document.querySelector(".pj-dp-field.is-active"); return a && a.dataset.kind; });
check("시작일 고름 → 시작·종료 10/29, 팝업은 열린 채 종료일 칸으로", s1.start === "2026-10-29" && s1.end === "2026-10-29" && s1.pop && act === "due", [s1, act]);
await p.click('.pj-dp-day[data-iso="2026-11-02"]');
await p.waitForTimeout(50);
check("첫 클릭 → 시작=종료, 동그라미, 오른쪽 칸 자동", s1.start === "2026-10-20" && s1.end === "2026-10-20" && s1.startShow === "2026.10.20(화)" &&
s1.endShow === "2026.10.20(화)" && JSON.stringify(s1.selected) === '["2026-10-20"]' && s1.band.length === 0 && s1.days === "1" && !s1.endHalf, s1);
// 기간 = 둥근 막대(주가 바뀌어도), 양 끝 원
await day("2026-10-27");
const s2 = await state();
check("종료일 고름 → 11/02, 팝업 닫힘, 버튼 글자·예상 일수(주말 빼고 3)", s2.end === "2026-11-02" && !s2.pop &&
s2.btns[1] === s2.want[1] && s2.days === "3", s2);
// 종료일 버튼 → 종료일 칸이 먼저, 기간 칸 옅은 파랑
await p.click('.erp-date-btn[data-kind="due"]');
const pop2 = await p.evaluate(function () {
const a = document.querySelector(".pj-dp-field.is-active");
return { active: a && a.dataset.kind, inrange: document.querySelectorAll(".pj-dp-day.is-inrange").length,
selected: Array.from(document.querySelectorAll(".pj-dp-day.is-selected")).map(function (b) { return b.dataset.iso; }) };
check("둘째 클릭 → 종료일, 기간 전체 막대, 양 끝 선택, 일수 6", s2.end === "2026-10-27" && s2.endShow === "2026.10.27(화)" && s2.band.length === 8 &&
JSON.stringify(s2.selected) === '["2026-10-20","2026-10-27"]' && s2.days === "6" && s2.endHalf, s2);
const bar = await p.evaluate(function () {
const st = function (iso) {
const c = getComputedStyle(document.querySelector('#vac-cal .pj-dp-day[data-iso="' + iso + '"]'), "::after");
return { bg: c.backgroundColor, h: c.height, r: c.borderTopRightRadius, l: c.borderTopLeftRadius };
};
return { mid: st("2026-10-22"), sat: st("2026-10-24"), sun: st("2026-10-25") };
});
// 종료일 달(11월)이 보인다 — 11/1 이 일요일이라 10월 날짜는 이 달력에 없음: 기간 = 11/1, 선택 = 11/2
check("종료일 버튼 → 종료일 칸 활성·종료일 달, 기간 표시", pop2.active === "due" && pop2.inrange === 1 &&
JSON.stringify(pop2.selected) === '["2026-11-02"]', pop2);
// 예상 일수는 휴가 설정 공휴일도 뺀다 — 10/8~10/12 = 8·9(한글날)·10·11(주말)·12 → 2일
await p.click('.erp-date-btn[data-kind="start"]');
await p.fill('.pj-dp-field[data-kind="start"]', "10/8");
await p.press('.pj-dp-field[data-kind="start"]', "Enter");
await p.fill('.pj-dp-field[data-kind="due"]', "10/12");
await p.press('.pj-dp-field[data-kind="due"]', "Enter");
const sh = await state();
check("예상 일수 = 주말·공휴일(한글날) 빼고 2", sh.start === "2026-10-08" && sh.end === "2026-10-12" && sh.days === "2", sh);
await p.click('.erp-date-btn[data-kind="due"]');
// 직접 입력 — 종료일 칸에 11/3 Enter
await p.fill('.pj-dp-field[data-kind="due"]', "11/3");
await p.press('.pj-dp-field[data-kind="due"]', "Enter");
check("막대 색칠, 줄 끝·줄 처음은 둥글게", bar.mid.bg !== "rgba(0, 0, 0, 0)" && bar.mid.h === "30px" && parseInt(bar.sat.r) === 15 && parseInt(bar.sun.l) === 15, bar);
// 셋째 클릭 = 새로 시작, 시작일보다 앞을 누르면 새 시작일
await day("2026-10-08");
await day("2026-10-06");
const s3 = await state();
check("직접 입력 11/3 Enter → 종료일 11/03, 닫힘", s3.end === "2026-11-03" && !s3.pop, s3);
// Esc 로 닫기
await p.click('.erp-date-btn[data-kind="start"]');
await p.waitForTimeout(50);
await p.keyboard.press("Escape");
check("Esc → 닫힘", !(await state()).pop);
// 반차 — 종료일 칸 숨김, 날짜 버튼 하나로 하루짜리 팝업(시작=종료)
await p.selectOption("#vac-type", "오전반차");
await p.click('.erp-date-btn[data-kind="start"]');
const half = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".pj-dp-field")).map(function (x) { return x.placeholder; });
});
await p.click('.pj-dp-day[data-iso="2026-11-05"]');
check("다시 고르기 — 새 시작, 앞날 클릭은 시작일로", s3.start === "2026-10-06" && s3.end === "2026-10-06", s3);
await day("2026-10-12");
check("일수에서 주말·공휴일(한글날) 뺌", (await state()).days === "4", await state());
// 달을 넘어가도 기간 유지
await p.click('#vac-cal .pj-dp-navbtn[data-nav="1"]');
check("달을 옮겨도 값 유지", (await state()).start === "2026-10-06");
await p.click('#vac-cal .pj-dp-navbtn[data-nav="-1"]');
// 반차 — 하루로 줄고 칸 숨김, 클릭마다 하루
await p.click('label.vac-type:has(input[value="오전반차"])');
const s4 = await state();
check("반차 → 날짜 칸 하나 팝업, 고르면 시작=종료=11/05, 0.5일", JSON.stringify(half) === '["날짜"]' &&
s4.start === "2026-11-05" && s4.end === "2026-11-05" && !s4.pop && s4.days === "0.5", [half, s4]);
// 제출 — 고른 날짜가 그대로 폼으로
await p.selectOption("#vac-type", "연차");
check("반차 선택 → 시작일 하루로, 종료·구분 칸 숨김, 0.5일", s4.end === "2026-10-06" && !s4.endField && !s4.startHalf && s4.days === "0.5", s4);
await day("2026-10-14"); await day("2026-10-15");
const s5 = await state();
check("반차 — 클릭마다 하루", s5.start === "2026-10-15" && s5.end === "2026-10-15" && s5.band.length === 0, s5);
await p.click('label.vac-type:has(input[value="연차"])');
// 결재 라인 — 통보자·결재자는 아이콘 + 이름(고칠 칸 없음)
const line = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".vac-line-row")).map(function (r) { return r.textContent.replace(/\s+/g, " ").trim(); });
});
check("통보자·결재자 = 옵션 값 표시만", line[1] === "통보자 EEllen" && line[2] === "결재자 RRJ", line);
const vis = function (sel) { return p.evaluate(function (s) { const e = document.querySelector(s); return !!e && e.offsetParent !== null; }, sel); };
check("협의자 전달 사항 칸은 처음엔 없음", !(await vis("#vac-consult-box")));
// 제출 검사 — 협의자도 협의자 없음도 없으면 막힘
await p.click('button[name="action"][value="submit"]');
await p.waitForTimeout(80);
const err = await p.textContent("#vac-form-err");
check("협의자 미지정 제출 → 안내, 전송 안 됨", /협의자를 고르거나/.test(err) && posts.length === 0, [err, posts]);
// 구성원 선택 → 아이콘 + 이름 목록, 복수 선택, 사람마다 내용 칸
await p.click("#vac-pick-btn");
check("구성원 선택 → 목록(아이콘 + 이름)", await vis("#vac-pick") && (await p.$$("#vac-pick .vac-opt-face")).length === 3);
await p.check('#vac-pick input[data-email="park@test.local"]');
await p.check('#vac-pick input[data-email="choi@test.local"]');
const rows = await p.evaluate(function () {
return Array.from(document.querySelectorAll(".vac-consult-row")).filter(function (r) { return !r.hidden; }).map(function (r) { return r.dataset.email; });
});
check("고른 사람마다 협의 내용 칸", await vis("#vac-consult-box") && JSON.stringify(rows.sort()) === '["choi@test.local","park@test.local"]', rows);
await p.click(".vac-line h3"); // 바깥 클릭 — 목록 닫힘
check("바깥을 누르면 목록 닫힘", !(await vis("#vac-pick")));
await p.fill('.vac-consult-row[data-email="choi@test.local"] textarea', "최대리에게 부탁");
// 협의자 없음 — 잠그면 칸이 사라지고 전송되지 않음, 풀면 내용 복구
await p.check("#vac-no-consult");
const locked = await p.evaluate(function () {
return { btn: document.getElementById("vac-pick-btn").disabled, sent: new FormData(document.getElementById("vac-form")).getAll("consult_email").length };
});
check("협의자 없음 → 선택 잠금·칸 숨김·전송 안 함", locked.btn && locked.sent === 0 && !(await vis("#vac-consult-box")), locked);
await p.uncheck("#vac-no-consult");
check("협의자 없음 해제 → 쓰던 내용 그대로", (await p.inputValue('.vac-consult-row[data-email="choi@test.local"] textarea')) === "최대리에게 부탁");
// ✕ 로 빼기
await p.click('.vac-consult-row[data-email="park@test.local"] .vac-consult-x');
check("✕ → 그 사람 빠짐, 선택 목록도 해제", !(await vis('.vac-consult-row[data-email="park@test.local"]')) &&
!(await p.isChecked('#vac-pick input[data-email="park@test.local"]', { strict: false })));
await p.click("#vac-pick-btn");
await p.check('#vac-pick input[data-email="lee@test.local"]');
await p.click(".vac-line h3");
// 제출 — 사람과 내용이 같은 순서로(빈 내용 포함)
await p.fill('textarea[name="reason"]', "가족 행사");
await p.click('button[name="action"][value="submit"]');
await p.waitForTimeout(200);
check("제출 → start_date·end_date 가 고른 날짜로 전송", posts.length === 1 && /start_date=2026-11-05/.test(posts[0]) && /end_date=2026-11-05/.test(posts[0]), posts);
const q = new URLSearchParams(posts[0] || "");
check("제출 → 날짜·종류·협의자·내용 전송(어긋나지 않음)", posts.length === 1 && q.get("start_date") === "2026-10-15" && q.get("end_date") === "2026-10-15" &&
q.get("vacation_type") === "연차" && JSON.stringify(q.getAll("consult_email")) === '["lee@test.local","choi@test.local"]' &&
JSON.stringify(q.getAll("consult_message")) === '["","최대리에게 부탁"]' && !q.get("no_consult"), posts);
} finally {
await browser.close();
}
+50 -1
View File
@@ -197,9 +197,23 @@ class InoutDbTests(unittest.TestCase):
self.st.add_receipt_photos(o["id"], rid, [("e.jpg", jpeg)], by="w@x")
with self.assertRaisesRegex(ValueError, "찾을 수 없"):
self.st.add_receipt_photos(o["id"], 999999, [("e.jpg", jpeg)], by="w@x")
o2 = self.order([("MT-Q", 1)])
# 돌리기(2026-11-02) — 저장된 내용·크기가 바뀌고, 다른 발주서 id 로는 못 돌린다(내용이 가짜 JPEG 이면 원본 그대로)
with self.assertRaisesRegex(ValueError, "찾을 수 없"):
self.st.rotate_receipt_photo(o2["id"], ph[1]["id"], 90)
from io import BytesIO
from PIL import Image
buf = BytesIO()
Image.new("RGB", (40, 20), (255, 0, 0)).save(buf, format="JPEG")
with self.st._pool.connection() as conn:
conn.execute("UPDATE inout_receipt_photos SET data=%s WHERE id=%s", (buf.getvalue(), ph[1]["id"]))
self.st.rotate_receipt_photo(o["id"], ph[1]["id"], 90)
turned = self.st.get_photo(ph[1]["id"])
self.assertEqual(Image.open(BytesIO(bytes(turned["data"]))).size, (20, 40))
self.st.delete_receipt_photo(o["id"], ph[0]["id"])
self.assertIsNone(self.st.get_photo(ph[0]["id"]))
o2 = self.order([("MT-Q", 1)])
with self.assertRaisesRegex(ValueError, "찾을 수 없"): # 다른 발주서의 사진 id 로는 못 지운다
self.st.delete_receipt_photo(o2["id"], ph[1]["id"])
self.st.delete_receipt(o["id"], rid, by="w@x") # 입고를 지우면 사진도 함께
@@ -335,6 +349,41 @@ class InoutDbTests(unittest.TestCase):
pass
self.assertEqual(self.st.catalog_count(), before)
def test_bag_pallet(self):
"""008 — 봉투·백: 이름으로 구분, 박스당 수량·1파렛트당 박스 저장, 뚜껑 값은 지움, 일반 상품 값은 그대로."""
from app.modules.inout import store
if not self.st.bags_ready():
self.skipTest("inout_db 008 미적용")
self.assertTrue(store.is_bag("미라클 봉투 대") and store.is_bag("새 미라클백 20L"))
self.assertFalse(store.is_bag("미라클 통") or store.is_bag(None))
self.assertEqual(store.validate_bag_values({"body_per_box": "1,000", "boxes_per_pallet": "40"}),
{"body_per_box": 1000, "lid_per_box": None, "boxes_per_pallet": 40})
for bad in ("0", "1.5", "abc"):
with self.assertRaises(ValueError):
store.validate_bag_values({"boxes_per_pallet": bad})
T = self.tag.upper()
A, B = f"ZP-{T}-A", f"ZP-{T}-B"
before = self.st.catalog_count()
try:
self.st.import_products([{"code": A, "name": "미라클 봉투 대"}, {"code": B, "name": "일반 통"}], by="b@x")
empty = {"unit_price": None, "weight_g": None, "silver_pct": None}
self.st.save_products([{"code": A, **empty, "body_per_box": 100, "lid_per_box": 50},
{"code": B, **empty, "body_per_box": 120, "lid_per_box": 500}], by="b@x")
self.st.save_products([{"code": A, **empty, **store.validate_bag_values({"body_per_box": "1,000", "boxes_per_pallet": "40"})}], by="b@x")
got = self.st.catalog_lookup([A, B])
self.assertEqual((got[A]["body_per_box"], got[A]["lid_per_box"], got[A]["boxes_per_pallet"]), (1000, None, 40))
self.assertEqual(store.box_info(got[A]), {"body_per_box": 1000, "lid_per_box": None, "is_bag": True, "boxes_per_pallet": 40})
self.assertEqual(store.box_info(got[B]), {"body_per_box": 120, "lid_per_box": 500, "is_bag": False, "boxes_per_pallet": None})
self.assertFalse(store.box_info({"item_name": "미라클백", "body_per_box": 10})["is_bag"]) # 008 미적용(열 없음) = 일반 상품
finally:
for code in (A, B):
try:
self.st.exclude_product(code, by="cleanup@x")
except ValueError:
pass
self.assertEqual(self.st.catalog_count(), before)
def test_box_quantities(self):
"""007 — 통·뚜껑 박스 입수(뚜껑 없음 = 빈칸), 검사, 목록·검색·조회에 나오고, 넣은 상품은 다시 불러와도 그대로."""
from app.modules.inout import store
+108
View File
@@ -2,6 +2,7 @@
import base64
import email
import json
import re
import unittest
from datetime import date
from email import policy
@@ -25,6 +26,69 @@ def _order(**over):
return o
class RotateTests(unittest.TestCase):
"""입고증 사진 돌리기(2026-11-02) — 시계 방향·형식 유지·EXIF 반영."""
@staticmethod
def _image(fmt, size=(40, 20), **save):
from io import BytesIO
from PIL import Image
im = Image.new("RGB", size, (255, 0, 0))
im.paste((0, 0, 255), (0, 0, size[0] // 2, size[1] // 2)) # 왼쪽 위만 파랑
buf = BytesIO()
im.save(buf, format=fmt, **save)
return buf.getvalue()
@staticmethod
def _open(data):
from io import BytesIO
from PIL import Image
return Image.open(BytesIO(data))
def test_right_and_left_turn_corner_the_right_way(self):
right = self._open(s.rotate_image(self._image("PNG"), 90))
self.assertEqual(right.size, (20, 40))
self.assertEqual(right.convert("RGB").getpixel((19, 0)), (0, 0, 255)) # 왼쪽 위 → 시계 방향이면 오른쪽 위
left = self._open(s.rotate_image(self._image("PNG"), 270))
self.assertEqual(left.convert("RGB").getpixel((0, 39)), (0, 0, 255)) # 반시계면 왼쪽 아래
def test_keeps_format(self):
for fmt, kind in (("JPEG", "image/jpeg"), ("PNG", "image/png"), ("WEBP", "image/webp"), ("GIF", "image/gif")):
with self.subTest(fmt=fmt):
out = s.rotate_image(self._image(fmt), 90)
self.assertEqual(s.sniff_image(out), kind)
self.assertEqual(self._open(out).size, (20, 40))
def test_phone_exif_is_applied_then_dropped(self):
"""휴대폰 사진(EXIF 회전 6 = 화면에선 세로) — 돌린 결과는 화면에 보이던 모습 기준이어야 하고 EXIF 회전이 남으면 안 된다."""
from PIL import Image
exif = Image.Exif()
exif[0x0112] = 6
out = self._open(s.rotate_image(self._image("JPEG", exif=exif.tobytes()), 90))
self.assertEqual(out.size, (40, 20)) # 화면 20×40 → 오른쪽으로 돌려 40×20
self.assertNotEqual(out.getexif().get(0x0112), 6)
def test_refuses_what_cannot_be_turned(self):
for bad, msg in ((b"....ftypheic" + b"0" * 20, "HEIC"), (JPEG, "돌릴 수 없")):
with self.subTest(msg=msg), self.assertRaisesRegex(ValueError, msg):
s.rotate_image(bad, 90)
with self.assertRaisesRegex(ValueError, "왼쪽·오른쪽"):
s.rotate_image(self._image("PNG"), 45)
from io import BytesIO
from PIL import Image
buf = BytesIO()
Image.new("RGB", (4, 4), (255, 0, 0)).save(buf, format="GIF", save_all=True, append_images=[Image.new("RGB", (4, 4), (0, 0, 255))])
with self.assertRaisesRegex(ValueError, "움직이는"):
s.rotate_image(buf.getvalue(), 90)
class MailContentTests(unittest.TestCase):
def test_parse_emails(self):
self.assertEqual(s.parse_emails("a@x.com, B@y.co.kr; a@X.com\nc@z.kr"), ["a@x.com", "B@y.co.kr", "c@z.kr"])
@@ -55,6 +119,50 @@ class MailContentTests(unittest.TestCase):
self.assertTrue(m2["text"].startswith("안녕하세요."))
self.assertNotIn("요청 사항", m2["text"])
def test_order_mail_simple_factories(self):
"""대성화학·인천공장 — 표는 번호·제품 코드·제품명·수량·박스당 수량·박스 수·비고만, 단가·금액·무게·은은 어디에도 없음. 다른 공장은 그대로."""
from decimal import Decimal as D
priced = [{"item_code": "MT-0320", "item_name": "통", "qty": 100, "memo": "흰색", "unit_price": D("7777"),
"weight_g": D("50"), "silver_pct": D("3")}]
for name in ("대성화학", "(주)대성화학", "인천공장", "인천 공장"):
with self.subTest(name=name):
m = s.order_mail(_order(factory_name=name, lines=priced), sender_name="K", sender_email="k@x.com")
head = m["html"][m["html"].index("<thead>"):m["html"].index("</thead>")]
self.assertEqual(re.findall(r"<th[^>]*>([^<]*)</th>", head), ["번호", "제품 코드", "제품명", "수량", "박스당 수량", "박스 수", "비고"])
row = m["html"][m["html"].index("<tbody>"):m["html"].index("</tbody>")]
self.assertEqual(row.count("<td"), 7)
self.assertEqual(m["html"][m["html"].index("<tfoot>"):].count("<th"), 5) # 합계(3칸 합침)·수량·박스당 빈칸·박스·비고
for part in (m["html"], m["text"]):
self.assertNotRegex(part, "단가|금액|무게|PP|은\\(|7,777|777,700")
self.assertIn("1. MT-0320 통 — 100개 (흰색)", m["text"])
self.assertIn("발주번호", m["html"])
other = s.order_mail(_order(lines=[dict(priced[0], body_per_box=30)]), sender_name="K", sender_email="k@x.com")
for part in ("단가(원)", "금액(원)", "전체 무게(kg)", "PP 사용량(kg)", "은(Ag) 함유량", "7,777"):
self.assertIn(part, other["html"])
self.assertIn(">No</th>", other["html"])
self.assertIn("단가 7,777", other["text"])
self.assertNotIn("박스", other["html"].replace("박스당 24개", "")) # 다른 공장엔 박스 칸 없음(요청 사항 글 제외)
def test_order_mail_simple_boxes(self):
"""박스당 수량·박스 수(올림) — 뚜껑 있으면 통·뚜껑 따로, 입수 없으면 '-', 합계는 있는 줄만."""
self.assertEqual(s.line_boxes({"qty": 100, "body_per_box": 30}), {"per": "30개", "count": "4박스", "total": 4})
self.assertEqual(s.line_boxes({"qty": 90, "body_per_box": 30})["total"], 3)
self.assertEqual(s.line_boxes({"qty": 1000, "body_per_box": 120, "lid_per_box": 500}),
{"per": "통 120개 · 뚜껑 500개", "count": "통 9 · 뚜껑 2박스", "total": 11})
self.assertEqual(s.line_boxes({"qty": 5}), {"per": "-", "count": "-", "total": None})
lines = [{"item_code": "A", "item_name": "봉투", "qty": 2600, "memo": "", "body_per_box": 100, "lid_per_box": None},
{"item_code": "B", "item_name": "통", "qty": 1000, "memo": "흰색", "body_per_box": 120, "lid_per_box": 500},
{"item_code": "C", "item_name": "없음", "qty": 5, "memo": ""}]
m = s.order_mail(_order(factory_name="대성화학", memo="", lines=lines), sender_name="K", sender_email="k@x.com")
self.assertIn(">100개</td>", m["html"])
self.assertIn(">26박스</td>", m["html"])
self.assertIn("통 9 · 뚜껑 2박스", m["html"])
self.assertIn("37박스 (미설정 1종 제외)", m["html"])
self.assertIn("1. A 봉투 — 2,600개 · 박스당 100개 · 26박스", m["text"])
self.assertIn("2. B 통 — 1,000개 · 박스당 통 120개 · 뚜껑 500개 · 통 9 · 뚜껑 2박스 (흰색)", m["text"])
self.assertIn("3. C 없음 — 5개", m["text"])
def test_build_message_utf8_and_alternative(self):
raw = gmail.build_message(sender_name="킹", sender_email="king@dbxcorp.co.kr", to=["a@x.com", "b@y.com"], cc=["c@z.com"],
subject="[발주] 테스트 · 한글", text="본문", html="<p>본문</p>")
+4
View File
@@ -126,6 +126,10 @@ class ProductValueTests(unittest.TestCase):
self.assertEqual((t["amount"], t["missing_price"], t["pp_kg"], t["silver_g"]), (D("8550.00"), 1, D("2.45"), D("12.25")))
empty = s.order_totals([{"qty": 5}]) # 004 전 발주서(값 칸 없음)
self.assertEqual((empty["amount"], empty["missing_price"], empty["pp_kg"], empty["silver_g"]), (None, 1, None, None))
# 봉투·백은 단가가 원래 없음 — "단가 미입력" 안내에 안 잡힘
bag = {"qty": 5, "unit_price": None, "item_name": "미라클백 2.5L"}
self.assertEqual(s.order_totals([bag])["missing_price"], 0)
self.assertEqual(s.order_totals([bag, {"qty": 5, "unit_price": None, "item_name": "통"}])["missing_price"], 1)
def test_parse_and_validate(self):
from decimal import Decimal as D
+136
View File
@@ -225,6 +225,12 @@ def body(c):
img = c.get("/inout/photos/%d" % pids[0])
assert img.status_code == 200 and img.content == JPEG and img.headers["content-type"] == "image/jpeg"
assert img.headers["x-content-type-options"] == "nosniff" and "sandbox" in img.headers["content-security-policy"]
# 돌린 사진이 캐시에 남지 않게 — 매번 확인(no-cache + ETag), 같으면 304
assert "no-cache" in img.headers["cache-control"] and img.headers["etag"]
assert c.get("/inout/photos/%d" % pids[0], headers={"If-None-Match": img.headers["etag"]}).status_code == 304
# 내용이 가짜 JPEG 이면 원본 그대로, 안내만(400)
r = c.post("/inout/orders/%d/photos/%d/rotate?degrees=90" % (oid3, pids[0]))
assert r.status_code == 400 and r.json()["error"] and c.get("/inout/photos/%d" % pids[0]).content == JPEG, r.text
page = c.get("/inout/orders/%d" % oid3).text
assert 'data-photo="%d"' % pids[0] in page and 'src="/inout/photos/%d"' % pids[0] in page
rid3 = got["receipts"][0]["id"]
@@ -234,6 +240,7 @@ def body(c):
who["u"] = viewer
assert c.get("/inout/photos/%d" % pids[0]).status_code == 200 # 모듈 권한이면 보기는 됨
assert c.post("/inout/orders/%d/photos/%d/delete" % (oid3, pids[0])).status_code == 403
assert c.post("/inout/orders/%d/photos/%d/rotate?degrees=90" % (oid3, pids[0])).status_code == 403
who["u"] = U("nobody-%s@t.local" % tag, inout=False)
assert c.get("/inout/photos/%d" % pids[0]).status_code == 403
who["u"] = wh
@@ -405,6 +412,135 @@ run(body)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
def test_bag_products_separated(self):
"""008 — 옵션: 봉투·백 표가 따로(칸 다름), 저장·발주서 제품 검색·발주서 화면에 값이 나온다."""
res = _run('''
import uuid
from app.modules.inout.db import InoutDBStore
st = InoutDBStore(__import__("os").environ["INOUT_TEST_DB_URL"])
main.app.state.inout_store = st
main.app.state.inout_items = Items()
tag = uuid.uuid4().hex[:6].upper()
admin = U("admin-%s@t.local" % tag.lower(), role="admin")
users.append(admin)
BAG, BOX = "ZG-%s-A" % tag, "ZG-%s-B" % tag
def body(c):
who["u"] = admin
st.import_products([{"code": BAG, "name": "미라클백 " + tag}, {"code": BOX, "name": "통 " + tag}], by=admin["email"])
try:
panel = c.get("/inout/settings?panel=1").text
assert panel.count('class="io-prod-part"') == 2 and "1파렛트당 박스 수량</th>" in panel
bag_row = panel[panel.index('data-code="%s"' % BAG):]
bag_row = bag_row[:bag_row.index("</tr>")]
box_row = panel[panel.index('data-code="%s"' % BOX):]
box_row = box_row[:box_row.index("</tr>")]
assert 'data-key="boxes_per_pallet"' in bag_row and 'data-key="lid_per_box"' not in bag_row
assert 'data-key="boxes_per_pallet"' not in box_row and 'data-key="lid_per_box"' in box_row
assert panel.index('data-code="%s"' % BAG) < panel.index("일반 상품") < panel.index('data-code="%s"' % BOX)
# 봉투·백 표엔 단가·무게·은 칸이 없다(일반 상품 표에만) — 전에 넣은 값은 숨은 칸으로 남아 저장해도 안 지워짐
assert panel.count("단가(원)</th>") == 1 and panel.count("은(g/개)</th>") == 1
assert 'class="io-ag"' not in bag_row and 'io-ag' not in bag_row and 'io-in-num" data-key="unit_price"' not in bag_row
assert 'io-in-num" data-key="unit_price"' in box_row
r = c.post("/inout/settings/products/save", headers={"X-Inout-Options": "1"}, json={"rows": [
{"code": BAG, "unit_price": "1500", "weight_g": "", "silver_pct": "", "body_per_box": "1,000", "boxes_per_pallet": "40"}]})
assert r.status_code == 200 and r.json()["ok"], r.text
assert 'type="hidden" data-key="unit_price" value="1,500"' in c.get("/inout/settings?panel=1").text
item = c.get("/inout/api/items?q=" + BAG).json()["items"][0]
assert (item["is_bag"], item["body_per_box"], item["lid_per_box"], item["boxes_per_pallet"]) == (True, 1000, None, 40)
r = c.post("/inout/settings/products/save", headers={"X-Inout-Options": "1"}, json={"rows": [
{"code": BAG, "unit_price": "", "weight_g": "", "silver_pct": "", "body_per_box": "1", "boxes_per_pallet": "0"}]})
assert r.json()["ok"] is False and "1파렛트당 박스 수량" in r.json()["message"], r.text
form = c.post("/inout/orders/new", data={"factory_id": "", "order_date": "2026-11-04", "item_code": [BAG],
"item_name": [""], "qty": ["500"], "line_memo": [""]}).text
assert 'data-body-box="1000" data-lid-box="" data-bag="1" data-pallet-box="40"' in form, form[:300]
assert 'id="io-pallet-bag"' in form
finally:
for code in (BAG, BOX):
st.exclude_product(code, by=admin["email"])
print("OK")
run(body)
''', {"INOUT_TEST_DB_URL": DSN})
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
def test_simple_factory_mail_shows_boxes(self):
"""대성화학 메일 미리보기 — 상품 정보의 박스 입수로 박스 칸이 차고 단가는 없음. 다른 공장은 예전 표."""
res = _run('''
import re, uuid
from app.modules.inout.db import InoutDBStore
st = InoutDBStore(__import__("os").environ["INOUT_TEST_DB_URL"])
main.app.state.inout_store = st
main.app.state.inout_items = Items()
tag = uuid.uuid4().hex[:6].upper()
admin = U("admin-%s@t.local" % tag.lower(), role="admin")
users.append(admin)
CODE = "ZS-%s-A" % tag
def order_for(c, factory):
c.post("/inout/settings/factories", data={"name": factory, "is_active": "1"}, headers={"X-Inout-Options": "1"})
fid = next(f["id"] for f in st.list_factories() if f["name"] == factory)
r = c.post("/inout/orders/new", data={"factory_id": fid, "order_date": "2026-11-04", "item_code": [CODE],
"item_name": [""], "qty": ["100"], "line_memo": [""]}, follow_redirects=False)
return int(re.search(r"/inout/orders/(\\d+)", r.headers["location"]).group(1))
def body(c):
who["u"] = admin
st.import_products([{"code": CODE, "name": "통 " + tag}], by=admin["email"])
try:
r = c.post("/inout/settings/products/save", headers={"X-Inout-Options": "1"}, json={"rows": [
{"code": CODE, "unit_price": "7777", "weight_g": "", "silver_pct": "", "body_per_box": "30", "lid_per_box": ""}]})
assert r.json()["ok"], r.text
html = c.get("/inout/orders/%d/mail" % order_for(c, "대성화학-" + tag)).json()["html"]
assert "박스당 수량" in html and ">30개</td>" in html and ">4박스</td>" in html, html
assert "단가" not in html and "7,777" not in html
html = c.get("/inout/orders/%d/mail" % order_for(c, "보통공장-" + tag)).json()["html"]
assert "박스당 수량" not in html and "7,777" in html
finally:
st.exclude_product(CODE, by=admin["email"])
print("OK")
run(body)
''', {"INOUT_TEST_DB_URL": DSN})
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
def test_list_status_remembered_per_user(self):
"""발주 목록 상태 보기 — 사람마다 따로 기억, 처음은 진행 중, 틀린 값은 저장 안 함."""
res = _run('''
import uuid
from app.modules.inout.db import InoutDBStore
st = InoutDBStore(__import__("os").environ["INOUT_TEST_DB_URL"])
main.app.state.inout_store = st
main.app.state.inout_items = Items()
tag = uuid.uuid4().hex[:6]
a, b = U("a-%s@t.local" % tag), U("b-%s@t.local" % tag)
users.extend([a, b])
def shown(c, url="/inout/"):
page = c.get(url).text
return next(k for k in ("active", "done", "closed", "all") if 'name="status" value="%s"' % k in page)
def body(c):
who["u"] = a
assert shown(c) == "active" # 처음은 진행 중
assert shown(c, "/inout/?status=closed") == "closed"
assert shown(c) == "closed" # 다음 접속에도 그대로
who["u"] = b
assert shown(c) == "active" # 다른 사람 선택은 영향 없음
assert shown(c, "/inout/?status=all") == "all"
who["u"] = a
assert shown(c) == "closed" # b 가 바꿔도 a 는 그대로
assert shown(c, "/inout/?status=nope") == "closed" and shown(c) == "closed"
assert st.get_settings().keys().isdisjoint({"list_status:" + a["email"]}) # 모듈 설정에 섞이지 않음
print("OK")
run(body)
''', {"INOUT_TEST_DB_URL": DSN})
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
def test_super_admin_deletes_order(self):
"""발주 목록 🗑 — 수퍼관리자만(ERP 관리자·발주 담당은 403·버튼 없음), 지운 뒤 보던 목록으로."""
+423
View File
@@ -0,0 +1,423 @@
"""라이브 커머스(live, 2026-11-04).
1) store — 호스트·방송 입력 검사, 판매금액, 달 범위, 표시 형식, 작은 그림.
2) 실제 앱(격리된 하위 프로세스) — 메뉴·권한 칩·"설정 필요" 안내(DB 없이 늘 실행).
3) 전체 흐름(LIVE_TEST_DB_URL 이 localhost 일 때만) — 호스트 등록·권한·스케줄·이미지·지우기.
"""
import io
import os
import re
import subprocess
import sys
import tempfile
import unittest
from datetime import date, time
from decimal import Decimal
from pathlib import Path
from urllib.parse import urlparse
from PIL import Image
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from app.modules.live import i18n, store # noqa: E402
DSN = os.getenv("LIVE_TEST_DB_URL", "")
DB_ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
PRELUDE = '''
from unittest.mock import patch
from fastapi.testclient import TestClient
import app.main as main
def U(email, role="user", live=True):
return {"email": email, "name": email.split("@")[0], "role": role, "is_super_admin": False, "modules": {"live": live}}
who = {"u": None}
def run(body):
with patch.object(main, "get_current_user_record", side_effect=lambda r: who["u"]), \\
patch.object(main, "get_session_user", side_effect=lambda r: who["u"]), \\
patch.object(main.user_store, "get", side_effect=lambda e: who["u"]), \\
patch.object(main.user_store, "list_all", side_effect=lambda: [who["u"]]):
body(TestClient(main.app))
'''
def _run(code: str, extra_env: dict[str, str] | None = None) -> subprocess.CompletedProcess:
env = dict(os.environ)
for key in ("ASSET", "CAFE24", "CUPANG", "VACATION", "PROJECT", "DISPATCH", "PERFORMANCE", "MALAYSIA_STOCK",
"ITEMCODE", "EXPENSE", "INOUT", "OUTREACH", "LIVE"):
env[key + "_DB_URL"] = ""
env.update(SESSION_SECRET_KEY="local-live-test-only", SESSION_COOKIE_SECURE="false", PERFORMANCE_AUTO_SYNC="false")
env.update(extra_env or {})
with tempfile.TemporaryDirectory(prefix="live-web-") as directory:
env["DATA_DIR"] = directory
return subprocess.run([sys.executable, "-c", PRELUDE + code], cwd=ROOT, env=env, capture_output=True,
text=True, encoding="utf-8", timeout=90)
class StoreTests(unittest.TestCase):
def test_clean_host(self):
got = store.clean_host({"full_name": " Siti Aisyah ", "phone": "+60 12-345 6789", "email": "siti@example.my", "address": "KL",
"bank_name": "Maybank", "bank_account": "1234-5678", "tiktok_handle": "@siti.live"})
self.assertEqual((got["full_name"], got["tiktok_handle"]), ("Siti Aisyah", "siti.live"))
self.assertEqual(store.clean_host({"full_name": "A"})["phone"], "") # Full Name 만 필수
for bad in ({}, {"full_name": " "}, {"full_name": "A", "email": "nope"}, {"full_name": "A", "phone": "abc"},
{"full_name": "A", "bank_account": "12a"}, {"full_name": "A", "tiktok_handle": "한글"},
{"full_name": "x" * 201}):
with self.assertRaises(ValueError, msg=bad):
store.clean_host(bad)
def test_clean_handle(self):
for raw in ("@siti.live", "siti.live", "https://www.tiktok.com/@siti.live?lang=en", "tiktok.com/@siti.live/video/1"):
self.assertEqual(store.clean_handle(raw), "siti.live", raw)
def test_parse_money(self):
self.assertIsNone(store.parse_money(""))
self.assertEqual(store.parse_money("RM 1,234.5"), Decimal("1234.50"))
self.assertEqual(store.parse_money("0"), Decimal("0.00"))
for bad in ("-1", "abc", "NaN", "Infinity", "1e20"):
with self.assertRaises(ValueError, msg=bad):
store.parse_money(bad)
def test_clean_broadcast(self):
got = store.clean_broadcast({"host_id": "3", "broadcast_date": "2026-11-04", "start_time": "20:00", "end_time": "22:00",
"venue": " Studio ", "sales_amount": "100"})
self.assertEqual(got, {"host_id": 3, "broadcast_date": date(2026, 11, 4), "start_time": time(20, 0), "end_time": time(22, 0),
"venue": "Studio", "sales_amount": Decimal("100.00")})
good = {"host_id": "3", "broadcast_date": "2026-11-04", "start_time": "20:00", "end_time": "22:00"}
for over in ({"host_id": ""}, {"host_id": "x"}, {"broadcast_date": ""}, {"broadcast_date": "2026-13-01"}, {"start_time": ""},
{"start_time": "25:00"}, {"end_time": ""}, {"end_time": "nope"}, {"end_time": "20:00"}, {"venue": "x" * 201}, {"sales_amount": "-5"}):
with self.assertRaises(ValueError, msg=over):
store.clean_broadcast({**good, **over})
def test_month_range(self):
today = date(2026, 11, 4)
self.assertEqual(store.month_range("", today)["label"], "2026년 11월")
self.assertEqual(store.month_range("", today, "en")["label"], "November 2026")
self.assertEqual(store.month_range("bad", today)["start"], date(2026, 11, 1))
self.assertEqual(store.month_range("2026-13", today)["start"], date(2026, 11, 1))
dec = store.month_range("2026-12", today)
self.assertEqual((dec["start"], dec["end"], dec["prev"], dec["next"]), (date(2026, 12, 1), date(2027, 1, 1), "2026-11", "2027-01"))
jan = store.month_range("2027-01", today)
self.assertEqual((jan["end"], jan["prev"], jan["next"]), (date(2027, 2, 1), "2026-12", "2027-02"))
def test_format(self):
self.assertEqual(store.fmt_date(date(2026, 11, 4)), "2026.11.04(수)")
self.assertEqual(store.fmt_date(date(2026, 11, 4), "en"), "2026.11.04 (Wed)")
self.assertEqual(store.fmt_times(time(20, 0), time(22, 30)), "20:00 ~ 22:30")
self.assertEqual(store.fmt_times(time(20, 0), None), "20:00")
self.assertEqual(store.fmt_money(Decimal("1234.5")), "1,234.50")
self.assertEqual(store.fmt_money(None), "")
def test_session_pay(self):
"""호스트 비용 = 시간 × RM 25 + 판매금액 10%. 받은 화면의 예: 2시간·판매 48 → 50 + 4.8."""
p = store.session_pay(time(12, 0), time(14, 0), Decimal("48"))
self.assertEqual((p["base"], p["commission"], p["fee"]), (Decimal("50.00"), Decimal("4.80"), Decimal("54.80")))
self.assertEqual(store.session_pay(time(22, 0), time(0, 0), None)["fee"], Decimal("50.00")) # 자정까지
self.assertEqual(store.session_pay(time(23, 0), time(1, 30), None)["base"], Decimal("62.50")) # 자정 넘김·30분
self.assertEqual(store.session_pay(time(12, 0), None, Decimal("10"))["fee"], Decimal("1.00")) # 끝 시간 없음 = 기본 요금 없음
self.assertEqual(store.session_pay(time(12, 0), time(14, 0), Decimal("0.05"))["commission"], Decimal("0.01")) # 반올림
self.assertEqual((store.fmt_short(Decimal("48")), store.fmt_short(Decimal("4.80")), store.fmt_short(Decimal("1234.5"))), ("48", "4.80", "1,234.50"))
def test_moved_end(self):
self.assertEqual(store.moved_end(time(12, 0), time(14, 30), time(20, 0)), time(22, 30))
self.assertEqual(store.moved_end(time(12, 0), time(14, 0), time(22, 0)), time(0, 0)) # 자정으로 넘어감
self.assertIsNone(store.moved_end(time(12, 0), None, time(20, 0)))
self.assertEqual(store.parse_move("2026-11-04", "20:00"), (date(2026, 11, 4), time(20, 0)))
for bad in (("", "20:00"), ("2026-11-04", ""), ("nope", "20:00")):
with self.assertRaises(ValueError):
store.parse_move(*bad)
def test_build_calendar(self):
def b(id, day, start, end, sales=None, host=1, handle="yaya"):
return {"id": id, "host_id": host, "host_name": "Yaya", "tiktok_handle": handle, "broadcast_date": day, "start_time": start,
"end_time": end, "venue": "", "sales_amount": sales, "images": []}
span = store.month_range("2026-11", date(2026, 11, 4))
cal = store.build_calendar(span, [b(1, date(2026, 11, 4), time(12, 0), time(14, 0), Decimal("48")),
b(2, date(2026, 11, 4), time(22, 0), time(0, 0), handle=""),
b(3, date(2026, 11, 7), time(13, 30), time(15, 0))],
{date(2026, 11, 4): Decimal("24")}, date(2026, 11, 4), "en")
ko = store.build_calendar(span, [], {}, date(2026, 11, 4))
self.assertEqual((ko["days"][3]["weekday"], ko["days"][3]["label"], ko["slot_note"]), ("수요일", "11월 4일", "2시간 (기본 RM50)"))
self.assertEqual(len(cal["days"]), 30)
self.assertEqual([s["label"] for s in cal["slots"]][0], "06:00 - 08:00")
self.assertEqual([s["label"] for s in cal["slots"]][-1], "22:00 - 00:00")
self.assertEqual(len(cal["slots"]), 9)
self.assertEqual(cal["slot_note"], "2 Hours (RM50 Base)")
d4 = cal["days"][3]
self.assertEqual((d4["weekday"], d4["label"], d4["count"], d4["is_today"], d4["is_weekend"]), ("WEDNESDAY", "4 NOV", 2, True, False))
self.assertEqual((d4["sales_text"], d4["spend_text"], d4["fee_text"], d4["roas"]), ("48", "24", "104.80", "2.00"))
self.assertEqual(cal["days"][6]["is_weekend"], True) # 11-07 토
self.assertEqual(cal["days"][0]["roas"], "-") # 광고비 없음
noon = next(s for s in cal["slots"] if s["start"] == "12:00")
self.assertEqual(noon["cells"][3]["cards"][0]["label"], "yaya") # 카드 머리 = Tiktok Handle
self.assertEqual((noon["cells"][3]["cards"][0]["card_sales"], noon["cells"][3]["cards"][0]["card_commission"], noon["cells"][3]["cards"][0]["card_fee"]),
("48", "4.80", "54.80"))
late = next(s for s in cal["slots"] if s["start"] == "22:00")
self.assertEqual((late["end"], late["cells"][3]["cards"][0]["label"]), ("00:00", "Yaya")) # 핸들 없으면 이름
self.assertEqual(next(s for s in cal["slots"] if s["start"] == "12:00")["cells"][6]["cards"][0]["id"], 3) # 13:30 = 12~14 칸
self.assertEqual(cal["totals"]["sales"], "48")
# 06시보다 이른 칸은 방송이 있을 때만
early = store.build_calendar(span, [b(9, date(2026, 11, 1), time(3, 0), time(5, 0))], {}, date(2026, 11, 4))
self.assertEqual(early["slots"][0]["label"], "02:00 - 04:00")
self.assertEqual(len(early["slots"]), 10)
def test_thumbnail(self):
for mode, fmt in (("RGB", "JPEG"), ("RGBA", "PNG")):
raw = io.BytesIO()
Image.new(mode, (800, 400)).save(raw, format=fmt)
with Image.open(io.BytesIO(store.thumbnail(raw.getvalue()))) as im:
self.assertEqual((im.format, im.size), ("JPEG", (160, 80)))
class I18nTests(unittest.TestCase):
def test_every_text_has_english(self):
"""템플릿·오류·권한 문구가 모두 영문 표에 있다 — 새 문구를 넣고 빠뜨리면 여기서 걸린다."""
live = ROOT / "app" / "modules" / "live"
keys = set(i18n.JS_KEYS) | set(store._LABELS.values()) | {"시작 시간", "끝 시간"}
for path in (live / "templates" / "live").glob("*.html"):
keys |= set(re.findall(r"\bt\('([^']+)'\)", path.read_text(encoding="utf-8")))
for name in ("store.py", "db.py", "router.py"):
text = (live / name).read_text(encoding="utf-8")
keys |= set(re.findall(r'LiveError\("([^"]+)"', text))
keys |= set(re.findall(r'_t\(request, "([^"]+)"\)', text))
keys |= set(re.findall(r'_ok\(request, "([^"]+)"\)', text))
keys |= set(re.findall(r'raise ValueError\("([^"]+)"', text))
keys |= set(re.findall(r'ValueError\("([^"]+)"', (ROOT / "app" / "modules" / "asset" / "media.py").read_text(encoding="utf-8")))
self.assertGreater(len(keys), 80)
self.assertEqual(sorted(k for k in keys if k not in i18n.EN), [])
self.assertEqual(sorted(k for k, v in i18n.EN.items() if re.search("[가-힣]", v)), [])
def test_error_text(self):
err = i18n.LiveError("{label} 이(가) 너무 깁니다({limit}자까지).", label="이메일", limit=254)
self.assertEqual(str(err), "이메일 이(가) 너무 깁니다(254자까지).")
self.assertEqual(i18n.error_text(err, "en"), "Email is too long (up to 254 characters).")
self.assertEqual(i18n.error_text(err, "ko"), str(err))
self.assertEqual(i18n.error_text(ValueError("잘못된 요청입니다."), "en"), "Invalid request.")
nested = i18n.LiveError("{name}: {detail}", name="a{b}.jpg", detail="JPG, PNG, WebP 사진만 등록할 수 있습니다.")
self.assertEqual(nested.text("en"), "a{b}.jpg: Only JPG, PNG and WebP images are allowed.")
self.assertEqual((i18n.norm_lang("en"), i18n.norm_lang("ko"), i18n.norm_lang("<x>"), i18n.norm_lang(None)), ("en", "ko", "ko", "ko"))
class WebTests(unittest.TestCase):
def test_main_card_title_both_languages(self):
res = _run('''
def body(c):
who["u"] = U("a@test.local", role="admin")
page = c.get("/modules").text # 카드 화면(수퍼관리자 홈과 같은 main.html)
assert "라이브 커머스 · Live Commerce" in page, page[:300]
nav = [i for i in main.build_erp_nav(who["u"], active="live") if i["key"] == "live"]
assert nav and nav[0]["label"] == "라이브 커머스" # 사이드바는 짧게
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_registered_and_unconfigured(self):
res = _run('''
from app.store import MODULE_KEYS
assert "live" in MODULE_KEYS and main.MODULE_LABELS["live"] == "라이브 커머스"
def body(c):
who["u"] = U("a@test.local", role="admin")
assert c.get("/live/health").json() == {"status": "not_configured"}
r = c.get("/live/")
assert r.status_code == 503 and "LIVE_DB_URL" in r.text and "라이브 커머스" in r.text, r.status_code
assert c.post("/live/broadcasts", data={}).status_code == 503
who["u"] = U("b@test.local", live=False)
assert c.get("/live/").status_code == 403
assert c.post("/live/broadcasts", data={}).status_code == 403
assert c.get("/live/images/1").status_code == 403
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
@unittest.skipUnless(DB_ENABLED, "LIVE_TEST_DB_URL(localhost) not set")
def test_full_flow(self):
res = _run('''
import io, re, uuid
from PIL import Image
from app.modules.live.db import LiveDBStore
st = LiveDBStore(__import__("os").environ["LIVE_TEST_DB_URL"])
main.app.state.live_store = st
tag = uuid.uuid4().hex[:8]
admin, staff, outsider = U("admin-%s@t.local" % tag, role="admin"), U("staff-%s@t.local" % tag), U("out-%s@t.local" % tag, live=False)
ACCOUNT = "9988%s" % int(tag, 16)
NAME = "Siti <b>" + tag
def jpeg():
raw = io.BytesIO()
exif = Image.Exif(); exif[0x010F] = "SECRET-CAMERA"
Image.new("RGB", (3000, 1500), "red").save(raw, format="JPEG", exif=exif)
return raw.getvalue()
def body(c):
host = {"full_name": NAME, "phone": "+60 12-345", "email": "siti@example.my", "address": "Kuala Lumpur",
"bank_name": "Maybank", "bank_account": ACCOUNT, "tiktok_handle": "@siti.%s" % tag, "is_active": "1"}
# ── 호스트 설정 = ERP 관리자만 ──
who["u"] = staff
assert c.get("/live/settings").status_code == 403
assert c.post("/live/settings/hosts", data=host).status_code == 403
assert c.post("/live/settings/hosts/1/delete").status_code == 403
assert 'href="/live/settings"' not in c.get("/live/").text
who["u"] = admin
bad = c.post("/live/settings/hosts", data={**host, "email": "nope"})
assert bad.status_code == 400 and "이메일" in bad.json()["message"]
r = c.post("/live/settings/hosts", data=host)
assert r.json()["ok"], r.text
hid = next(h["id"] for h in st.list_hosts() if h["full_name"] == NAME)
page = c.get("/live/settings").text
for field in ("이름 (IC 기준)", "전화번호", "이메일", "주소", "은행명", "계좌번호", "틱톡 핸들"):
assert field in page, field
assert ACCOUNT in page and "Siti &lt;b&gt;" in page and "<b>" + tag not in page
assert st.list_hosts() and next(h for h in st.list_hosts() if h["id"] == hid)["tiktok_handle"] == "siti." + tag
# ── 스케줄: 일반 권한자도 추가·고치기, 화면에 계좌·주소 없음 ──
who["u"] = staff
page = c.get("/live/?month=2031-03").text
assert 'value="%d"' % hid in page and "@siti." + tag in page
assert ACCOUNT not in page and "Kuala Lumpur" not in page and "Maybank" not in page
show = {"host_id": hid, "broadcast_date": "2031-03-05", "start_time": "20:00", "end_time": "22:30", "venue": "KL Studio", "sales_amount": "1,234.5"}
assert c.post("/live/broadcasts", data={**show, "host_id": ""}).status_code == 400
assert c.post("/live/broadcasts", data={**show, "host_id": 99999999}).status_code == 400
junk = c.post("/live/broadcasts", data=show, files=[("images", ("x.jpg", b"not an image", "image/jpeg"))])
assert junk.status_code == 400 and "x.jpg" in junk.json()["message"]
assert "KL Studio" not in c.get("/live/?month=2031-03").text # 이미지가 틀리면 방송도 저장 안 됨
r = c.post("/live/broadcasts", data=show, files=[("images", ("../../evil.jpg", jpeg(), "image/jpeg"))])
assert r.json()["ok"], r.text
page = c.get("/live/?month=2031-03").text
assert "2031.03.05(수)" in page and "20:00 ~ 22:30" in page and "KL Studio" in page and "1,234.50" in page
assert ">123.45</td>" in page and ">185.95</td>" in page # 커미션 10%·호스트 비용(2.5시간 × 25 + 123.45)
assert "KL Studio" not in c.get("/live/?month=2031-04").text
row = st.list_broadcasts(__import__("datetime").date(2031, 3, 1), __import__("datetime").date(2031, 4, 1))
row = next(b for b in row if b["host_id"] == hid)
bid, img = row["id"], row["images"][0]
assert img["filename"] == "evil.jpg" and len(row["images"]) == 1 # 파일 이름의 경로 제거
# ── 이미지: 크기 줄임·EXIF 제거·권한 ──
r = c.get("/live/images/%d" % img["id"])
assert r.status_code == 200 and r.headers["content-type"] == "image/jpeg" and "private" in r.headers["cache-control"]
assert b"SECRET-CAMERA" not in r.content
assert Image.open(io.BytesIO(r.content)).size == (2400, 1200)
assert Image.open(io.BytesIO(c.get("/live/images/%d?thumb=1" % img["id"]).content)).size == (160, 80)
assert c.get("/live/images/99999999").status_code == 404
who["u"] = outsider
assert c.get("/live/images/%d" % img["id"]).status_code == 403
assert c.post("/live/images/%d/delete" % img["id"]).status_code == 403
who["u"] = staff
# ── 고치기: 값 바뀜, 이미지 유지 + 더하기, 판매금액 지우기, 10장 제한 ──
r = c.post("/live/broadcasts", data={**show, "id": bid, "venue": "PJ Studio", "sales_amount": "", "end_time": "21:00"})
assert r.json()["ok"], r.text
page = c.get("/live/?month=2031-03").text
assert "PJ Studio" in page and "1,234.50" not in page and "20:00 ~ 21:00" in page
assert c.post("/live/broadcasts", data={**show, "end_time": ""}).status_code == 400 # 끝 시간 필수
# ── 달력: 카드 머리 = Tiktok Handle, Fee, 옮기기(길이 유지)·맞바꾸기, 광고비·ROAS, 권한 ──
c.post("/live/broadcasts", data={**show, "id": bid, "sales_amount": "48", "start_time": "12:00", "end_time": "14:00", "broadcast_date": "2031-03-05"})
cal = c.get("/live/calendar?month=2031-03").text
assert "날짜로 이동" in cal and "토요일" in cal and "12:00 - 14:00" in cal and "2시간 (기본 RM50)" in cal
assert '<span class="lv-card-name">siti.%s</span>' % tag in cal and "RM54.80" in cal and ">4.80</b>" in cal
# ── 영문: 화면 세 개 모두 한글 없음(입력한 데이터 제외)·날짜·오류·권한 문구 ──
def no_korean(url):
page = c.get(url).text
assert 'class="lv-lang"' in page and "window.LV_T" in page
part = page[page.index('<section class="lv"'):page.index("</dialog>")].replace(">한글<", "><") # 화면 + 창(공용 셸 제외)
left = re.findall("[가-힣][^<>\\"]*", part)
assert not left, (url, left[:5])
return page
c.cookies.set("live_lang", "en")
page = no_korean("/live/?month=2031-03")
assert 'lang="en"' in page and "March 2031" in page and "2031.03.05 (Wed)" in page and "Commission 10% (RM)" in page
cal = no_korean("/live/calendar?month=2031-03")
assert "Jump to Date" in cal and "SATURDAY" in cal and "1 MAR" in cal and "2 Hours (RM50 Base)" in cal and ">Sales<" in cal and "Com (10%)" in cal and "Fee: <b>RM54.80" in cal
assert "Total Sales:" in cal and "Ad Spend:" in cal and "Host Fee:" in cal and "Total &amp; ROAS" in cal
assert c.post("/live/broadcasts", data={**show, "id": bid, "sales_amount": "abc"}).json()["message"] == "Sales must be a number."
assert c.post("/live/broadcasts", data={**show, "id": bid, "end_time": ""}).json()["message"] == "Enter the End Time."
junk = c.post("/live/broadcasts", data=show, files=[("images", ("x.jpg", b"not an image", "image/jpeg"))]).json()["message"]
assert junk == "x.jpg: The image can't be read. Please choose a valid JPG, PNG or WebP file.", junk
assert c.post("/live/settings/hosts", data=host).json()["detail"] == "Only ERP admins can view host information."
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": "1"}).json()["message"] == "Ad spend saved."
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": ""}).json()["ok"]
who["u"] = admin
page = no_korean("/live/settings")
for field in ("Full Name (as per IC)", "Phone Number", "Email", "Address", "Bank Name", "Bank Account Number", "Tiktok Handle"):
assert field in page, field
who["u"] = staff
c.cookies.set("live_lang", "<bad>") # 모르는 값 = 한글
assert "2031년 3월" in c.get("/live/?month=2031-03").text
c.cookies.delete("live_lang")
assert ACCOUNT not in cal and "Maybank" not in cal
day = __import__("datetime").date
def one(i):
return next(b for b in st.list_broadcasts(day(2031, 3, 1), day(2031, 4, 1)) if b["id"] == i)
assert c.post("/live/broadcasts/%d/move" % bid, data={"broadcast_date": "2031-03-07", "start_time": "22:00"}).json()["ok"]
got = one(bid)
assert (got["broadcast_date"], str(got["start_time"]), str(got["end_time"])) == (day(2031, 3, 7), "22:00:00", "00:00:00")
assert c.post("/live/broadcasts/%d/move" % bid, data={"broadcast_date": "bad", "start_time": "22:00"}).status_code == 400
assert c.post("/live/broadcasts/99999999/move", data={"broadcast_date": "2031-03-07", "start_time": "22:00"}).status_code == 400
c.post("/live/broadcasts", data={**show, "broadcast_date": "2031-03-09", "start_time": "08:00", "end_time": "09:00", "venue": "Second"})
other = next(b["id"] for b in st.list_broadcasts(day(2031, 3, 9), day(2031, 3, 10)) if b["venue"] == "Second")
assert c.post("/live/broadcasts/%d/move" % bid, data={"swap_with": other}).json()["ok"]
a, b2 = one(bid), one(other)
assert (a["broadcast_date"], str(a["start_time"]), str(a["end_time"])) == (day(2031, 3, 9), "08:00:00", "09:00:00")
assert (b2["broadcast_date"], str(b2["start_time"]), str(b2["end_time"])) == (day(2031, 3, 7), "22:00:00", "00:00:00")
assert c.post("/live/broadcasts/%d/move" % bid, data={"swap_with": 99999999}).status_code == 400
assert c.post("/live/broadcasts/%d/move" % bid, data={"swap_with": bid}).json()["ok"]
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": "24"}).json()["ok"]
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": "12"}).json()["ok"] # 덮어쓰기
assert st.ad_spends(day(2031, 3, 1), day(2031, 4, 1)) == {day(2031, 3, 9): __import__("decimal").Decimal("12.00")}
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": "-1"}).status_code == 400
assert c.post("/live/ad-spend", data={"day": "bad", "amount": "1"}).status_code == 400
assert "4.00" in c.get("/live/calendar?month=2031-03").text # ROAS 48 ÷ 12
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": ""}).json()["ok"] # 빈칸 = 지우기
assert st.ad_spends(day(2031, 3, 1), day(2031, 4, 1)) == {}
assert c.post("/live/broadcasts/%d/delete" % other).json()["ok"]
c.post("/live/broadcasts", data={**show, "id": bid}) # 아래 시험을 위해 원래 값으로
who["u"] = outsider
assert c.get("/live/calendar").status_code == 403
assert c.post("/live/broadcasts/%d/move" % bid, data={"swap_with": bid}).status_code == 403
assert c.post("/live/ad-spend", data={"day": "2031-03-09", "amount": "1"}).status_code == 403
who["u"] = staff
many = [("images", ("%d.jpg" % i, jpeg(), "image/jpeg")) for i in range(10)]
r = c.post("/live/broadcasts", data={**show, "id": bid}, files=many)
assert r.status_code == 400 and "10장" in r.json()["message"], r.text # 이미 1장 + 10장
assert c.post("/live/broadcasts", data={**show, "id": 99999999}).status_code == 400
assert c.post("/live/broadcasts", data={**show, "id": "x"}).status_code == 400
# ── 호스트: 방송이 있으면 못 지움, 사용 안 함이면 새 방송 불가·기존 방송 고치기는 가능 ──
who["u"] = admin
r = c.post("/live/settings/hosts/%d/delete" % hid)
assert r.status_code == 400 and "사용 안 함" in r.json()["message"]
assert c.post("/live/settings/hosts", data={**host, "id": hid, "is_active": ""}).json()["ok"]
who["u"] = staff
assert 'data-inactive="1"' in c.get("/live/?month=2031-03").text
r = c.post("/live/broadcasts", data=show)
assert r.status_code == 400 and "사용 안 함" in r.json()["message"]
assert c.post("/live/broadcasts", data={**show, "id": bid}).json()["ok"]
# ── 지우기: 이미지 하나, 방송(이미지도), 그 뒤 호스트 ──
assert c.post("/live/images/%d/delete" % img["id"]).json()["ok"]
assert c.get("/live/images/%d" % img["id"]).status_code == 404
assert c.post("/live/broadcasts", data={**show, "id": bid}, files=[("images", ("a.png", jpeg(), "image/jpeg"))]).json()["ok"]
assert c.post("/live/broadcasts/%d/delete" % bid).json()["ok"]
assert c.post("/live/broadcasts/%d/delete" % bid).status_code == 400
who["u"] = admin
assert c.post("/live/settings/hosts/%d/delete" % hid).json()["ok"]
assert c.post("/live/settings/hosts/%d/delete" % hid).status_code == 400
print("OK")
run(body)
''', {"LIVE_TEST_DB_URL": DSN})
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
if __name__ == "__main__":
unittest.main()
+60
View File
@@ -3,6 +3,7 @@
VACATION_TEST_DB_URL 이 localhost/127.0.0.1 일 때만 돈다(아니면 skip). 앱 계정(vacation_app)으로 접속해 권한(GRANT)까지 본다.
psql … -v app_password=… -f scripts/sql/vacation_db_init.sql
psql … -d vacation_db -f scripts/sql/vacation_db_001_options_mail.sql
psql … -d vacation_db -f scripts/sql/vacation_db_003_consults.sql
VACATION_TEST_DB_URL=postgresql://vacation_app:<pw>@localhost:55432/vacation_db python -m pytest tests/test_vacation_db.py
"""
import os
@@ -43,6 +44,65 @@ class VacationOptionsDBTests(unittest.TestCase):
again = self.st.save_options(approvers=[], notifiers=[], by="admin@test.local") # 덮어쓰기(키 하나)
self.assertEqual((again["approvers"], again["notifiers"]), ([], []))
def _consult_req(self, owner, status="제출"):
return self.st.create_request(
owner=owner, owner_name="김철수", status=status,
payload={"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-06", "start_half": "full", "end_half": "full", "reason": "x"},
consults=[{"email": "park@test.local", "name": "박과장", "message": "박 내용"},
{"email": "choi@test.local", "name": "최대리", "message": "최 내용"}])
def test_consult_all_approve_moves_to_approver(self):
"""협의자(003) — 모두 승인해야 결재자에게, 그 전엔 승인 못 함, 내 협의 목록·권한."""
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
req = self._consult_req(owner)
rid = req["id"]
self.assertEqual(req["status"], "협의중")
self.assertEqual([(c["email"], c["message"], c["state"]) for c in self.st.list_consults(request_id=rid)],
[("park@test.local", "박 내용", "대기"), ("choi@test.local", "최 내용", "대기")])
with self.assertRaises(ValueError): # 협의 중에는 결재자가 승인 못 함
self.st.approve(request_id=rid, approver_email="lee@test.local")
self.assertNotIn(rid, [r["id"] for r in self.st.list_pending()])
self.assertIn(rid, [r["id"] for r in self.st.my_consults(email="PARK@test.local")])
with self.assertRaises(PermissionError):
self.st.decide_consult(request_id=rid, email="nobody@test.local", approve=True)
got, event = self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
self.assertEqual((got["status"], event), ("협의중", None)) # 한 명 남음
self.assertNotIn(rid, [r["id"] for r in self.st.my_consults(email="park@test.local")])
with self.assertRaises(ValueError): # 같은 사람이 두 번은 못 함
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=True)
self.assertEqual((got["status"], event), ("제출", "consulted"))
self.assertIn(rid, [r["id"] for r in self.st.list_pending()])
self.assertEqual(self.st.approve(request_id=rid, approver_email="lee@test.local")["status"], "승인")
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=True)
self.assertEqual(self.st.list_consults(request_id=rid), []) # 신청을 지우면 함께
def test_consult_reject_edit_and_resubmit(self):
"""협의자 한 명이 반려 → 신청 반려, 고쳐서 다시 제출하면 협의가 처음부터, 협의자 없이 내면 바로 제출."""
owner = f"kim-{uuid.uuid4().hex[:6]}@test.local"
rid = self._consult_req(owner)["id"]
self.st.decide_consult(request_id=rid, email="park@test.local", approve=True)
with self.assertRaisesRegex(ValueError, "사유"):
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False)
got, event = self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="일정 겹침")
self.assertEqual((got["status"], got["reject_reason"], got["approver_email"], event), ("반려", "일정 겹침", "choi@test.local", "rejected"))
again = self.st.submit(request_id=rid, owner=owner)
self.assertEqual(again["status"], "협의중")
self.assertEqual({c["state"] for c in self.st.list_consults(request_id=rid)}, {"대기"})
self.st.decide_consult(request_id=rid, email="choi@test.local", approve=False, reason="x")
payload = {"vacation_type": "연차", "start_date": "2026-11-05", "end_date": "2026-11-05", "reason": "y"}
self.st.update_request(request_id=rid, owner=owner, payload=payload, consults=[])
self.assertEqual(self.st.list_consults(request_id=rid), [])
self.assertEqual(self.st.submit(request_id=rid, owner=owner)["status"], "제출")
self.st.hard_delete(request_id=rid, user_email=owner, is_admin=False)
def test_consult_mail_log_events(self):
"""003 이 메일 기록 CHECK 를 넓혔는지 — 협의 메일도 기록된다."""
rid = uuid.uuid4().hex[:12]
for ev in ("consult_request", "consulted"):
self.st.add_mail_log(request_id=rid, event=ev, sender="a@test.local", via="smtp", recipients=["b@test.local"], subject="s", ok=True)
self.assertEqual([m["event"] for m in self.st.list_mail_log(request_id=rid)], ["consult_request", "consulted"])
def test_submit_approve_mail_log_end_to_end(self):
"""신청 → 제출 → 승인을 실제 DB 로, 메일은 가짜 SMTP — 기록이 상세 화면용 목록으로 나온다."""
from app.modules.vacation import notify
+207
View File
@@ -88,6 +88,51 @@ class ContentTests(unittest.TestCase):
self.assertIn("제출 — 승인 대기", one["text"])
class ConsultMailTests(unittest.TestCase):
"""협의자(2026-11-02) — 협의자마다 자기 몫만, 결재자·통보자는 전체."""
CONSULTS = [{"email": "park@test.local", "name": "박과장", "message": "박과장 전용 <업무>", "state": "대기"},
{"email": "choi@test.local", "name": "최대리", "message": "최대리 전용 내용", "state": "대기"}]
OWNER = {"email": "kim@test.local", "name": "김철수"}
def test_each_consultant_gets_only_own_message_and_others_get_all(self):
store = FakeStore(["lee@test.local"], ["hr@test.local"])
sent = []
with patch("app.mail.send_email", side_effect=lambda **kw: sent.append(kw) or True), patch("app.mail.mail_enabled", return_value=True):
res = notify.deliver(store, None, event="submitted", req=dict(REQ, status="협의중", consults=self.CONSULTS),
actor=self.OWNER, users=USERS, link="https://erp.test/vacation/r1")
self.assertEqual([m["to"] for m in sent], [["park@test.local"], ["choi@test.local"], ["lee@test.local", "hr@test.local"]])
park, choi, line = sent
self.assertIn("[휴가 협의 요청]", park["subject"])
self.assertIn("박과장 전용 &lt;업무&gt;", park["html"])
self.assertNotIn("최대리", park["html"] + park["body"])
self.assertIn("최대리 전용 내용", choi["body"])
self.assertNotIn("박과장", choi["html"] + choi["body"])
for text in ("박과장", "박과장 전용 <업무>", "최대리", "최대리 전용 내용", "협의 진행 중"):
self.assertIn(text, line["body"])
self.assertIn("협의자가 모두 승인하면", line["html"])
self.assertEqual([log["event"] for log in store.logs], ["consult_request", "consult_request", "submitted"])
self.assertTrue(res["ok"])
self.assertEqual(res["to"], ["lee@test.local", "hr@test.local"])
def test_resend_skips_consultants_who_already_decided(self):
cs = [dict(self.CONSULTS[0], state="승인"), self.CONSULTS[1]]
with patch("app.mail.send_email", return_value=True) as smtp, patch("app.mail.mail_enabled", return_value=True):
notify.deliver(FakeStore(["lee@test.local"]), None, event="submitted", req=dict(REQ, consults=cs), actor=self.OWNER, users=USERS, link="x")
self.assertEqual([c.kwargs["to"] for c in smtp.call_args_list], [["choi@test.local"], ["lee@test.local"]])
def test_consulted_goes_to_approver_notifier_owner_and_lists_consults(self):
done = [dict(c, state="승인") for c in self.CONSULTS]
store = FakeStore(["lee@test.local"], ["hr@test.local"])
with patch("app.mail.send_email", return_value=True) as smtp, patch("app.mail.mail_enabled", return_value=True):
notify.deliver(store, None, event="consulted", req=dict(REQ, consults=done), actor={"email": "choi@test.local"},
users=USERS, link="x")
kw = smtp.call_args.kwargs
self.assertEqual(smtp.call_count, 1)
self.assertEqual(kw["to"], ["lee@test.local", "hr@test.local", "kim@test.local"])
self.assertIn("[휴가 협의 완료]", kw["subject"])
self.assertIn("협의자 박과장: 승인", kw["body"])
class DeliverTests(unittest.TestCase):
ACTOR = {"email": "lee@test.local", "name": "이팀장"}
@@ -197,6 +242,14 @@ class Store:
self.req.update(status="반려", reject_reason=reason); return dict(self.req)
def list_mail_log(self, request_id):
return []
def consults_ready(self):
return True
def list_consults(self, request_id):
return []
def consults_for(self, request_ids):
return {}
def my_consults(self, email):
return []
def list_balances(self, year):
return []
def used_days(self, user_email, year):
@@ -360,6 +413,160 @@ run(body)
self.assertIn("OK", res.stdout)
def test_consult_access_and_form(self):
"""협의자(2026-11-02) — 폼 값 저장 규칙, 휴가 권한 없는 협의자도 자기 신청은 보고 처리, 다른 협의자 내용은 안 보임."""
res = _run('''
outsider = U("out@test.local"); outsider["modules"] = {}
other = U("other@test.local"); other["modules"] = {}
users.extend([outsider, other])
CONSULTS = [{"email": "out@test.local", "name": "out", "message": "바깥 사람 전용", "state": "대기", "comment": "", "decided_at": None},
{"email": "lee@test.local", "name": "lee", "message": "이팀장 전용", "state": "대기", "comment": "", "decided_at": None}]
class Store3(Store):
created = None
decided = []
def list_consults(self, request_id):
return [dict(c) for c in CONSULTS]
def get_request(self, request_id):
return dict(self.req)
def create_request(self, owner, owner_name, payload, status, consults=None):
Store3.created = {"status": status, "consults": consults, "owner": owner}
return dict(self.req, id="new1")
def decide_consult(self, request_id, email, approve, reason=""):
Store3.decided.append((email, approve, reason))
return dict(self.req, status="제출"), ("consulted" if approve else "rejected")
def list_overlapping(self, date_from, date_to):
return []
def list_pending(self):
return []
st3 = Store3()
st3.req["status"] = "협의중"
FORM = {"vacation_type": "연차", "start_date": "2026-11-03", "end_date": "2026-11-03", "action": "submit"}
def body(c):
main.app.state.vacation_store = st3
who["u"] = kim
# 신청 화면 — 구성원 전체(휴가 권한 없는 사람 포함, 나 빼고)
t = c.get("/vacation/new").text
assert 'data-email="out@test.local"' in t and 'data-email="lee@test.local"' in t and 'data-email="kim@test.local"' not in t
# 제출 — 협의자도 "협의자 없음"도 없으면 400, 작성중 저장은 통과
assert c.post("/vacation/new", data=FORM).status_code == 400
assert c.post("/vacation/new", data=dict(FORM, action="draft")).status_code == 303 and Store3.created["consults"] == []
assert c.post("/vacation/new", data=dict(FORM, no_consult="1")).status_code == 303 and Store3.created["consults"] == []
# 빈 협의 내용이 있어도 사람과 내용 칸이 어긋나지 않음, 본인은 빠짐
r = c.post("/vacation/new", data=dict(FORM, consult_email=["kim@test.local", "lee@test.local", "out@test.local"], consult_message=["나", "", "부탁드립니다"]))
assert r.status_code == 303, r.text
assert Store3.created["consults"] == [{"email": "lee@test.local", "name": "lee", "message": ""},
{"email": "out@test.local", "name": "out", "message": "부탁드립니다"}], Store3.created
assert c.post("/vacation/new", data=dict(FORM, consult_email=["nobody@test.local"], consult_message=[""])).status_code == 400
# 휴가 권한 없는 협의자 — 메일 링크로 자기 신청을 열어 처리, 자기 내용만
who["u"] = outsider
t = c.get("/vacation/r1").text
assert "바깥 사람 전용" in t and "이팀장 전용" not in t and "협의 승인" in t
assert c.get("/vacation/").status_code == 403
assert c.post("/vacation/r1/consult", data={"decision": "approve"}).status_code == 303
assert Store3.decided[-1] == ("out@test.local", True, "") and sent[-1][0] == "consulted", sent
# 협의자가 아니고 권한도 없으면 못 봄
who["u"] = other
assert c.get("/vacation/r1").status_code == 403
# 신청자·결재자는 전체, 내 신청 내역은 라우팅이 신청 id 보다 먼저
who["u"] = kim
t = c.get("/vacation/r1").text
assert "바깥 사람 전용" in t and "이팀장 전용" in t and "협의 승인" not in t
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_failed_mail_gmail_connect_and_retry(self):
"""협의자가 Gmail 미연결로 메일 실패 → 상세에 안내 → (휴가 권한 없어도) 연결 → 다시 보내기 → 안내 사라짐."""
res = _run('''
from fastapi.responses import RedirectResponse
from app.modules.inout import gmail
outsider = U("out@test.local"); outsider["modules"] = {}
other = U("other@test.local"); other["modules"] = {}
users.extend([outsider, other])
LOG = []
class Store4(Store):
def list_consults(self, request_id):
return [{"email": "out@test.local", "name": "out", "message": "m", "state": "승인", "comment": "", "decided_at": None}]
def get_request(self, request_id):
return dict(self.req)
def list_mail_log(self, request_id):
return list(LOG)
def decide_consult(self, request_id, email, approve, reason=""):
self.req["status"] = "제출"
return dict(self.req), "consulted"
class Inout:
tokens = set()
def gmail_token(self, email):
return {"refresh_token_enc": "x"} if email in self.tokens else None
def save_gmail_token(self, email, refresh_token_enc, scopes):
self.tokens.add(email)
class Client:
async def authorize_redirect(self, request, url, **kw):
return RedirectResponse("https://accounts.test/", status_code=302)
async def authorize_access_token(self, request):
return {"userinfo": {"email": "out@test.local"}, "scope": "openid email " + gmail.GMAIL_SCOPE, "refresh_token": "R"}
st4 = Store4()
st4.req["status"] = "협의중"
inout = Inout()
def fail(event, sender="out@test.local", ok=False):
LOG.append({"event": event, "sender": sender, "ok": ok, "via": "smtp", "recipients": "a@test.local", "sent_at": "2026-11-02T15:59:00", "error": "SMTP 미설정"})
def body(c):
main.app.state.vacation_store = st4
main.app.state.inout_store = inout
with patch.object(gmail, "oauth_client", return_value=Client()), \\
patch.object(gmail, "encrypt_token", side_effect=lambda e, r: "enc:" + r), \\
patch.object(gmail, "configured", return_value=True), \\
patch("app.mail.mail_enabled", return_value=False):
# 미연결 — 처리는 저장되고 메일은 바로 시도(응답 뒤로 미루지 않음), 기록이 실패면 Gmail 연결 안내
who["u"] = outsider
n = len(sent)
assert c.post("/vacation/r1/consult", data={"decision": "approve"}).status_code == 303
assert sent[n:] == [("consulted", "out@test.local", "https://erp.test/vacation/r1")], sent
fail("consulted")
t = c.get("/vacation/r1").text
assert "협의 완료 메일을 보내지 못했습니다" in t and '/vacation/gmail/connect?next=/vacation/r1"' in t and "메일 다시 보내기" not in t
# 다른 사람(신청자)에게는 안내 없음, 다시 보내기도 안 됨
who["u"] = kim
assert "보내지 못했습니다" not in c.get("/vacation/r1").text
n = len(sent)
assert c.post("/vacation/r1/mail-retry").status_code == 303 and len(sent) == n
# 휴가 권한 없는 협의자 — 연결 시작 → 콜백 통과 → 그 상세로 복귀
who["u"] = outsider
assert c.get("/vacation/gmail/connect").status_code == 403 # 협의 신청 없이는 권한 필요
r = c.get("/vacation/gmail/connect?next=/vacation/r1")
assert r.status_code == 302, r.status_code
r = c.get("/inout/gmail/callback")
assert r.status_code == 303 and r.headers["location"].startswith("/vacation/r1?msg="), (r.status_code, r.headers.get("location"))
assert "out@test.local" in inout.tokens
assert "Gmail" in c.get(r.headers["location"]).text
# 협의자가 아닌 신청의 next 는 권한 없으면 거절
who["u"] = other
assert c.get("/vacation/gmail/connect?next=/vacation/r1").status_code == 403
who["u"] = outsider
# 연결 뒤 — 다시 보내기 버튼, 누르면 응답 전에 보냄, 성공 기록이면 안내 사라짐
t = c.get("/vacation/r1").text
assert "메일 다시 보내기" in t and "/vacation/gmail/connect" not in t
n = len(sent)
assert c.post("/vacation/r1/mail-retry").status_code == 303
assert sent[n:] == [("consulted", "out@test.local", "https://erp.test/vacation/r1")], sent
fail("consulted", ok=True)
assert "보내지 못했습니다" not in c.get("/vacation/r1").text
# 일이 더 진행되면(승인 메일 성공) 예전 실패는 안내하지 않음 — 스크린샷 사례
LOG.clear(); fail("consulted"); fail("approved", sender="lee@test.local", ok=True)
st4.req["status"] = "승인"
assert "보내지 못했습니다" not in c.get("/vacation/r1").text
print("OK")
run(body)
''')
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
self.assertIn("OK", res.stdout)
def test_balances_in_options_settings_and_calendar_holidays(self):
"""2026-10-27 — 잔여 연차는 옵션(관리자, 참여자 전원 아이콘·이름 미리), 설정엔 없음, 달력 공휴일 이름."""
res = _run('''