Add database-backed manual order grid with automatic cell saving

This commit is contained in:
2026-10-22 18:33:59 +09:00
parent 399e91518c
commit 827cb3b0a8
18 changed files with 1124 additions and 11 deletions
+2
View File
@@ -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
+3 -1
View File
@@ -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` | 반품 데이터 저장 |
+59
View File
@@ -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' '브라우저를 새로고침하고 수동발주 탭의 셀 편집·자동 저장을 확인해주세요.'
+62
View File
@@ -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 전환 후 변경이 있다면 현재 발주와 백업을 보관하고 차이를 확인한 뒤 복구한다.
+128 -7
View File
@@ -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="이미 삭제된 내역입니다. 새로고침해주세요.")
+203
View File
@@ -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,))
+94
View File
@@ -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())
+29
View File
@@ -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
View File
@@ -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 || "삭제 중 오류가 발생했습니다.");
+193
View File
@@ -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
View File
@@ -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>
+70
View File
@@ -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;});
+3
View File
@@ -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)
+141
View File
@@ -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()
+77
View File
@@ -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()
+3
View File
@@ -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
+3
View File
@@ -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()