Add database-backed manual order grid with automatic cell saving
This commit is contained in:
@@ -19,6 +19,8 @@ SETTINGS_DB=corm_db
|
||||
SETTINGS_BACKEND=google
|
||||
# 문자내역/수동발주내역: history_migrate.py 이전·검증 후 postgres로 변경
|
||||
HISTORY_BACKEND=google
|
||||
# 수동발주 표: deploy-manual-orders.sh 이전·검증 후 postgres로 변경
|
||||
MANUAL_ORDERS_BACKEND=google
|
||||
|
||||
# ============================================
|
||||
# 네이버 커머스 API
|
||||
|
||||
@@ -34,11 +34,13 @@ ERP 연결 실패/타임아웃은 503으로 차단하며, CORM은 ERP 세션을
|
||||
구글 시트의 업무 설정을 같은 PostgreSQL 서버의 전용 `corm_db`로 이전하려면 [설정 DB 이전 절차](docs/settings-postgres.md)를 따른다.
|
||||
`SETTINGS_BACKEND=postgres`로 전환한 뒤에는 설정 화면의 조회·저장이 DB를 사용한다. DB 접속 정보와 API 비밀키는 기존 `.env`/환경변수에 유지한다.
|
||||
문자내역과 수동발주내역도 같은 `corm_db`로 옮기려면 [내역 DB 이전 절차](docs/history-postgres.md)를 따르고 `HISTORY_BACKEND=postgres`로 전환한다.
|
||||
실제 수동발주 시트를 셀 편집·자동 저장 표로 바꾸려면 [수동발주 표 전환](docs/manual-orders-postgres.md)을 따른다.
|
||||
운영자 실행: `cd /opt/dbx-corm && git pull --ff-only && bash deploy-manual-orders.sh`.
|
||||
|
||||
| DB 이름 | 용도 |
|
||||
|---|---|
|
||||
| `itemcode_db` | 품목코드 마스터 + CS 기록(v9.1: `cs_records`·`cs_memo_folders`·`cs_permanent_memos`·`cs_schedules`, 앱이 처음 쓸 때 `CREATE TABLE IF NOT EXISTS` 로 자동 생성) |
|
||||
| `corm_db` | CORM 업무 설정·문자내역·수동발주내역 (`SETTINGS_DB`, `corm_settings`·`corm_sms_history`·`corm_manual_history` 테이블) |
|
||||
| `corm_db` | CORM 업무 설정·문자내역·수동발주내역·실제 수동발주 표 (`SETTINGS_DB`, 각각 별도 테이블 사용) |
|
||||
| `orderlist_db` | 주문 정보 조회 |
|
||||
| `return_db` | 반품 데이터 저장 |
|
||||
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
#!/usr/bin/env bash
|
||||
set -Eeuo pipefail
|
||||
umask 077
|
||||
cd -- "$(dirname -- "${BASH_SOURCE[0]}")"
|
||||
project_dir="$(pwd -P)"
|
||||
test -f .env
|
||||
git diff --quiet && git diff --cached --quiet || { printf '%s\n' '서버 코드 변경을 먼저 확인해주세요.' >&2; exit 1; }
|
||||
docker compose ps
|
||||
container="$(docker compose ps -q corm-app)"
|
||||
test -n "$container"
|
||||
runtime="$(docker exec "$container" python -c 'import os; assert os.getenv("SETTINGS_DB")=="corm_db" and os.getenv("HISTORY_BACKEND")=="postgres" and os.getenv("SETTINGS_BACKEND")=="postgres", "설정·내역 DB 전환부터 완료해주세요"; assert os.getenv("INTERNAL_SERVICE_TOKEN"), "기존 서비스 토큰이 필요합니다"; print(os.getenv("MANUAL_ORDERS_BACKEND","google"))')"
|
||||
[[ "$runtime" =~ ^(google|postgres)$ ]]
|
||||
stamp="$(date -u +%Y%m%dT%H%M%SZ)-$$"
|
||||
backup_dir="$project_dir/.settings-backups/manual-$stamp"
|
||||
mkdir -p -- "$backup_dir"
|
||||
chmod 700 -- "$backup_dir"
|
||||
cp -p -- .env "$backup_dir/env.before"
|
||||
old_image="$(docker inspect --format '{{.Image}}' "$container")"
|
||||
rollback_image="dbx-corm:before-manual-$stamp"
|
||||
docker image tag "$old_image" "$rollback_image"
|
||||
printf 'services:\n corm-app:\n image: %s\n' "$rollback_image" > "$backup_dir/rollback.yml"
|
||||
printf '백업 위치: %s\n' "$backup_dir"
|
||||
printf '%s\n' '빌드 후 앱을 잠시 정지합니다. 다른 앱과 구글 시트에서도 발주 편집을 중단해주세요.'
|
||||
docker compose build corm-app
|
||||
stopped=0
|
||||
env_changed=0
|
||||
rollback() {
|
||||
result=$?
|
||||
trap - ERR INT TERM
|
||||
printf '전환 실패. DB·원본·백업은 보존했습니다: %s\n' "$backup_dir" >&2
|
||||
if [[ "$stopped" == 1 ]]; then
|
||||
if [[ "$env_changed" == 1 ]]; then cp -p -- "$backup_dir/env.before" "$project_dir/.env" || true; fi
|
||||
docker compose -f "$project_dir/docker-compose.yml" -f "$backup_dir/rollback.yml" up -d --no-deps --no-build corm-app || true
|
||||
fi
|
||||
[[ "$result" != 0 ]] || result=1
|
||||
exit "$result"
|
||||
}
|
||||
trap rollback ERR INT TERM
|
||||
stopped=1
|
||||
docker compose stop corm-app
|
||||
run_corm() {
|
||||
docker compose run --rm --no-deps -T -e MANUAL_ORDERS_BACKEND="$runtime" \
|
||||
-v "$backup_dir:/backups" -v "$project_dir:/deploy" corm-app python manual_orders_deploy.py "$@"
|
||||
}
|
||||
run_corm snapshot
|
||||
run_corm migrate
|
||||
env_changed=1
|
||||
run_corm environment
|
||||
docker compose up -d --no-deps --no-build corm-app
|
||||
ready=0
|
||||
for attempt in {1..12}; do
|
||||
if docker compose exec -T corm-app python manual_orders_deploy.py probe; then ready=1; break; fi
|
||||
sleep 2
|
||||
done
|
||||
[[ "$ready" == 1 ]]
|
||||
trap - ERR INT TERM
|
||||
docker compose ps
|
||||
printf '수동발주 DB 표 전환 완료. 백업: %s\n' "$backup_dir"
|
||||
printf '%s\n' '브라우저를 새로고침하고 수동발주 탭의 셀 편집·자동 저장을 확인해주세요.'
|
||||
@@ -0,0 +1,62 @@
|
||||
# 수동발주 표를 DB로 전환
|
||||
|
||||
설정·문자내역·수동발주내역을 `corm_db`로 옮긴 설치에서 사용한다.
|
||||
같은 DB의 별도 `corm_manual_orders` 테이블에 실제 발주 행을 저장한다.
|
||||
`itemcode_db`와 CS 기록은 변경하지 않는다.
|
||||
|
||||
## 화면과 저장
|
||||
|
||||
- 기존 Google 수동 발주 시트의 15개 열 이름·순서와 값을 유지한다. 원본에 추가 열이 있으면 함께 보존한다.
|
||||
- 프로그램의 수동발주 탭에 편집 가능한 표를 표시한다. 셀을 클릭해 입력하면 약 0.45초 뒤, 또는 셀을 벗어날 때 자동 저장한다. 별도 저장 버튼은 없다.
|
||||
- Enter/Shift+Enter는 아래/위 셀, Tab/Shift+Tab은 다음/이전 셀로 이동한다. Alt+Enter는 셀 안 줄바꿈이다.
|
||||
- TSV 형식의 여러 셀 붙여넣기를 지원한다. 필요한 행을 먼저 추가하고 한 번에 1,000셀 이내로 붙여넣는다.
|
||||
- 입력 중·저장 완료·실패 상태를 표시한다. 실패한 입력은 표에 유지하며 재시도할 수 있다. 미저장 입력이 있는 채로 창을 닫으면 브라우저가 확인한다.
|
||||
- 같은 셀을 다른 사용자가 먼저 바꿨으면 자동으로 덮어쓰지 않는다. 재시도 시 최신값과 내 입력을 비교해 선택한다.
|
||||
- 다른 셀에 대한 동시 수정은 DB 행 잠금 안에서 반영한다. 이전 저장 응답을 받지 못한 같은 값의 재시도는 허용한다.
|
||||
- 다른 사용자의 변경은 편집하지 않는 동안 10초 간격으로 갱신한다. 화면의 새로고침으로 즉시 갱신할 수도 있다.
|
||||
- 행 추가와 선택 행 삭제를 지원한다. 행 삭제는 DB에 보관 처리하며, Google 시트에는 쓰지 않는다.
|
||||
- 발주 입력과 수동발주 내역 요약은 같은 DB 트랜잭션으로 저장한다. 브라우저에서 요약을 중복 생성하지 않는다.
|
||||
- 셀 편집은 값 입력용이다. 수식 계산·Google Sheets의 서식/스크립트는 이 표의 기능에 포함하지 않는다.
|
||||
|
||||
## 엑셀 다운로드
|
||||
|
||||
기존처럼 발주 자료를 엑셀로 내려받고 현재 표를 비운다. 미저장 셀이 있으면 먼저 저장을 완료한다.
|
||||
파일 생성·파일 보관·해당 행 보관 처리는 한 트랜잭션에서 수행한다. 파일 생성이 실패하면 표를 비우지 않는다.
|
||||
내려받는 중 다른 사용자가 추가한 새 행은 함께 지우지 않는다.
|
||||
표의 **다운로드 기록**에서 최근 10개 파일을 다시 받을 수 있다. 최근 10개만 화면에 표시하며 더 오래된 파일도 DB에서 자동 삭제하지 않는다.
|
||||
주소·전화·상품코드·우편번호 등은 텍스트로 보존하고, 수량/금액의 일반 정수 값은 숫자로 내보낸다.
|
||||
`=`로 시작하는 입력은 Excel 수식으로 실행하지 않고 텍스트로 저장한다.
|
||||
|
||||
## 서버 실행 명령
|
||||
|
||||
다른 앱과 Google 시트에서의 발주 편집을 잠시 중단한 뒤 운영 서버에서 실행한다.
|
||||
별도 SSH 원격 실행 없이 운영자가 실행하는 명령이다.
|
||||
|
||||
```bash
|
||||
cd /opt/dbx-corm && git pull --ff-only && bash deploy-manual-orders.sh
|
||||
```
|
||||
|
||||
스크립트는 현재 설정·내역 DB 전환 상태 확인 → 이전 환경/이미지 보관 → 새 이미지 빌드 → CORM 정지 →
|
||||
발주 원본 백업 → 테이블 생성·행/열 전체 이전·읽기 검증 → `.env`의 `MANUAL_ORDERS_BACKEND=postgres` 전환 →
|
||||
기동·조회 API 점검 순서로 진행한다. 별도 DB 생성은 필요 없다.
|
||||
|
||||
백업은 `.settings-backups/manual-<시각>-<프로세스번호>/`에 보관한다.
|
||||
Google 원본은 수정하거나 지우지 않는다. 이미 DB로 전환된 상태에서 다시 실행하면 현재 DB를 원본으로 백업하며,
|
||||
기존 DB가 원본과 다르면 덮어쓰지 않고 중단한다.
|
||||
실패하면 이전 환경/이미지로 앱 재시작을 시도하고, DB와 원본 백업을 보존한다.
|
||||
|
||||
전환 후 브라우저를 새로고침한다. 기존 구글 시트 iframe 대신 표가 표시되는지 확인하고,
|
||||
테스트용 셀 수정 후 저장 완료 표시와 새로고침 후 값 유지를 확인한다.
|
||||
실제 주문 삭제와 다운로드 후 비우기 검증에는 테스트 발주를 사용한다.
|
||||
|
||||
## 백업과 복구
|
||||
|
||||
`corm_db` 전체를 정기 백업한다. 이번에 추가되는 테이블은 다음과 같다.
|
||||
|
||||
- `corm_manual_sheet`: 열 이름과 최초 이전 정보
|
||||
- `corm_manual_orders`: 발주 셀·수정 버전·주문 연결 정보·보관 시각
|
||||
- `corm_manual_exports`: 다시 받을 수 있는 Excel 파일과 해당 행 ID
|
||||
|
||||
DB 전환 뒤의 추가·수정·삭제는 기존 Google 시트로 복제되지 않는다.
|
||||
`MANUAL_ORDERS_BACKEND=google`로 단순 복귀하면 이전 시트 값이 표시되므로,
|
||||
DB 전환 후 변경이 있다면 현재 발주와 백업을 보관하고 차이를 확인한 뒤 복구한다.
|
||||
@@ -41,6 +41,7 @@ from settings_store import (
|
||||
config_to_rows, rows_to_config, settings_db_config,
|
||||
)
|
||||
from history_store import PostgresHistoryStore
|
||||
from manual_orders import ManualOrderStore, CellConflict
|
||||
|
||||
# ==========================================
|
||||
# SSO / 서브경로 호스팅 설정
|
||||
@@ -73,6 +74,12 @@ HISTORY_BACKEND = os.getenv("HISTORY_BACKEND", "google").strip().lower()
|
||||
if HISTORY_BACKEND not in {"google", "postgres"}:
|
||||
raise RuntimeError("HISTORY_BACKEND는 google 또는 postgres여야 합니다.")
|
||||
_postgres_history = PostgresHistoryStore(SETTINGS_DB_CONFIG)
|
||||
MANUAL_ORDERS_BACKEND = os.getenv("MANUAL_ORDERS_BACKEND", "google").strip().lower()
|
||||
if MANUAL_ORDERS_BACKEND not in {"google", "postgres"}:
|
||||
raise RuntimeError("MANUAL_ORDERS_BACKEND는 google 또는 postgres여야 합니다.")
|
||||
if MANUAL_ORDERS_BACKEND == "postgres" and HISTORY_BACKEND != "postgres":
|
||||
raise RuntimeError("DB 수동발주는 HISTORY_BACKEND=postgres가 필요합니다.")
|
||||
_manual_orders = ManualOrderStore(SETTINGS_DB_CONFIG)
|
||||
|
||||
# 2. 반품 데이터 저장용 DB
|
||||
RETURN_DB_CONFIG = {
|
||||
@@ -249,6 +256,28 @@ def history_db_call(method, *args, **kwargs):
|
||||
raise HTTPException(status_code=503, detail="DB 내역 처리를 확인하지 못했습니다. 새로고침하여 확인해주세요.") from exc
|
||||
|
||||
|
||||
def manual_worker(function):
|
||||
@functools.wraps(function)
|
||||
async def wrapped(*args, **kwargs):
|
||||
if MANUAL_ORDERS_BACKEND == "postgres":
|
||||
return await run_in_threadpool(function, *args, **kwargs)
|
||||
return await run_google_io(function, *args, **kwargs)
|
||||
return wrapped
|
||||
|
||||
|
||||
def manual_db_call(method, *args, **kwargs):
|
||||
try:
|
||||
return getattr(_manual_orders, method)(*args, **kwargs)
|
||||
except CellConflict as exc:
|
||||
raise HTTPException(status_code=409, detail={"message": str(exc), "conflicts": exc.rows}) from exc
|
||||
except LookupError as exc:
|
||||
raise HTTPException(status_code=404, detail=str(exc)) from exc
|
||||
except ValueError as exc:
|
||||
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
||||
except Exception as exc:
|
||||
raise HTTPException(status_code=503, detail="수동발주 저장을 확인하지 못했습니다. 입력을 보존한 후 다시 시도해주세요.") from exc
|
||||
|
||||
|
||||
def read_config(force_refresh=False):
|
||||
if SETTINGS_BACKEND == "postgres":
|
||||
try:
|
||||
@@ -336,6 +365,7 @@ async def index(request: Request):
|
||||
"root_path": APP_ROOT_PATH,
|
||||
"user_email": getattr(request.state, "erp_user", {}).get("email", ""),
|
||||
"user_name": getattr(request.state, "erp_user", {}).get("name", ""),
|
||||
"manual_orders_backend": MANUAL_ORDERS_BACKEND,
|
||||
}
|
||||
)
|
||||
|
||||
@@ -583,9 +613,11 @@ async def startup_event():
|
||||
_settings_cache.refresh_in_background(_load_settings_rows)
|
||||
if HISTORY_BACKEND == "postgres":
|
||||
await run_in_threadpool(_postgres_history.check_ready)
|
||||
if MANUAL_ORDERS_BACKEND == "postgres":
|
||||
await run_in_threadpool(_manual_orders.check_ready)
|
||||
|
||||
@app.post("/api/order/submit")
|
||||
@google_worker
|
||||
@manual_worker
|
||||
def submit_order_submit(payload: OrderPayload):
|
||||
date_str, time_str, current_datetime_str = get_current_time_info()
|
||||
c_tel = format_phone_number(payload.phone)
|
||||
@@ -601,8 +633,6 @@ def submit_order_submit(payload: OrderPayload):
|
||||
title = "재구매"
|
||||
|
||||
try:
|
||||
worksheet = get_manual_worksheet()
|
||||
|
||||
rows = []
|
||||
lines = []
|
||||
for i, item in enumerate(payload.items):
|
||||
@@ -618,7 +648,12 @@ def submit_order_submit(payload: OrderPayload):
|
||||
rows.append(row_data)
|
||||
|
||||
if rows:
|
||||
worksheet.append_rows(rows, value_input_option='USER_ENTERED')
|
||||
if MANUAL_ORDERS_BACKEND == "postgres":
|
||||
manual_db_call("append", rows, {"timestamp": current_datetime_str,
|
||||
"customer_name": payload.customer_name,
|
||||
"total_amount": order_status or payload.total_amount})
|
||||
else:
|
||||
get_manual_worksheet().append_rows(rows, value_input_option='USER_ENTERED')
|
||||
|
||||
clipboard_text = "\r\n".join(lines) + "\r\n"
|
||||
cs_record_saved_count = 0
|
||||
@@ -635,21 +670,104 @@ def submit_order_submit(payload: OrderPayload):
|
||||
|
||||
return {
|
||||
"status": "success",
|
||||
"message": f"{len(rows)}개 항목 구글 시트 입력 및 클립보드 준비 완료.",
|
||||
"message": f"{len(rows)}개 항목 발주 입력 및 클립보드 준비 완료.",
|
||||
"history_saved": MANUAL_ORDERS_BACKEND == "postgres",
|
||||
"clipboard_text": clipboard_text,
|
||||
"timestamp": current_datetime_str,
|
||||
"cs_record_saved_count": cs_record_saved_count,
|
||||
"cs_record_warning": cs_record_warning,
|
||||
}
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception as e:
|
||||
err_str = str(e)
|
||||
if not err_str or err_str.strip() == "{}":
|
||||
err_str = repr(e)
|
||||
raise HTTPException(status_code=500, detail=f"수동발주 시트 접근 에러 (스프레드시트에 이메일 편집 권한을 추가했는지 확인해주세요!): {err_str}")
|
||||
|
||||
def manual_file_response(content, filename, export_id=None):
|
||||
headers = {"Content-Disposition": f"attachment; filename*=UTF-8''{quote(filename)}"}
|
||||
if export_id:
|
||||
headers["X-Manual-Export-ID"] = export_id
|
||||
return StreamingResponse(io.BytesIO(content),
|
||||
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", headers=headers)
|
||||
|
||||
|
||||
class ManualCellChange(BaseModel):
|
||||
id: int
|
||||
column: int
|
||||
value: str
|
||||
previous_value: str
|
||||
|
||||
|
||||
class ManualCellChanges(BaseModel):
|
||||
changes: List[ManualCellChange]
|
||||
|
||||
|
||||
class ManualRowVersion(BaseModel):
|
||||
id: int
|
||||
version: int
|
||||
|
||||
|
||||
class ManualRowsToArchive(BaseModel):
|
||||
rows: List[ManualRowVersion]
|
||||
|
||||
|
||||
def require_manual_db():
|
||||
if MANUAL_ORDERS_BACKEND != "postgres":
|
||||
raise HTTPException(status_code=409, detail="수동발주 DB 이전 후 사용할 수 있습니다.")
|
||||
|
||||
|
||||
@app.get("/api/manual/orders")
|
||||
def get_manual_orders():
|
||||
require_manual_db()
|
||||
return manual_db_call("list_rows")
|
||||
|
||||
|
||||
@app.post("/api/manual/orders")
|
||||
def add_manual_order_row():
|
||||
require_manual_db()
|
||||
manual_db_call("append", [[get_current_time_info()[2]] + [""] * 14])
|
||||
return {"status": "success"}
|
||||
|
||||
|
||||
@app.patch("/api/manual/orders/cells")
|
||||
def patch_manual_order_cells(payload: ManualCellChanges):
|
||||
require_manual_db()
|
||||
return {"rows": manual_db_call("patch_cells", [dict(change) for change in payload.changes])}
|
||||
|
||||
|
||||
@app.post("/api/manual/orders/archive")
|
||||
def archive_manual_order_rows(payload: ManualRowsToArchive):
|
||||
require_manual_db()
|
||||
if not payload.rows or len(payload.rows) > 2000:
|
||||
raise HTTPException(status_code=400, detail="삭제할 행을 선택해주세요.")
|
||||
manual_db_call("archive_rows", [dict(row) for row in payload.rows])
|
||||
return {"status": "success"}
|
||||
|
||||
|
||||
@app.get("/api/manual/orders/exports")
|
||||
def get_manual_exports():
|
||||
require_manual_db()
|
||||
return manual_db_call("exports")
|
||||
|
||||
|
||||
@app.get("/api/manual/orders/exports/{export_id}")
|
||||
def get_manual_export(export_id: uuid.UUID):
|
||||
require_manual_db()
|
||||
filename, content = manual_db_call("exports", str(export_id))
|
||||
return manual_file_response(content, filename)
|
||||
|
||||
|
||||
@app.post("/api/sheet/download_and_clear")
|
||||
@google_worker
|
||||
@manual_worker
|
||||
def download_and_clear_sheet():
|
||||
if MANUAL_ORDERS_BACKEND == "postgres":
|
||||
now = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=9)))
|
||||
weekdays = ["월요일", "화요일", "수요일", "목요일", "금요일", "토요일", "일요일"]
|
||||
filename = f"{now:%m}월 {now:%d}일 ({weekdays[now.weekday()]}) 5 수동발주.xlsx"
|
||||
content, export_id = manual_db_call("export_and_archive", filename)
|
||||
return manual_file_response(content, filename, export_id)
|
||||
try:
|
||||
scopes = ['https://www.googleapis.com/auth/spreadsheets', 'https://www.googleapis.com/auth/drive']
|
||||
creds = load_service_account_credentials(scopes)
|
||||
@@ -994,11 +1112,14 @@ def delete_manual_order_rows(timestamp):
|
||||
|
||||
|
||||
@app.delete("/api/manual/history/records/{record_id}")
|
||||
@google_worker
|
||||
@manual_worker
|
||||
@google_history_access
|
||||
def delete_manual_history_record(record_id: int):
|
||||
if HISTORY_BACKEND != "postgres":
|
||||
raise HTTPException(status_code=409, detail="내역 화면을 새로고침해주세요.")
|
||||
if MANUAL_ORDERS_BACKEND == "postgres":
|
||||
manual_db_call("delete_history", record_id)
|
||||
return {"status": "success"}
|
||||
record = history_db_call("get_manual", record_id)
|
||||
if record is None:
|
||||
raise HTTPException(status_code=404, detail="이미 삭제된 내역입니다. 새로고침해주세요.")
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
"""Editable manual-order queue, with atomic cell updates and recoverable exports."""
|
||||
|
||||
import io
|
||||
import re
|
||||
import uuid
|
||||
from contextlib import closing
|
||||
|
||||
from openpyxl import Workbook
|
||||
from openpyxl.styles import Alignment, Font, PatternFill
|
||||
from psycopg2.extras import Json, execute_values
|
||||
|
||||
from history_store import normalize_record
|
||||
from settings_store import PostgresSettingsStore, SettingsAlreadyInitialized, SettingsNotInitialized
|
||||
|
||||
|
||||
HEADERS = ["주문날짜", "번호", "주문번호", "수령인명", "상품코드", "상품명", "주문수량", "주소", "우편번호",
|
||||
"수령인 전화번호", "수령인 휴대폰", "배송시 요구사항", "송장번호", "주문처", "비고"]
|
||||
|
||||
|
||||
class CellConflict(RuntimeError):
|
||||
def __init__(self, rows):
|
||||
self.rows = rows
|
||||
super().__init__("다른 사용자가 수정한 셀이 있습니다. 최신값을 확인해주세요.")
|
||||
|
||||
|
||||
def validate_source(source):
|
||||
if not isinstance(source, dict) or source.get("kind") != "corm-manual-orders":
|
||||
raise ValueError("수동발주 원본이 필요합니다.")
|
||||
headers, rows = source.get("headers"), source.get("rows")
|
||||
if not isinstance(headers, list) or len(headers) < 15 or len(headers) > 100 or not all(isinstance(x, str) for x in headers):
|
||||
raise ValueError("원본 열 구성을 확인해주세요.")
|
||||
if not isinstance(rows, list) or not all(isinstance(row, list) and len(row) <= len(headers)
|
||||
and all(isinstance(x, str) and "\x00" not in x for x in row) for row in rows):
|
||||
raise ValueError("원본 셀 형식을 확인해주세요.")
|
||||
return headers, [row + [""] * (len(headers) - len(row)) for row in rows]
|
||||
|
||||
|
||||
def build_xlsx(headers, rows):
|
||||
workbook = Workbook()
|
||||
sheet = workbook.active
|
||||
sheet.title = "수동 발주"
|
||||
for index, values in enumerate([headers] + rows, start=1):
|
||||
for column, value in enumerate(values, start=1):
|
||||
numeric = index > 1 and column in (3, 7) and re.fullmatch(r"-?(?:0|[1-9][0-9]{0,14})", value.replace(",", ""))
|
||||
cell = sheet.cell(index, column, int(value.replace(",", "")) if numeric else value)
|
||||
# IDs, phone numbers, leading zeros and '=' always remain literal text.
|
||||
if not numeric:
|
||||
cell.data_type = "s"
|
||||
cell.alignment = Alignment(vertical="top", wrap_text=True)
|
||||
if index == 1:
|
||||
cell.font = Font(bold=True, color="FFFFFF")
|
||||
cell.fill = PatternFill("solid", fgColor="334155")
|
||||
sheet.freeze_panes = "A2"
|
||||
sheet.auto_filter.ref = sheet.dimensions
|
||||
for column in sheet.columns:
|
||||
sheet.column_dimensions[column[0].column_letter].width = 21
|
||||
sheet.column_dimensions["H"].width = 45
|
||||
sheet.column_dimensions["O"].width = 45
|
||||
output = io.BytesIO()
|
||||
workbook.save(output)
|
||||
return output.getvalue()
|
||||
|
||||
|
||||
class ManualOrderStore:
|
||||
def __init__(self, config):
|
||||
self.database = PostgresSettingsStore(config)
|
||||
|
||||
def _connect(self):
|
||||
return self.database._connect()
|
||||
|
||||
@staticmethod
|
||||
def _schema(cursor):
|
||||
cursor.execute("""CREATE TABLE IF NOT EXISTS corm_manual_sheet (
|
||||
id SMALLINT PRIMARY KEY CHECK(id=1), headers JSONB NOT NULL, source TEXT NOT NULL,
|
||||
imported_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP)""")
|
||||
cursor.execute("""CREATE TABLE IF NOT EXISTS corm_manual_orders (
|
||||
id BIGSERIAL PRIMARY KEY, order_key TEXT NOT NULL, cells JSONB NOT NULL,
|
||||
version BIGINT NOT NULL DEFAULT 1, archived_at TIMESTAMPTZ,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP)""")
|
||||
cursor.execute("CREATE INDEX IF NOT EXISTS corm_manual_orders_active ON corm_manual_orders(id) WHERE archived_at IS NULL")
|
||||
cursor.execute("CREATE INDEX IF NOT EXISTS corm_manual_orders_key ON corm_manual_orders(order_key)")
|
||||
cursor.execute("""CREATE TABLE IF NOT EXISTS corm_manual_exports (
|
||||
id UUID PRIMARY KEY, filename TEXT NOT NULL, content BYTEA NOT NULL,
|
||||
row_ids JSONB NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP)""")
|
||||
|
||||
def check_ready(self):
|
||||
self.list_rows()
|
||||
|
||||
def list_rows(self):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT headers FROM corm_manual_sheet WHERE id=1")
|
||||
metadata = cursor.fetchone()
|
||||
if metadata is None:
|
||||
raise SettingsNotInitialized("수동발주 이전을 먼저 실행해주세요.")
|
||||
cursor.execute("SELECT id, cells, version FROM corm_manual_orders WHERE archived_at IS NULL ORDER BY id")
|
||||
return {"headers": metadata[0], "rows": [dict(zip(("id", "cells", "version"), row)) for row in cursor.fetchall()]}
|
||||
|
||||
def import_source(self, source, label):
|
||||
headers, rows = validate_source(source)
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
self._schema(cursor)
|
||||
cursor.execute("LOCK TABLE corm_manual_sheet, corm_manual_orders IN EXCLUSIVE MODE")
|
||||
cursor.execute("SELECT EXISTS(SELECT 1 FROM corm_manual_sheet) OR EXISTS(SELECT 1 FROM corm_manual_orders)")
|
||||
if cursor.fetchone()[0]:
|
||||
raise SettingsAlreadyInitialized("기존 발주 DB를 덮어쓰지 않았습니다.")
|
||||
cursor.execute("INSERT INTO corm_manual_sheet(id,headers,source) VALUES(1,%s,%s)", (Json(headers), label))
|
||||
if rows:
|
||||
execute_values(cursor, "INSERT INTO corm_manual_orders(order_key,cells) VALUES %s",
|
||||
[("legacy:" + row[0] if row[0] else "legacy-row:" + str(i), Json(row)) for i, row in enumerate(rows)])
|
||||
cursor.execute("SELECT cells FROM corm_manual_orders ORDER BY id")
|
||||
if [row[0] for row in cursor.fetchall()] != rows:
|
||||
raise RuntimeError("발주 원본 검증 실패.")
|
||||
|
||||
def append(self, rows, history=None):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT headers FROM corm_manual_sheet WHERE id=1")
|
||||
metadata = cursor.fetchone()
|
||||
if not metadata:
|
||||
raise SettingsNotInitialized("수동발주 이전이 필요합니다.")
|
||||
key = str(uuid.uuid4())
|
||||
_, normalized = validate_source({"kind": "corm-manual-orders", "headers": metadata[0],
|
||||
"rows": [[str(x) for x in row] for row in rows]})
|
||||
for row in normalized:
|
||||
cursor.execute("INSERT INTO corm_manual_orders(order_key,cells) VALUES(%s,%s)", (key, Json(row)))
|
||||
if history is not None:
|
||||
record = normalize_record("manual", {**history, "manual_order_key": key})
|
||||
cursor.execute("INSERT INTO corm_manual_history(occurred_at,payload) VALUES(%s,%s)", (record["timestamp"], Json(record)))
|
||||
return key
|
||||
|
||||
def patch_cells(self, changes):
|
||||
if not changes or len(changes) > 2000 or len({(c["id"], c["column"]) for c in changes}) != len(changes):
|
||||
raise ValueError("한 번에 수정할 셀을 확인해주세요.")
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT id,cells,version FROM corm_manual_orders WHERE id=ANY(%s) AND archived_at IS NULL ORDER BY id FOR UPDATE",
|
||||
(sorted({c["id"] for c in changes}),))
|
||||
rows = {row[0]: {"id": row[0], "cells": row[1], "version": row[2]} for row in cursor.fetchall()}
|
||||
if len(rows) != len({c["id"] for c in changes}):
|
||||
raise LookupError("이미 내려받았거나 삭제된 행입니다. 표를 새로고침해주세요.")
|
||||
conflicts = []
|
||||
for change in changes:
|
||||
row = rows[change["id"]]
|
||||
column = change["column"]
|
||||
if column < 0 or column >= len(row["cells"]) or len(change["value"]) > 20000 or "\x00" in change["value"]:
|
||||
raise ValueError("셀 내용을 확인해주세요.")
|
||||
actual = row["cells"][column]
|
||||
if actual != change["previous_value"] and actual != change["value"]:
|
||||
conflicts.append({"id": row["id"], "column": column, "value": actual})
|
||||
if conflicts:
|
||||
raise CellConflict(conflicts)
|
||||
for change in changes:
|
||||
rows[change["id"]]["cells"][change["column"]] = change["value"]
|
||||
for row in rows.values():
|
||||
cursor.execute("UPDATE corm_manual_orders SET cells=%s,version=version+1 WHERE id=%s RETURNING version", (Json(row["cells"]), row["id"]))
|
||||
row["version"] = cursor.fetchone()[0]
|
||||
return list(rows.values())
|
||||
|
||||
def archive_rows(self, rows):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT id,version FROM corm_manual_orders WHERE id=ANY(%s) AND archived_at IS NULL ORDER BY id FOR UPDATE", ([r["id"] for r in rows],))
|
||||
versions = dict(cursor.fetchall())
|
||||
if any(versions.get(r["id"]) != r["version"] for r in rows):
|
||||
raise CellConflict([])
|
||||
cursor.execute("UPDATE corm_manual_orders SET archived_at=CURRENT_TIMESTAMP WHERE id=ANY(%s)", ([r["id"] for r in rows],))
|
||||
|
||||
def export_and_archive(self, filename):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT headers FROM corm_manual_sheet WHERE id=1")
|
||||
headers = cursor.fetchone()[0]
|
||||
cursor.execute("SELECT id,cells FROM corm_manual_orders WHERE archived_at IS NULL ORDER BY id FOR UPDATE")
|
||||
rows = cursor.fetchall()
|
||||
content = build_xlsx(headers, [row[1] for row in rows])
|
||||
export_id = str(uuid.uuid4())
|
||||
cursor.execute("INSERT INTO corm_manual_exports(id,filename,content,row_ids) VALUES(%s,%s,%s,%s)",
|
||||
(export_id, filename, content, Json([row[0] for row in rows])))
|
||||
cursor.execute("UPDATE corm_manual_orders SET archived_at=CURRENT_TIMESTAMP WHERE id=ANY(%s)", ([row[0] for row in rows],))
|
||||
return content, export_id
|
||||
|
||||
def exports(self, export_id=None):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
if export_id:
|
||||
cursor.execute("SELECT filename,content FROM corm_manual_exports WHERE id=%s", (export_id,))
|
||||
row = cursor.fetchone()
|
||||
if row is None:
|
||||
raise LookupError("다운로드 기록이 없습니다.")
|
||||
return row[0], bytes(row[1])
|
||||
cursor.execute("SELECT id,filename,created_at FROM corm_manual_exports ORDER BY created_at DESC LIMIT 10")
|
||||
return [{"id": str(r[0]), "filename": r[1], "created_at": r[2].isoformat()} for r in cursor.fetchall()]
|
||||
|
||||
def delete_history(self, record_id):
|
||||
with closing(self._connect()) as connection, connection, connection.cursor() as cursor:
|
||||
cursor.execute("SELECT payload FROM corm_manual_history WHERE id=%s FOR UPDATE", (record_id,))
|
||||
record = cursor.fetchone()
|
||||
if record is None:
|
||||
raise LookupError("이미 삭제된 내역입니다.")
|
||||
payload = record[0]
|
||||
key = payload.get("manual_order_key")
|
||||
if not key:
|
||||
cursor.execute("SELECT count(*) FROM corm_manual_history WHERE occurred_at=%s", (payload["timestamp"],))
|
||||
if cursor.fetchone()[0] > 1:
|
||||
raise ValueError("같은 일시의 내역이 여러 건입니다. 수동발주 표에서 대상 주문을 먼저 확인해주세요.")
|
||||
key = "legacy:" + payload["timestamp"]
|
||||
cursor.execute("UPDATE corm_manual_orders SET archived_at=CURRENT_TIMESTAMP WHERE order_key=%s AND archived_at IS NULL", (key,))
|
||||
cursor.execute("DELETE FROM corm_manual_history WHERE id=%s", (record_id,))
|
||||
@@ -0,0 +1,94 @@
|
||||
"""Operator-run migration of the active manual-order sheet; source stays intact."""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
|
||||
import psycopg2
|
||||
import requests
|
||||
from dotenv import set_key
|
||||
|
||||
from manual_orders import ManualOrderStore, validate_source
|
||||
from settings_store import settings_db_config, SettingsNotInitialized
|
||||
from settings_migrate import save_snapshot, fingerprint
|
||||
|
||||
|
||||
def read_source():
|
||||
if os.getenv("MANUAL_ORDERS_BACKEND", "google") == "postgres":
|
||||
data = ManualOrderStore(settings_db_config()).list_rows()
|
||||
return {"kind": "corm-manual-orders", "headers": data["headers"], "rows": [r["cells"] for r in data["rows"]]}
|
||||
import main
|
||||
worksheet = main.get_gspread_client().open_by_key(main.MANUAL_SPREADSHEET_ID).get_worksheet(0)
|
||||
values = worksheet.get_all_values()
|
||||
if not values:
|
||||
raise ValueError("수동 발주 시트의 머리글을 확인해주세요.")
|
||||
width = max(len(row) for row in values)
|
||||
source = {"kind": "corm-manual-orders", "headers": values[0] + [""] * (width - len(values[0])), "rows": values[1:]}
|
||||
headers, rows = validate_source(source)
|
||||
return {"kind": "corm-manual-orders", "headers": headers, "rows": rows}
|
||||
|
||||
|
||||
def migrate(directory):
|
||||
payload = json.loads((Path(directory) / "manual-orders-source.json").read_text(encoding="utf-8"))
|
||||
source = payload["rows"]
|
||||
if payload.get("format") != 1 or payload.get("sha256") != fingerprint(source):
|
||||
raise ValueError("원본 백업 체크섬이 다릅니다.")
|
||||
headers, rows = validate_source(source)
|
||||
store = ManualOrderStore(settings_db_config())
|
||||
try:
|
||||
stored = store.list_rows()
|
||||
except (SettingsNotInitialized, psycopg2.errors.UndefinedTable):
|
||||
store.import_source(source, "manual-order-sheet")
|
||||
stored = store.list_rows()
|
||||
if stored["headers"] != headers or [r["cells"] for r in stored["rows"]] != rows:
|
||||
raise RuntimeError("기존 발주 DB와 원본이 다릅니다. 덮어쓰지 않고 중단합니다.")
|
||||
print(f"수동발주 {len(rows)}행 · {len(headers)}열 전체 검증 완료.")
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("step", choices=("snapshot", "migrate", "environment", "probe"))
|
||||
parser.add_argument("--directory", default="/backups")
|
||||
args = parser.parse_args(argv)
|
||||
try:
|
||||
if args.step == "snapshot":
|
||||
source = read_source()
|
||||
path = Path(args.directory) / "manual-orders-source.json"
|
||||
save_snapshot(path, source, "manual-orders")
|
||||
owner = path.parent.stat()
|
||||
os.chown(path, owner.st_uid, owner.st_gid)
|
||||
print(f"발주 원본 백업 완료: {len(source['rows'])}행.")
|
||||
elif args.step == "migrate":
|
||||
migrate(args.directory)
|
||||
elif args.step == "environment":
|
||||
path = Path("/deploy/.env")
|
||||
owner = path.stat()
|
||||
set_key(path, "MANUAL_ORDERS_BACKEND", "postgres", quote_mode="never")
|
||||
os.chmod(path, 0o600)
|
||||
os.chown(path, owner.st_uid, owner.st_gid)
|
||||
print("수동발주 저장소를 DB로 전환했습니다.")
|
||||
else:
|
||||
if os.getenv("MANUAL_ORDERS_BACKEND") != "postgres":
|
||||
raise RuntimeError("수동발주 저장소가 아직 postgres가 아닙니다.")
|
||||
ManualOrderStore(settings_db_config()).check_ready()
|
||||
token = os.getenv("INTERNAL_SERVICE_TOKEN", "")
|
||||
if not token:
|
||||
raise RuntimeError("기존 서비스 토큰이 필요합니다.")
|
||||
response = requests.get("http://127.0.0.1:8002/api/manual/orders", headers={"X-Service-Token": token}, timeout=5)
|
||||
response.raise_for_status()
|
||||
if not isinstance(response.json().get("rows"), list):
|
||||
raise RuntimeError("발주 API 검증 실패.")
|
||||
print("수동발주 DB·조회 API 정상.")
|
||||
return 0
|
||||
except Exception as exc:
|
||||
if args.step == "probe" and isinstance(exc, requests.exceptions.ConnectionError):
|
||||
print("앱 시작 응답을 기다리는 중입니다.", file=sys.stderr)
|
||||
return 1
|
||||
print(f"수동발주 전환 단계 실패: {args.step} ({type(exc).__name__}). 원본·DB·백업을 확인해주세요.", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,29 @@
|
||||
.manual-grid-panel { display:flex; flex-direction:column; width:100%; min-width:0; height:100%; padding:16px; gap:10px; box-sizing:border-box; background:#f8fafc; }
|
||||
.manual-grid-toolbar,.manual-grid-actions,.manual-grid-info { display:flex; align-items:center; gap:10px; flex-wrap:wrap; }
|
||||
.manual-grid-toolbar { justify-content:space-between; }
|
||||
.manual-grid-toolbar strong { font-size:18px; color:#1e293b; }
|
||||
.manual-grid-actions .btn { padding:7px 12px; font-size:13px; }
|
||||
.manual-muted,.manual-grid-info { color:#64748b; font-size:12px; }
|
||||
.manual-grid-info > :first-child { margin-right:auto; }
|
||||
#manual-save-status[data-state="error"] { color:#b91c1c; font-weight:600; }
|
||||
#manual-save-status[data-state="saving"] { color:#1d4ed8; }
|
||||
#manual-save-retry { border:1px solid #fecaca; background:#fff1f2; padding:3px 9px; border-radius:4px; cursor:pointer; }
|
||||
.manual-grid-scroll { flex:1; min-height:200px; overflow:auto; background:white; border:1px solid #cbd5e1; border-radius:8px; }
|
||||
table.manual-grid { border-collapse:separate; border-spacing:0; table-layout:fixed; width:max-content; min-width:100%; margin:0; font-size:13px; color:#1e293b; }
|
||||
.manual-grid th,.manual-grid td { box-sizing:border-box; min-width:150px; width:150px; max-width:150px; padding:7px 9px; border:0; border-right:1px solid #e2e8f0; border-bottom:1px solid #e2e8f0; text-align:left; vertical-align:top; white-space:pre-wrap; overflow-wrap:anywhere; line-height:20px; background:white; }
|
||||
.manual-grid th { position:sticky; z-index:2; top:24px; background:#f1f5f9; font-weight:600; height:35px; }
|
||||
.manual-grid thead tr:first-child th { top:0; height:24px; padding:1px 9px; text-align:center; color:#64748b; font-size:11px; background:#e9eef5; }
|
||||
.manual-grid td:first-child,.manual-grid th:first-child { position:sticky; left:0; min-width:65px; width:65px; max-width:65px; background:#f1f5f9; color:#64748b; text-align:center; z-index:1; white-space:nowrap; }
|
||||
.manual-grid th:first-child { z-index:3; }
|
||||
.manual-grid td:nth-child(9),.manual-grid th:nth-child(9),.manual-grid td:nth-child(16),.manual-grid th:nth-child(16) { min-width:280px; width:280px; max-width:280px; }
|
||||
.manual-grid td[contenteditable]:focus { outline:2px solid #2563eb; outline-offset:-2px; background:#eff6ff; }
|
||||
.manual-grid td[data-dirty="true"] { background:#fffbeb; }
|
||||
.manual-grid td[data-error="true"] { background:#fff1f2; box-shadow:inset 0 -2px #e11d48; }
|
||||
.manual-grid tbody tr:has(input:checked) td { background:#eff6ff; }
|
||||
#manual-grid-empty { color:#64748b; padding:36px; text-align:center; }
|
||||
#manual-exports { position:relative; font-size:13px; }
|
||||
#manual-exports summary { cursor:pointer; padding:7px; }
|
||||
#manual-export-list { position:absolute; right:0; top:25px; min-width:270px; max-height:300px; overflow:auto; background:white; box-shadow:0 8px 24px #0f172a26; border:1px solid #e2e8f0; border-radius:6px; padding:10px; list-style:none; z-index:5; }
|
||||
#manual-export-list li { padding:6px; }
|
||||
#manual-export-list a { color:#1d4ed8; text-decoration:none; }
|
||||
@media(max-width:800px) { .manual-grid-panel { padding:8px; } .manual-grid-actions { gap:5px; } }
|
||||
+6
-2
@@ -30,7 +30,7 @@ async function settingsErrorMessage(response) {
|
||||
async function readHistoryResponse(response) {
|
||||
const data = await response.json().catch(() => ({}));
|
||||
if (!response.ok) {
|
||||
throw new Error(typeof data.detail === 'string' ? data.detail : '내역 처리를 확인하지 못했습니다. 새로고침해주세요.');
|
||||
throw new Error(typeof data.detail === 'string' ? data.detail : data.detail?.message || '내역 처리를 확인하지 못했습니다. 새로고침해주세요.');
|
||||
}
|
||||
return data;
|
||||
}
|
||||
@@ -1750,7 +1750,7 @@ document.addEventListener('DOMContentLoaded', () => {
|
||||
if (data.status === 'success') {
|
||||
if (!url.includes('submit')) {
|
||||
alert(data.message);
|
||||
} else if (data.timestamp) {
|
||||
} else if (data.timestamp && !data.history_saved) {
|
||||
const histData = {
|
||||
timestamp: data.timestamp,
|
||||
customer_name: submitPayload.customer_name,
|
||||
@@ -1766,6 +1766,7 @@ document.addEventListener('DOMContentLoaded', () => {
|
||||
}
|
||||
}).catch(error => alert('발주는 완료됐지만 수동발주내역 저장을 확인하지 못했습니다. ' + error.message));
|
||||
}
|
||||
if (data.history_saved && typeof loadManualHistory === 'function') loadManualHistory();
|
||||
|
||||
// Copy the same text that is written to the sheet remarks/comparison field.
|
||||
if (data.clipboard_text) {
|
||||
@@ -1784,6 +1785,7 @@ document.addEventListener('DOMContentLoaded', () => {
|
||||
if (url.includes('submit')) {
|
||||
const iframe = document.querySelector('#manual-tab iframe');
|
||||
if (iframe) iframe.src = iframe.src;
|
||||
window.manualGrid?.refresh().catch(error => alert(error.message));
|
||||
}
|
||||
} else {
|
||||
alert("Error: " + data.detail);
|
||||
@@ -1803,6 +1805,7 @@ document.addEventListener('DOMContentLoaded', () => {
|
||||
document.getElementById('btn-submit-ellen').addEventListener('click', () => submitOrder('/api/order/submit', true));
|
||||
|
||||
document.getElementById('btn-download-sheet').addEventListener('click', () => {
|
||||
if (window.manualGrid) { window.manualGrid.download().catch(error => alert(error.message)); return; }
|
||||
if (!confirm("수동발주로 입력한 자료는 엑셀 파일로 저장되며, 입력된 수동발주 내용은 사라집니다.\n진행하시겠습니까?")) return;
|
||||
|
||||
const btn = document.getElementById('btn-download-sheet');
|
||||
@@ -2334,6 +2337,7 @@ document.addEventListener('DOMContentLoaded', () => {
|
||||
window.loadManualHistory();
|
||||
const iframe = document.querySelector('#manual-tab iframe');
|
||||
if (iframe) iframe.src = iframe.src;
|
||||
window.manualGrid?.refresh().catch(error => alert(error.message));
|
||||
})
|
||||
.catch(error => {
|
||||
alert(error.message || "삭제 중 오류가 발생했습니다.");
|
||||
|
||||
@@ -0,0 +1,193 @@
|
||||
(() => {
|
||||
const panel = document.getElementById('manual-grid-panel');
|
||||
if (!panel) return;
|
||||
const table = document.getElementById('manual-grid');
|
||||
const status = document.getElementById('manual-save-status');
|
||||
const retry = document.getElementById('manual-save-retry');
|
||||
const pending = new Map();
|
||||
let rows = new Map(), headers = [], saving = null, sentKeys = new Set(), timer, failure = null, locked = false, loadGeneration = 0;
|
||||
const keyOf = (id, column) => `${id}:${column}`;
|
||||
const cellAt = (id, column) => table.querySelector(`td[data-id="${id}"][data-column="${column}"]`);
|
||||
function message(text, state = '') { status.textContent = text; status.dataset.state = state; }
|
||||
async function request(url, options) {
|
||||
const response = await fetch(url, options);
|
||||
if (!response.ok) {
|
||||
const data = await response.json().catch(() => ({}));
|
||||
const error = new Error(typeof data.detail === 'string' ? data.detail : data.detail?.message || '처리를 확인하지 못했습니다. 다시 시도해주세요.');
|
||||
error.conflicts = data.detail?.conflicts;
|
||||
throw error;
|
||||
}
|
||||
return response;
|
||||
}
|
||||
const jsonOptions = (method, data) => ({method, headers: {'Content-Type': 'application/json'}, body: JSON.stringify(data)});
|
||||
function queueCell(td) {
|
||||
const id = Number(td.dataset.id), column = Number(td.dataset.column), key = keyOf(id, column);
|
||||
const value = td.textContent.replace(/\r\n/g, '\n');
|
||||
const previous = pending.get(key)?.previous_value ?? rows.get(id).cells[column];
|
||||
if (value === rows.get(id).cells[column] && !sentKeys.has(key)) pending.delete(key);
|
||||
else pending.set(key, {id, column, value, previous_value: previous});
|
||||
td.dataset.dirty = String(pending.has(key));
|
||||
delete td.dataset.error;
|
||||
if (!failure) message('입력 중 · 자동 저장 대기', 'saving');
|
||||
clearTimeout(timer);
|
||||
timer = setTimeout(() => { if (!failure) flush().catch(() => {}); }, 450);
|
||||
}
|
||||
function applyRows(updated, keys) {
|
||||
for (const row of updated) {
|
||||
rows.set(row.id, row);
|
||||
row.cells.forEach((value, column) => {
|
||||
const key = keyOf(row.id, column), queued = pending.get(key), td = cellAt(row.id, column);
|
||||
if (queued && keys.has(key)) queued.previous_value = value;
|
||||
if (td && !queued) { if (td.textContent !== value) td.textContent = value; delete td.dataset.dirty; delete td.dataset.error; }
|
||||
});
|
||||
}
|
||||
}
|
||||
function flush() {
|
||||
clearTimeout(timer);
|
||||
if (saving) return saving;
|
||||
if (failure) return Promise.reject(failure);
|
||||
saving = (async () => {
|
||||
while (pending.size) {
|
||||
const batch = [...pending.values()].slice(0, 1000);
|
||||
sentKeys = new Set(batch.map(c => keyOf(c.id, c.column)));
|
||||
for (const key of sentKeys) pending.delete(key);
|
||||
message('저장 중…', 'saving');
|
||||
try {
|
||||
const result = await (await request('/api/manual/orders/cells', jsonOptions('PATCH', {changes: batch}))).json();
|
||||
applyRows(result.rows, sentKeys);
|
||||
} catch (error) {
|
||||
for (const change of batch) {
|
||||
const key = keyOf(change.id, change.column), newer = pending.get(key);
|
||||
pending.set(key, {...change, value: newer?.value ?? change.value});
|
||||
const td = cellAt(change.id, change.column);
|
||||
if (td) td.dataset.error = 'true';
|
||||
}
|
||||
failure = error;
|
||||
retry.hidden = false;
|
||||
message('저장하지 못한 입력이 있습니다 · ' + error.message, 'error');
|
||||
throw error;
|
||||
} finally { sentKeys = new Set(); }
|
||||
}
|
||||
message('모든 변경사항 저장됨');
|
||||
retry.hidden = true;
|
||||
})().finally(() => { saving = null; });
|
||||
return saving;
|
||||
}
|
||||
retry.addEventListener('click', () => {
|
||||
if (failure?.conflicts?.length) {
|
||||
const preview = failure.conflicts.slice(0, 3).map(c => `${headers[c.column]}: 최신값 「${c.value}」 / 내 입력 「${pending.get(keyOf(c.id, c.column))?.value ?? ''}」`).join('\n');
|
||||
const keepMine = confirm(preview + '\n\n확인: 내 입력으로 변경\n취소: 충돌한 셀은 최신값 사용');
|
||||
for (const conflict of failure.conflicts) {
|
||||
const key = keyOf(conflict.id, conflict.column), change = pending.get(key), td = cellAt(conflict.id, conflict.column);
|
||||
rows.get(conflict.id).cells[conflict.column] = conflict.value;
|
||||
if (keepMine && change) change.previous_value = conflict.value;
|
||||
else { pending.delete(key); if (td) { td.textContent = conflict.value; delete td.dataset.dirty; delete td.dataset.error; } }
|
||||
}
|
||||
}
|
||||
failure = null;
|
||||
flush().catch(() => {});
|
||||
});
|
||||
function columnLetter(index) { let out = ''; for (let n = index + 1; n; n = Math.floor((n - 1) / 26)) out = String.fromCharCode(65 + (n - 1) % 26) + out; return out; }
|
||||
function render(data) {
|
||||
headers = data.headers;
|
||||
rows = new Map(data.rows.map(row => [row.id, row]));
|
||||
const head = table.tHead, body = table.tBodies[0];
|
||||
head.replaceChildren(); body.replaceChildren();
|
||||
const letters = head.insertRow(), titles = head.insertRow();
|
||||
for (const [i, title] of ['', ...headers].entries()) {
|
||||
const letter = document.createElement('th'), label = document.createElement('th');
|
||||
letter.textContent = i ? columnLetter(i - 1) : '';
|
||||
if (i) label.textContent = title;
|
||||
else { const all = document.createElement('input'); all.type = 'checkbox'; all.setAttribute('aria-label', '모든 행 선택'); all.onchange = () => body.querySelectorAll('input').forEach(box => { box.checked = all.checked; }); label.append(all); }
|
||||
letters.append(letter); titles.append(label);
|
||||
}
|
||||
data.rows.forEach((row, index) => {
|
||||
const tr = body.insertRow(), number = tr.insertCell(), check = document.createElement('input');
|
||||
check.type = 'checkbox'; check.dataset.rowId = row.id; check.setAttribute('aria-label', `${index + 1}행 선택`);
|
||||
number.append(check, document.createTextNode(` ${index + 1}`));
|
||||
row.cells.forEach((value, column) => {
|
||||
const td = tr.insertCell(); td.textContent = value; td.contentEditable = 'plaintext-only'; td.tabIndex = 0;
|
||||
td.dataset.id = row.id; td.dataset.column = column; td.setAttribute('aria-label', `${index + 1}행 ${headers[column] || columnLetter(column)}`);
|
||||
td.addEventListener('input', event => { if (!event.isComposing) queueCell(td); });
|
||||
td.addEventListener('compositionend', () => queueCell(td));
|
||||
td.addEventListener('blur', () => { if (!failure) flush().catch(() => {}); });
|
||||
td.addEventListener('keydown', event => {
|
||||
if (event.isComposing) return;
|
||||
if (event.key === 'Enter' && event.altKey) return;
|
||||
if (event.key === 'Tab' || event.key === 'Enter') {
|
||||
event.preventDefault();
|
||||
const ids = [...rows.keys()], rowIndex = ids.indexOf(row.id);
|
||||
let nextRow = rowIndex, nextColumn = column;
|
||||
if (event.key === 'Enter') nextRow += event.shiftKey ? -1 : 1;
|
||||
else nextColumn += event.shiftKey ? -1 : 1;
|
||||
if (nextColumn >= headers.length) { nextColumn = 0; nextRow++; }
|
||||
if (nextColumn < 0) { nextColumn = headers.length - 1; nextRow--; }
|
||||
cellAt(ids[nextRow], nextColumn)?.focus();
|
||||
}
|
||||
if (event.key === 'Escape') { td.textContent = rows.get(row.id).cells[column]; queueCell(td); td.blur(); }
|
||||
});
|
||||
td.addEventListener('paste', event => {
|
||||
event.preventDefault();
|
||||
const text = event.clipboardData.getData('text/plain').replace(/\r\n/g, '\n').replace(/\n$/, '');
|
||||
const matrix = text.split('\n').map(line => line.split('\t')), ids = [...rows.keys()], start = ids.indexOf(row.id);
|
||||
if (matrix.length + start > ids.length || matrix.some(line => line.length + column > headers.length) || matrix.reduce((n, line) => n + line.length, 0) > 1000) {
|
||||
alert('붙여넣을 범위를 확인해주세요. 필요한 행을 먼저 추가하고 한 번에 1,000셀 이내로 붙여넣으세요.'); return;
|
||||
}
|
||||
matrix.forEach((line, r) => line.forEach((text, c) => { const target = cellAt(ids[start + r], column + c); target.textContent = text; queueCell(target); }));
|
||||
});
|
||||
});
|
||||
});
|
||||
document.getElementById('manual-row-count').textContent = `${data.rows.length.toLocaleString()}행`;
|
||||
document.getElementById('manual-grid-empty').hidden = data.rows.length !== 0;
|
||||
}
|
||||
async function load() {
|
||||
if (pending.size || saving || locked) return;
|
||||
const generation = ++loadGeneration;
|
||||
const data = await (await request('/api/manual/orders')).json();
|
||||
if (generation !== loadGeneration || pending.size || saving || locked || table.contains(document.activeElement)) return;
|
||||
render(data); message('모든 변경사항 저장됨');
|
||||
}
|
||||
async function action(work) {
|
||||
if (locked) return;
|
||||
locked = true;
|
||||
loadGeneration++;
|
||||
table.querySelectorAll('[contenteditable]').forEach(td => { td.contentEditable = 'false'; });
|
||||
try { await flush(); await work(); }
|
||||
finally { locked = false; table.querySelectorAll('[contenteditable]').forEach(td => { td.contentEditable = 'plaintext-only'; }); }
|
||||
await load();
|
||||
}
|
||||
async function download() {
|
||||
if (!confirm('현재 발주를 엑셀로 내려받고 표를 비우시겠습니까? 내려받은 자료는 다운로드 기록에 보관됩니다.')) return;
|
||||
await action(async () => {
|
||||
const response = await request('/api/sheet/download_and_clear', {method: 'POST'});
|
||||
const blob = await response.blob(), a = document.createElement('a');
|
||||
a.href = URL.createObjectURL(blob);
|
||||
a.download = decodeURIComponent(response.headers.get('Content-Disposition')?.split("UTF-8''")[1] || '수동발주.xlsx');
|
||||
document.body.append(a); a.click(); a.remove(); setTimeout(() => URL.revokeObjectURL(a.href), 30000);
|
||||
});
|
||||
await loadExports();
|
||||
}
|
||||
async function loadExports() {
|
||||
const list = document.getElementById('manual-export-list');
|
||||
const exports = await (await request('/api/manual/orders/exports')).json(); list.replaceChildren();
|
||||
for (const item of exports) { const li = document.createElement('li'), a = document.createElement('a'); a.textContent = item.filename; a.href = (window.APP_BASE_PATH || '') + '/api/manual/orders/exports/' + item.id; li.append(a); list.append(li); }
|
||||
if (!exports.length) list.textContent = '아직 다운로드 기록이 없습니다.';
|
||||
}
|
||||
document.getElementById('manual-add-row').onclick = () => action(async () => { await request('/api/manual/orders', {method: 'POST'}); }).catch(error => message(error.message, 'error'));
|
||||
document.getElementById('manual-delete-rows').onclick = () => {
|
||||
const selected = [...table.querySelectorAll('input[data-row-id]:checked')].map(box => rows.get(Number(box.dataset.rowId)));
|
||||
if (!selected.length || !confirm(`${selected.length}개 행을 표에서 삭제하시겠습니까?`)) return;
|
||||
action(async () => { await request('/api/manual/orders/archive', jsonOptions('POST', {rows: selected.map(({id}) => ({id, version: rows.get(id).version}))})); }).catch(error => message(error.message, 'error'));
|
||||
};
|
||||
document.getElementById('manual-refresh').onclick = async () => {
|
||||
try { if (failure && confirm('저장하지 못한 입력이 있습니다. 필요한 내용을 복사해 두셨나요? 확인하면 미저장 입력을 버리고 새로 불러옵니다.')) { pending.clear(); failure = null; retry.hidden = true; } else await flush(); document.activeElement?.blur(); await load(); }
|
||||
catch (error) { message(error.message, 'error'); }
|
||||
};
|
||||
document.getElementById('manual-download').onclick = () => download().catch(error => message(error.message + ' · 다운로드 기록도 확인해주세요.', 'error'));
|
||||
document.getElementById('manual-exports').ontoggle = event => { if (event.target.open) loadExports().catch(error => message(error.message, 'error')); };
|
||||
window.manualGrid = {flush, refresh: async () => { await flush(); await load(); }, download};
|
||||
window.addEventListener('beforeunload', event => { if (pending.size || saving) { event.preventDefault(); event.returnValue = ''; } });
|
||||
document.querySelector('[data-tab="manual-tab"]')?.addEventListener('click', () => load().catch(error => message(error.message, 'error')));
|
||||
setInterval(() => { if (document.getElementById('manual-tab').classList.contains('active')) load().catch(error => message(error.message, 'error')); }, 10000);
|
||||
load().catch(error => message(error.message, 'error'));
|
||||
})();
|
||||
+26
-1
@@ -17,6 +17,7 @@
|
||||
/>
|
||||
<link rel="stylesheet" href="{{ root_path }}/static/css/cs_records.css?v=21" />
|
||||
<link rel="stylesheet" href="{{ root_path }}/static/css/return_filters.css?v=1" />
|
||||
<link rel="stylesheet" href="{{ root_path }}/static/css/manual_grid.css?v=1" />
|
||||
<script src="https://cdn.jsdelivr.net/npm/sortablejs@latest/Sortable.min.js"></script>
|
||||
<script>
|
||||
// 서브경로 호스팅 정보 — JS 가 fetch 시 prefix 로 사용한다.
|
||||
@@ -1428,6 +1429,28 @@
|
||||
class="tab-content"
|
||||
style="padding: 0"
|
||||
>
|
||||
{% if manual_orders_backend == 'postgres' %}
|
||||
<div id="manual-grid-panel" class="manual-grid-panel">
|
||||
<div class="manual-grid-toolbar">
|
||||
<div><strong>수동발주</strong> <span id="manual-row-count" class="manual-muted"></span></div>
|
||||
<div class="manual-grid-actions">
|
||||
<button type="button" id="manual-add-row" class="btn btn-secondary">+ 행 추가</button>
|
||||
<button type="button" id="manual-delete-rows" class="btn btn-secondary">선택 행 삭제</button>
|
||||
<button type="button" id="manual-refresh" class="btn btn-secondary">새로고침</button>
|
||||
<button type="button" id="manual-download" class="btn btn-primary">엑셀로 저장</button>
|
||||
<details id="manual-exports"><summary>다운로드 기록</summary><ul id="manual-export-list"></ul></details>
|
||||
</div>
|
||||
</div>
|
||||
<div class="manual-grid-info"><span>셀을 클릭해 입력하세요 · Enter ↓ · Tab → · 여러 셀 붙여넣기</span>
|
||||
<span id="manual-save-status" role="status" aria-live="polite">불러오는 중…</span>
|
||||
<button type="button" id="manual-save-retry" hidden>다시 시도</button>
|
||||
</div>
|
||||
<div class="manual-grid-scroll" id="manual-grid-scroll" tabindex="-1">
|
||||
<table id="manual-grid" class="manual-grid" aria-label="수동발주 편집 표"><thead></thead><tbody></tbody></table>
|
||||
<p id="manual-grid-empty" hidden>등록된 발주가 없습니다. 발주를 입력하거나 행을 추가하세요.</p>
|
||||
</div>
|
||||
</div>
|
||||
{% else %}
|
||||
<div style="padding: 10px 10px 0 10px; display: flex; justify-content: flex-end">
|
||||
<a
|
||||
href="https://docs.google.com/spreadsheets/d/1QxFtjDurPPZd8NmtXBy4XEUIzkf93aXD5Mlx5kB33xw/edit?gid=0#gid=0"
|
||||
@@ -1467,6 +1490,7 @@
|
||||
style="border: none; border-radius: 8px; box-shadow: var(--card-shadow)"
|
||||
></iframe>
|
||||
</div>
|
||||
{% endif %}
|
||||
</section>
|
||||
<!-- =========================
|
||||
GIFT SETTINGS TAB
|
||||
@@ -4006,7 +4030,8 @@
|
||||
{% include 'version_history.html' %}
|
||||
</main>
|
||||
</div>
|
||||
<script src="{{ root_path }}/static/js/app.js?v=72"></script>
|
||||
<script src="{{ root_path }}/static/js/app.js?v=73"></script>
|
||||
<script src="{{ root_path }}/static/js/manual_grid.js?v=1"></script>
|
||||
<script src="{{ root_path }}/static/js/cs_records.js?v=19"></script>
|
||||
<script src="{{ root_path }}/static/js/mall_event.js?v=7"></script>
|
||||
<script src="{{ root_path }}/static/js/milkrun_gsheet.js?v=8"></script>
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
// Optional browser QA: NODE_PATH must contain an installed playwright package.
|
||||
const {chromium} = require('playwright');
|
||||
const http = require('node:http');
|
||||
const fs = require('node:fs');
|
||||
const path = require('node:path');
|
||||
const assert = require('node:assert/strict');
|
||||
const {execFileSync} = require('node:child_process');
|
||||
const root = path.resolve(__dirname, '..');
|
||||
const headers = JSON.parse(execFileSync('python', ['-c', 'import json; from manual_orders import HEADERS; print(json.dumps(HEADERS))'], {cwd: root, encoding: 'utf8'}));
|
||||
const template = fs.readFileSync(path.join(root, 'templates/index.html'), 'utf8');
|
||||
const markup = template.match(/{% if manual_orders_backend == 'postgres' %}([\s\S]*?){% else %}/)[1];
|
||||
const html = `<!doctype html><meta charset="utf-8"><link rel="stylesheet" href="/static/css/styles.css"><link rel="stylesheet" href="/static/css/manual_grid.css"><style>body{margin:0;font-family:Arial,sans-serif}section{height:94vh;width:100%}</style><section id="manual-tab" class="active">${markup}</section><script src="/static/js/manual_grid.js"></script>`;
|
||||
let rows = [1, 2].map(id => ({id, version: 1, cells: headers.map((_, c) => c === 0 ? '2026-10-22 10:00:00' : c === 3 ? `테스트 고객 ${id}` : c === 4 ? 'TEST-0001' : c === 8 ? '00123' : '')}));
|
||||
let failNext = false, conflictNext = false, exported = false, nextId = 3;
|
||||
const server = http.createServer(async (req, res) => {
|
||||
const reply = (code, data) => { res.writeHead(code, {'Content-Type': 'application/json'}); res.end(JSON.stringify(data)); };
|
||||
if (req.url === '/') {res.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});res.end(html);return;}
|
||||
if (req.url.startsWith('/static/')) {res.writeHead(200, {'Content-Type': req.url.endsWith('.css') ? 'text/css' : 'application/javascript'});res.end(fs.readFileSync(path.join(root, req.url)));return;}
|
||||
if (req.url === '/api/manual/orders' && req.method === 'GET') return reply(200, {headers, rows});
|
||||
if (req.url === '/api/manual/orders' && req.method === 'POST') {rows.push({id: nextId++, version: 1, cells: headers.map(() => '')});return reply(200, {status: 'success'});}
|
||||
if (req.url === '/api/manual/orders/cells') {
|
||||
let body='';for await(const chunk of req)body+=chunk;
|
||||
const changes=JSON.parse(body).changes;
|
||||
if(failNext){failNext=false;return reply(503,{detail:'테스트 저장 장애'});}
|
||||
if(conflictNext){conflictNext=false;const change=changes[0], row=rows.find(r=>r.id===change.id);row.cells[change.column]='다른 사용자의 최신값';row.version++;return reply(409,{detail:{message:'동시 수정 충돌',conflicts:[{id:row.id,column:change.column,value:row.cells[change.column]}]}});}
|
||||
const updated=new Set();
|
||||
for(const c of changes){const row=rows.find(r=>r.id===c.id);assert(row);assert(row.cells[c.column]===c.previous_value||row.cells[c.column]===c.value);row.cells[c.column]=c.value;updated.add(row.id);}
|
||||
for(const id of updated)rows.find(r=>r.id===id).version++;
|
||||
return reply(200,{rows:rows.filter(r=>updated.has(r.id))});
|
||||
}
|
||||
if(req.url==='/api/manual/orders/archive'){
|
||||
let body='';for await(const chunk of req)body+=chunk;const selected=JSON.parse(body).rows;
|
||||
for(const row of selected)assert.equal(rows.find(r=>r.id===row.id).version,row.version);
|
||||
rows=rows.filter(r=>!selected.some(s=>s.id===r.id));return reply(200,{status:'success'});
|
||||
}
|
||||
if(req.url==='/api/sheet/download_and_clear'){exported=true;rows=[];res.writeHead(200,{'Content-Type':'application/octet-stream','Content-Disposition':"attachment; filename*=UTF-8''manual.xlsx"});res.end('exported rows');return;}
|
||||
if(req.url==='/api/manual/orders/exports')return reply(200,exported?[{id:'test-export',filename:'manual.xlsx'}]:[]);
|
||||
if(req.url==='/api/manual/orders/exports/test-export'){res.writeHead(200,{'Content-Disposition':'attachment; filename="manual.xlsx"'});res.end('exported rows');return;}
|
||||
reply(404,{});
|
||||
});
|
||||
(async()=>{
|
||||
await new Promise(resolve=>server.listen(0,'127.0.0.1',resolve));
|
||||
const browser=await chromium.launch({headless:true,executablePath:process.env.CORM_TEST_BROWSER||'C:/Program Files/Google/Chrome/Application/chrome.exe'});
|
||||
try{
|
||||
const page=await browser.newPage({viewport:{width:1440,height:900},acceptDownloads:true});
|
||||
const errors=[];page.on('pageerror',e=>errors.push(e.message));
|
||||
await page.goto(`http://127.0.0.1:${server.address().port}`);
|
||||
await page.waitForSelector('td[data-id="1"]');
|
||||
const cell=(id,column)=>page.locator(`td[data-id="${id}"][data-column="${column}"]`);
|
||||
const saved=()=>page.waitForFunction(()=>document.getElementById('manual-save-status').textContent==='모든 변경사항 저장됨');
|
||||
await cell(1,3).fill('자동 저장 고객');await saved();assert.equal(rows[0].cells[3],'자동 저장 고객');
|
||||
await page.reload();await page.waitForSelector('td[data-id="1"]');assert.equal(await cell(1,3).textContent(),'자동 저장 고객');
|
||||
await cell(1,3).focus();await page.keyboard.press('Tab');assert.equal(await page.locator(':focus').getAttribute('data-column'),'4');
|
||||
await cell(1,4).evaluate(td=>{const data=new DataTransfer();data.setData('text/plain','CODE-A\t상품 A\nCODE-B\t상품 B');td.dispatchEvent(new ClipboardEvent('paste',{clipboardData:data,bubbles:true,cancelable:true}));});
|
||||
await saved();assert.equal(rows[1].cells[5],'상품 B');
|
||||
failNext=true;await cell(1,3).fill('장애 후 재시도');await page.waitForSelector('#manual-save-retry:not([hidden])');
|
||||
assert.equal(await cell(1,3).textContent(),'장애 후 재시도');await page.click('#manual-save-retry');await saved();assert.equal(rows[0].cells[3],'장애 후 재시도');
|
||||
conflictNext=true;await cell(1,3).fill('충돌 입력');await page.waitForSelector('#manual-save-retry:not([hidden])');
|
||||
page.once('dialog',d=>d.dismiss());await page.click('#manual-save-retry');await saved();assert.equal(await cell(1,3).textContent(),'다른 사용자의 최신값');
|
||||
await page.locator('body').click({position:{x:1300,y:800}});
|
||||
fs.mkdirSync(path.join(root,'.cache'),{recursive:true});await page.screenshot({path:path.join(root,'.cache/manual-grid-qa.png')});
|
||||
await page.click('#manual-add-row');await page.waitForSelector('td[data-id="3"]');
|
||||
await cell(3,3).fill('삭제 전 수정');await page.check('input[data-row-id="3"]');
|
||||
page.once('dialog',d=>d.accept());await page.click('#manual-delete-rows');await page.waitForFunction(()=>document.querySelectorAll('#manual-grid tbody tr').length===2);
|
||||
page.once('dialog',d=>d.accept());const download=page.waitForEvent('download');await page.click('#manual-download');await download;
|
||||
await page.waitForFunction(()=>document.getElementById('manual-grid-empty').hidden===false);
|
||||
await page.click('#manual-exports summary');await page.waitForSelector('#manual-export-list a');assert.equal(await page.locator('#manual-export-list a').textContent(),'manual.xlsx');
|
||||
assert.deepEqual(errors,[]);console.log('Browser QA passed: autosave, reload, Tab, multi-cell paste, failure retry, conflict, row add/delete, export and redownload link.');
|
||||
}finally{await browser.close();server.close();}
|
||||
})().catch(error=>{console.error(error);server.close();process.exitCode=1;});
|
||||
@@ -172,6 +172,9 @@ class ApiTests(unittest.IsolatedAsyncioTestCase):
|
||||
histories = patch.object(main, "HISTORY_BACKEND", "google")
|
||||
histories.start()
|
||||
self.addCleanup(histories.stop)
|
||||
manual = patch.object(main, "MANUAL_ORDERS_BACKEND", "google")
|
||||
manual.start()
|
||||
self.addCleanup(manual.stop)
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.cache = runtime.SettingsCache(Path(self.directory.name) / "settings.json", "test")
|
||||
self.cache_patch = patch.object(main, "_settings_cache", self.cache)
|
||||
|
||||
@@ -0,0 +1,141 @@
|
||||
"""Manual queue fidelity, atomic autosave, export recovery and API isolation."""
|
||||
|
||||
import io
|
||||
import json
|
||||
import unittest
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from openpyxl import load_workbook
|
||||
|
||||
import main
|
||||
from manual_orders import HEADERS, CellConflict, ManualOrderStore, build_xlsx, validate_source
|
||||
from test_google_resilience import request
|
||||
|
||||
|
||||
CELLS = ["2026-10-22 10:00:00", "", "3500", "테스트", "TEST-1", "상품", "2", "주소", "00123", "010-0000-0000", "010-0000-0000", "요청", "", "수동발주", "비고"]
|
||||
|
||||
|
||||
class FormatTests(unittest.TestCase):
|
||||
def test_excel_keeps_column_order_leading_zeros_and_literal_formulas(self):
|
||||
cells = CELLS.copy()
|
||||
cells[14] = '=HYPERLINK("https://example.invalid","text")'
|
||||
book = load_workbook(io.BytesIO(build_xlsx(HEADERS, [cells])))
|
||||
sheet = book.active
|
||||
self.assertEqual(list(next(sheet.values)), HEADERS)
|
||||
self.assertEqual(sheet["I2"].value, "00123")
|
||||
self.assertEqual(sheet["G2"].value, 2)
|
||||
self.assertEqual(sheet["O2"].data_type, "s")
|
||||
self.assertEqual(sheet["O2"].value, cells[14])
|
||||
|
||||
def test_source_padding_keeps_blank_rows_and_extra_columns(self):
|
||||
headers, rows = validate_source({"kind": "corm-manual-orders", "headers": HEADERS + ["추가 열"], "rows": [[], CELLS + ["추가 값"]]})
|
||||
self.assertEqual(len(rows[0]), 16)
|
||||
self.assertEqual(rows[1][-1], "추가 값")
|
||||
|
||||
|
||||
class StoreTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = ManualOrderStore({})
|
||||
self.connection = MagicMock()
|
||||
self.cursor = self.connection.cursor.return_value.__enter__.return_value
|
||||
connect = patch.object(self.store, "_connect", return_value=self.connection)
|
||||
connect.start()
|
||||
self.addCleanup(connect.stop)
|
||||
|
||||
def test_same_cell_conflict_aborts_entire_batch(self):
|
||||
self.cursor.fetchall.return_value = [(1, CELLS.copy(), 2)]
|
||||
with self.assertRaises(CellConflict):
|
||||
self.store.patch_cells([{"id": 1, "column": 3, "value": "새 이름", "previous_value": "다른 이름"}])
|
||||
self.assertIs(self.connection.__exit__.call_args.args[0], CellConflict)
|
||||
self.assertEqual(self.cursor.execute.call_count, 1)
|
||||
|
||||
def test_retry_of_already_saved_value_succeeds_and_other_cells_are_preserved(self):
|
||||
self.cursor.fetchall.return_value = [(1, CELLS.copy(), 2)]
|
||||
self.cursor.fetchone.return_value = (3,)
|
||||
rows = self.store.patch_cells([{"id": 1, "column": 3, "value": CELLS[3], "previous_value": "old"}])
|
||||
self.assertEqual(rows[0]["cells"][8], "00123")
|
||||
self.assertEqual(rows[0]["version"], 3)
|
||||
|
||||
def test_missing_or_archived_row_is_not_recreated_by_autosave(self):
|
||||
self.cursor.fetchall.return_value = []
|
||||
with self.assertRaises(LookupError):
|
||||
self.store.patch_cells([{"id": 1, "column": 3, "value": "new", "previous_value": "old"}])
|
||||
|
||||
def test_order_and_summary_share_one_transaction(self):
|
||||
self.cursor.fetchone.return_value = (HEADERS,)
|
||||
self.cursor.execute.side_effect = [None, None, RuntimeError("summary insert failed")]
|
||||
with self.assertRaises(RuntimeError):
|
||||
self.store.append([CELLS], {"timestamp": CELLS[0], "customer_name": "테스트", "total_amount": 3500})
|
||||
self.assertIs(self.connection.__exit__.call_args.args[0], RuntimeError)
|
||||
|
||||
def test_export_failure_never_archives_rows(self):
|
||||
self.cursor.fetchone.return_value = (HEADERS,)
|
||||
self.cursor.fetchall.return_value = [(1, CELLS)]
|
||||
with patch("manual_orders.build_xlsx", side_effect=RuntimeError("file failed")), self.assertRaises(RuntimeError):
|
||||
self.store.export_and_archive("test.xlsx")
|
||||
self.assertEqual(self.cursor.execute.call_count, 2)
|
||||
|
||||
def test_export_is_archived_with_exact_row_ids_for_redownload(self):
|
||||
self.cursor.fetchone.return_value = (HEADERS,)
|
||||
self.cursor.fetchall.return_value = [(4, CELLS)]
|
||||
data, export_id = self.store.export_and_archive("test.xlsx")
|
||||
self.assertTrue(data.startswith(b"PK"))
|
||||
calls = self.cursor.execute.call_args_list
|
||||
self.assertIn("corm_manual_exports", calls[2].args[0])
|
||||
self.assertEqual(calls[3].args[1], ([4],))
|
||||
|
||||
|
||||
class ApiTests(unittest.IsolatedAsyncioTestCase):
|
||||
def setUp(self):
|
||||
self.store = MagicMock()
|
||||
self.store.list_rows.return_value = {"headers": HEADERS, "rows": [{"id": 1, "cells": CELLS, "version": 1}]}
|
||||
self.store.patch_cells.return_value = []
|
||||
self.store.export_and_archive.return_value = (build_xlsx(HEADERS, [CELLS]), "00000000-0000-0000-0000-000000000001")
|
||||
for key, value in (("MANUAL_ORDERS_BACKEND", "postgres"), ("HISTORY_BACKEND", "postgres"), ("_manual_orders", self.store)):
|
||||
mock = patch.object(main, key, value)
|
||||
mock.start()
|
||||
self.addCleanup(mock.stop)
|
||||
google = patch.object(main, "get_manual_worksheet", side_effect=AssertionError("Unexpected Google call"))
|
||||
google.start()
|
||||
self.addCleanup(google.stop)
|
||||
|
||||
async def test_grid_read_patch_and_export_do_not_use_google(self):
|
||||
with patch.object(main, "run_google_io", side_effect=AssertionError("Google unavailable")):
|
||||
self.assertEqual((await request("GET", "/api/manual/orders"))[0], 200)
|
||||
self.assertEqual((await request("PATCH", "/api/manual/orders/cells", {"changes": [{"id": 1, "column": 3, "value": "새 이름", "previous_value": "테스트"}]}))[0], 200)
|
||||
self.assertEqual((await request("POST", "/api/sheet/download_and_clear"))[0], 200)
|
||||
|
||||
async def test_conflicting_autosave_returns_current_values(self):
|
||||
self.store.patch_cells.side_effect = CellConflict([{"id": 1, "column": 3, "value": "최신 이름"}])
|
||||
status, _, body = await request("PATCH", "/api/manual/orders/cells", {"changes": [{"id": 1, "column": 3, "value": "내 이름", "previous_value": "old"}]})
|
||||
self.assertEqual(status, 409)
|
||||
self.assertEqual(json.loads(body)["detail"]["conflicts"][0]["value"], "최신 이름")
|
||||
|
||||
async def test_submission_saves_summary_server_side_and_retains_sheet_layout(self):
|
||||
payload = {"customer_name": "테스트", "phone": "01000000000", "address": "주소", "comment": "요청",
|
||||
"order_type": "normal", "no_lid": False, "total_amount": 3500,
|
||||
"items": [{"code": "TEST-1", "name": "상품", "label": "상품", "quantity": 2, "item_type": "ORDER_SINGLE"}]}
|
||||
status, _, body = await request("POST", "/api/order/submit", payload)
|
||||
self.assertEqual(status, 200)
|
||||
self.assertTrue(json.loads(body)["history_saved"])
|
||||
rows, history = self.store.append.call_args.args
|
||||
self.assertEqual(len(rows[0]), 15)
|
||||
self.assertEqual(rows[0][4:7], ["TEST-1", "상품", 2])
|
||||
self.assertEqual(history["total_amount"], 3500)
|
||||
|
||||
async def test_cancellation_updates_queue_and_history_through_same_store(self):
|
||||
self.assertEqual((await request("DELETE", "/api/manual/history/records/1"))[0], 200)
|
||||
self.store.delete_history.assert_called_once_with(1)
|
||||
|
||||
async def test_legacy_template_uses_sheet_until_migration_and_db_template_uses_grid(self):
|
||||
# Reuse the actual template render path with service authentication.
|
||||
status, _, body = await request("GET", "/")
|
||||
self.assertEqual(status, 200)
|
||||
self.assertIn(b'id="manual-grid-panel"', body)
|
||||
self.assertNotIn(b'id="manual-iframe-container"', body)
|
||||
with patch.object(main, "MANUAL_ORDERS_BACKEND", "google"):
|
||||
self.assertEqual((await request("GET", "/api/manual/orders"))[0], 409)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,77 @@
|
||||
"""Read-only source capture and non-overwriting manual queue migration."""
|
||||
|
||||
import io
|
||||
import os
|
||||
import tempfile
|
||||
import unittest
|
||||
from contextlib import redirect_stdout
|
||||
from pathlib import Path
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import psycopg2
|
||||
import main
|
||||
import manual_orders_deploy as deployment
|
||||
from manual_orders import HEADERS
|
||||
from settings_migrate import save_snapshot
|
||||
|
||||
|
||||
SOURCE = {"kind": "corm-manual-orders", "headers": HEADERS, "rows": [["2026-10-22"] + [""] * 14]}
|
||||
|
||||
|
||||
class MigrationTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.path = Path(self.directory.name) / "manual-orders-source.json"
|
||||
save_snapshot(self.path, SOURCE, "test")
|
||||
self.store = MagicMock()
|
||||
self.store.list_rows.return_value = {"headers": HEADERS, "rows": [{"id": 1, "cells": SOURCE["rows"][0], "version": 1}]}
|
||||
mocked = patch.object(deployment, "ManualOrderStore", return_value=self.store)
|
||||
mocked.start()
|
||||
self.addCleanup(mocked.stop)
|
||||
|
||||
def test_existing_identical_queue_is_not_reimported(self):
|
||||
with redirect_stdout(io.StringIO()):
|
||||
deployment.migrate(self.directory.name)
|
||||
self.store.import_source.assert_not_called()
|
||||
|
||||
def test_existing_different_queue_is_not_overwritten(self):
|
||||
self.store.list_rows.return_value = {"headers": HEADERS, "rows": []}
|
||||
with self.assertRaises(RuntimeError):
|
||||
deployment.migrate(self.directory.name)
|
||||
self.store.import_source.assert_not_called()
|
||||
|
||||
def test_missing_table_imports_then_validates_every_cell(self):
|
||||
stored = self.store.list_rows.return_value
|
||||
self.store.list_rows.side_effect = [psycopg2.errors.UndefinedTable(), stored]
|
||||
with redirect_stdout(io.StringIO()):
|
||||
deployment.migrate(self.directory.name)
|
||||
self.store.import_source.assert_called_once_with(SOURCE, "manual-order-sheet")
|
||||
|
||||
def test_bad_checksum_never_accesses_database(self):
|
||||
self.path.write_text(self.path.read_text(encoding="utf-8").replace('2026-10-22', '2026-10-23'), encoding="utf-8")
|
||||
with self.assertRaises(ValueError):
|
||||
deployment.migrate(self.directory.name)
|
||||
self.store.list_rows.assert_not_called()
|
||||
|
||||
def test_google_source_keeps_first_sheet_order_and_uses_no_write_helpers(self):
|
||||
client = MagicMock()
|
||||
worksheet = client.open_by_key.return_value.get_worksheet.return_value
|
||||
worksheet.get_all_values.return_value = [HEADERS, ["date"], [], ["other"]]
|
||||
with patch.dict(os.environ, {"MANUAL_ORDERS_BACKEND": "google"}), \
|
||||
patch.object(main, "get_gspread_client", return_value=client):
|
||||
source = deployment.read_source()
|
||||
self.assertEqual(len(source["rows"]), 3)
|
||||
self.assertEqual(source["rows"][1], [""] * 15)
|
||||
client.open_by_key.return_value.get_worksheet.assert_called_once_with(0)
|
||||
worksheet.update.assert_not_called()
|
||||
|
||||
def test_db_source_never_reads_old_google_values(self):
|
||||
with patch.dict(os.environ, {"MANUAL_ORDERS_BACKEND": "postgres"}), \
|
||||
patch.object(main, "get_gspread_client") as google:
|
||||
self.assertEqual(deployment.read_source(), SOURCE)
|
||||
google.assert_not_called()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -75,6 +75,9 @@ class MergeTests(unittest.TestCase):
|
||||
|
||||
class HistoryApiTests(unittest.IsolatedAsyncioTestCase):
|
||||
def setUp(self):
|
||||
manual = patch.object(main, "MANUAL_ORDERS_BACKEND", "google")
|
||||
manual.start()
|
||||
self.addCleanup(manual.stop)
|
||||
self.store = MagicMock()
|
||||
self.store.list_records.return_value = [{**SMS, "id": 42}]
|
||||
self.store.add.return_value = 42
|
||||
|
||||
@@ -121,6 +121,9 @@ class StoreTests(unittest.TestCase):
|
||||
|
||||
class PostgresApiTests(unittest.IsolatedAsyncioTestCase):
|
||||
def setUp(self):
|
||||
manual = patch.object(main, "MANUAL_ORDERS_BACKEND", "google")
|
||||
manual.start()
|
||||
self.addCleanup(manual.stop)
|
||||
histories = patch.object(main, "HISTORY_BACKEND", "google")
|
||||
histories.start()
|
||||
self.addCleanup(histories.stop)
|
||||
|
||||
@@ -17,6 +17,7 @@ from settings_store import (
|
||||
SettingsNotInitialized,
|
||||
)
|
||||
from history_store import PostgresHistoryStore
|
||||
from manual_orders import ManualOrderStore, HEADERS, CellConflict
|
||||
|
||||
|
||||
@unittest.skipUnless(os.getenv("SETTINGS_TEST_DSN"), "SETTINGS_TEST_DSN test database is not configured")
|
||||
@@ -35,6 +36,8 @@ class RealPostgresTests(unittest.TestCase):
|
||||
self.store._connect = self.connect
|
||||
self.histories = PostgresHistoryStore({})
|
||||
self.histories._connect = self.connect
|
||||
self.manual = ManualOrderStore({})
|
||||
self.manual._connect = self.connect
|
||||
self.rows = [HEADER.copy(), ["APP_SETTINGS", "font", "한글 😊"],
|
||||
["ORDER_SINGLE", "B", "B-1"], ["ORDER_SINGLE", "A", "A-1"]]
|
||||
|
||||
@@ -110,6 +113,25 @@ class RealPostgresTests(unittest.TestCase):
|
||||
with self.assertRaises(SettingsAlreadyInitialized):
|
||||
self.histories.import_all(bundle, "test")
|
||||
|
||||
def test_manual_queue_conflicts_export_and_atomic_summary(self):
|
||||
self.histories.import_all({"kind": "corm-history", "sms": [], "manual": []}, "test")
|
||||
cells = ["2026-10-22 10:00:00"] + [""] * 14
|
||||
self.manual.import_source({"kind": "corm-manual-orders", "headers": HEADERS, "rows": [cells]}, "test")
|
||||
record = self.manual.list_rows()["rows"][0]
|
||||
change = {"id": record["id"], "column": 3, "value": "이름", "previous_value": ""}
|
||||
self.manual.patch_cells([change])
|
||||
with self.assertRaises(CellConflict):
|
||||
self.manual.patch_cells([{**change, "value": "다른 이름"}])
|
||||
# A lost successful response can be retried without reporting a conflict.
|
||||
self.manual.patch_cells([change])
|
||||
key = self.manual.append([cells], {"timestamp": cells[0], "customer_name": "테스트", "total_amount": 3500})
|
||||
histories = self.histories.list_records("manual")
|
||||
self.assertEqual(histories[0]["manual_order_key"], key)
|
||||
data, export_id = self.manual.export_and_archive("manual.xlsx")
|
||||
self.assertEqual(self.manual.exports(export_id), ("manual.xlsx", data))
|
||||
self.assertEqual(self.manual.list_rows()["rows"], [])
|
||||
self.assertEqual(len(self.manual.exports()), 1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
||||
Reference in New Issue
Block a user