diff --git a/.env.example b/.env.example index ed9a337..1f5e514 100644 --- a/.env.example +++ b/.env.example @@ -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 diff --git a/README.md b/README.md index a911d02..9301298 100644 --- a/README.md +++ b/README.md @@ -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` | 반품 데이터 저장 | diff --git a/deploy-manual-orders.sh b/deploy-manual-orders.sh new file mode 100644 index 0000000..760151e --- /dev/null +++ b/deploy-manual-orders.sh @@ -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' '브라우저를 새로고침하고 수동발주 탭의 셀 편집·자동 저장을 확인해주세요.' diff --git a/docs/manual-orders-postgres.md b/docs/manual-orders-postgres.md new file mode 100644 index 0000000..1edcbce --- /dev/null +++ b/docs/manual-orders-postgres.md @@ -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 전환 후 변경이 있다면 현재 발주와 백업을 보관하고 차이를 확인한 뒤 복구한다. diff --git a/main.py b/main.py index 1816bbe..0759700 100644 --- a/main.py +++ b/main.py @@ -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="이미 삭제된 내역입니다. 새로고침해주세요.") diff --git a/manual_orders.py b/manual_orders.py new file mode 100644 index 0000000..f101304 --- /dev/null +++ b/manual_orders.py @@ -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,)) diff --git a/manual_orders_deploy.py b/manual_orders_deploy.py new file mode 100644 index 0000000..a440bf5 --- /dev/null +++ b/manual_orders_deploy.py @@ -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()) diff --git a/static/css/manual_grid.css b/static/css/manual_grid.css new file mode 100644 index 0000000..731ef7d --- /dev/null +++ b/static/css/manual_grid.css @@ -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; } } diff --git a/static/js/app.js b/static/js/app.js index b0c3ca3..1c05a7c 100644 --- a/static/js/app.js +++ b/static/js/app.js @@ -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 || "삭제 중 오류가 발생했습니다."); diff --git a/static/js/manual_grid.js b/static/js/manual_grid.js new file mode 100644 index 0000000..762c98e --- /dev/null +++ b/static/js/manual_grid.js @@ -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')); +})(); diff --git a/templates/index.html b/templates/index.html index 806b6b3..f7c4af2 100644 --- a/templates/index.html +++ b/templates/index.html @@ -17,6 +17,7 @@ /> +