diff --git a/.env.example b/.env.example index 2edac20..ec4c9c2 100644 --- a/.env.example +++ b/.env.example @@ -26,9 +26,10 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/ # DB/역할/스키마/센터 seed 생성: scripts/sql/cupang_db_init.sql 참고. # CUPANG_DB_URL=postgresql://cupang_app:replace-me@postgres-db:5432/cupang_db -# 쿠팡 밀크런 출고리스트를 기록할 Google 스프레드시트 (분배 확정 시 출고일 시트 생성) -# - 대상 문서는 반드시 "Google 스프레드시트" 형식(업로드한 .xlsx 는 파일>Google 스프레드시트로 저장) -# - 서비스 계정 이메일(client_email)에 해당 문서를 편집자로 공유해야 한다 +# 쿠팡 밀크런 출고리스트 문서 (분배 확정·출고리스트 작성 팝업이 출고일 시트에 기록) +# - 구글 드라이브에 올린 .xlsx 파일 id(기본값 = 아래 id). 구글 스프레드시트 문서 id 여도 된다(형식 자동 판별) +# - .xlsx 는 Drive 권한이 필요하다: 서비스 계정(GOOGLE_SHEETS_CREDENTIALS) 또는 GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN +# - 서비스 계정이면 이메일(client_email)에 해당 파일을 편집자로 공유해야 한다 # CUPANG_SHEET_ID=1J74op7lBZOgE27p4R28I3RWsv0EtXdii # # [방식 A] 사용자 OAuth 리프레시 토큰 — 조직 정책으로 서비스 계정 키를 못 만들 때 diff --git a/app/integrations/drive_xlsx.py b/app/integrations/drive_xlsx.py new file mode 100644 index 0000000..dbb2bc4 --- /dev/null +++ b/app/integrations/drive_xlsx.py @@ -0,0 +1,345 @@ +"""Google 드라이브에 올려 둔 엑셀(.xlsx) 파일을 시트처럼 고쳐 쓰기(쿠팡 밀크런 출고리스트, 2026-10-23). + +구글 시트 문서가 아니라 드라이브의 .xlsx 파일이면 Sheets API 로는 쓸 수 없다. 그래서 +파일을 내려받아(openpyxl) 고친 뒤 같은 파일 id 에 내용을 다시 올린다(링크·공유·이름 그대로). + +- 인증은 google_drive 와 같다(서비스 계정 우선, 없으면 OAuth 리프레시 토큰 — Drive 권한 포함). +- `GoogleSheetsWriter` 와 같은 메서드(sheet_titles·read_ranges·append_block·write_table·delete_sheet·lock)를 + 같은 인자로 제공한다 → cupang 라우터는 어느 쪽인지 몰라도 된다(`file_kind` 로 골라 씀). +- `with writer.lock:` 안의 호출은 내려받은 사본 하나를 같이 쓰고, 블록이 끝날 때 바뀐 게 있으면 한 번만 올린다. + 잠금 밖에서 부른 메서드는 호출마다 내려받고(바뀌면) 올린다. +- 올리기 직전에 파일 version 을 다시 보고, 그 사이 누가 고쳤으면 `XlsxChangedError` — 덮어쓰지 않는다 + (호출부가 처음부터 다시 시도). +- 비밀값은 로그·화면에 출력하지 않는다. +""" + +from __future__ import annotations + +import re +import threading +from io import BytesIO +from typing import Any + +from app.integrations.google_drive import GoogleDriveError, GoogleDriveFiles, _friendly_drive + +XLSX_MIME = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" +SHEETS_MIME = "application/vnd.google-apps.spreadsheet" +_RANGE_RE = re.compile(r"^([A-Z]+)(\d*)(?::([A-Z]+)(\d*))?$") + +# 같은 파일을 두 요청이 동시에 내려받아 고치면 나중 것이 앞의 것을 지우므로 한 번에 하나씩. +_LOCK = threading.RLock() +_KIND_CACHE: dict[str, str] = {} + + +class XlsxChangedError(RuntimeError): + """내려받은 뒤 올리기 전에 다른 사람이 파일을 고쳤다.""" + + +def _col_num(letters: str) -> int: + n = 0 + for ch in letters: + n = n * 26 + (ord(ch) - 64) + return n + + +def _parse_range(a1: str) -> tuple[str, int, int, int | None, int | None]: + """"'시트'!F6:F" → (시트, 첫 행, 첫 열, 끝 행|None, 끝 열|None). 끝이 비면 시트 끝까지.""" + sheet, _, ref = a1.rpartition("!") + if sheet.startswith("'") and sheet.endswith("'"): + sheet = sheet[1:-1].replace("''", "'") + m = _RANGE_RE.match(ref.upper()) + if not sheet or not m: + raise ValueError(f"지원하지 않는 범위: {a1}") + c1, r1, c2, r2 = m.groups() + if c2 is None: # 셀 하나 + c2, r2 = c1, r1 + return sheet, int(r1 or 1), _col_num(c1), (int(r2) if r2 else None), _col_num(c2) + + +def _text(value: Any) -> str: + """Sheets API 의 FORMATTED_VALUE 처럼 문자열로(정수인 실수는 소수점 없이).""" + if value is None: + return "" + if isinstance(value, float) and value.is_integer(): + return str(int(value)) + return str(value) + + +def _put(cell: Any, value: Any) -> None: + """Sheets 의 USER_ENTERED 처럼 앞의 작은따옴표는 "글자 그대로" 표시로 보고 떼어 낸다.""" + if isinstance(value, str) and value.startswith("'"): + cell.value = value[1:] + cell.data_type = "s" # '=' 로 시작해도 수식이 되지 않게 + else: + cell.value = value + + +class DriveXlsxWriter(GoogleDriveFiles): + """드라이브 .xlsx 파일 하나를 GoogleSheetsWriter 처럼 다룬다(spreadsheet_id = 드라이브 파일 id).""" + + def __init__(self) -> None: + super().__init__() + self._depth = 0 + self._book: dict[str, Any] | None = None # {"id", "wb", "version", "dirty"} + + # ── 내려받기 / 올리기 ─────────────────────────── + def file_kind(self, file_id: str) -> str: + """"xlsx" | "sheets" | 그 밖의 mimeType. 실패는 GoogleDriveError(사유).""" + if file_id in _KIND_CACHE: + return _KIND_CACHE[file_id] + meta = self._meta(file_id, "mimeType") + mime = str(meta.get("mimeType") or "") + kind = "xlsx" if mime == XLSX_MIME else "sheets" if mime == SHEETS_MIME else mime + _KIND_CACHE[file_id] = kind + return kind + + def _meta(self, file_id: str, fields: str) -> dict[str, Any]: + self._check() + try: + return self._service().files().get(fileId=file_id, fields=fields, supportsAllDrives=True).execute() + except Exception as exc: # noqa: BLE001 + raise self._error(exc) from None + + @staticmethod + def _error(exc: Exception) -> GoogleDriveError: + text = _friendly_drive(exc).replace("업무 파일 폴더", "출고리스트 엑셀 파일") + return GoogleDriveError(text) + + def _open(self, file_id: str) -> dict[str, Any]: + from openpyxl import load_workbook + + version = str(self._meta(file_id, "version").get("version") or "") + try: + data = self._service().files().get_media(fileId=file_id, supportsAllDrives=True).execute() + except Exception as exc: # noqa: BLE001 + raise self._error(exc) from None + return {"id": file_id, "wb": load_workbook(BytesIO(data)), "version": version, "dirty": False} + + def _save(self, book: dict[str, Any]) -> None: + from googleapiclient.http import MediaIoBaseUpload + + now = str(self._meta(book["id"], "version").get("version") or "") + if book["version"] and now != book["version"]: + raise XlsxChangedError("출고리스트 엑셀 파일이 그 사이 바뀌었습니다.") + out = BytesIO() + book["wb"].save(out) + out.seek(0) + try: + self._service().files().update( + fileId=book["id"], media_body=MediaIoBaseUpload(out, mimetype=XLSX_MIME, resumable=False), + fields="id", supportsAllDrives=True, + ).execute() + except Exception as exc: # noqa: BLE001 + raise self._error(exc) from None + + class _Session: + def __init__(self, writer: "DriveXlsxWriter") -> None: + self.w = writer + + def __enter__(self) -> "DriveXlsxWriter": + _LOCK.acquire() + self.w._depth += 1 + return self.w + + def __exit__(self, exc_type: Any, *_: Any) -> None: + w = self.w + try: + w._depth -= 1 + if w._depth == 0: + book, w._book = w._book, None + if exc_type is None and book is not None and book["dirty"]: + w._save(book) + finally: + _LOCK.release() + + @property + def lock(self) -> "DriveXlsxWriter._Session": + """이 블록 안의 호출은 내려받은 사본 하나를 같이 쓰고, 끝날 때 바뀐 게 있으면 한 번 올린다.""" + return DriveXlsxWriter._Session(self) + + def _wb(self, file_id: str) -> Any: + if self._book is None or self._book["id"] != file_id: + if self._book is not None and self._book["dirty"]: + self._save(self._book) + self._book = self._open(file_id) + return self._book["wb"] + + def _touch(self) -> None: + if self._book is not None: + self._book["dirty"] = True + + @staticmethod + def _url(file_id: str) -> str: + return f"https://docs.google.com/spreadsheets/d/{file_id}/edit" + + # ── GoogleSheetsWriter 와 같은 메서드 ──────────── + def sheet_titles(self, *, spreadsheet_id: str) -> list[str]: + with self.lock: + return list(self._wb(spreadsheet_id).sheetnames) + + def read_ranges(self, *, spreadsheet_id: str, ranges: list[str], chunk: int = 50) -> list[list[list[Any]]]: + """범위마다 값의 2차원 목록(문자열) — Sheets API 처럼 뒤쪽 빈 칸·빈 행은 잘라 낸다.""" + del chunk + with self.lock: + wb = self._wb(spreadsheet_id) + out: list[list[list[Any]]] = [] + for a1 in ranges: + title, r1, c1, r2, c2 = _parse_range(a1) + if title not in wb.sheetnames: + out.append([]) + continue + ws = wb[title] + rows = [ + [_text(v) for v in row] + for row in ws.iter_rows(min_row=r1, max_row=r2 or ws.max_row, min_col=c1, + max_col=c2 or ws.max_column, values_only=True) + ] + for row in rows: + while row and row[-1] == "": + row.pop() + while rows and not rows[-1]: + rows.pop() + out.append(rows) + return out + + def append_block( + self, + *, + spreadsheet_id: str, + title: str, + cells: dict[tuple[int, int], Any], + merges: list[tuple[int, int, int, int]], + first_row: int, + last_row: int, + first_col: int, + last_col: int, + left_cols: tuple[int, ...] = (9,), + highlight: str = "", + ) -> dict[str, Any]: + """이미 있는 시트의 first_row~last_row 에 표 한 덩어리(위쪽 내용은 그대로). 서식은 GoogleSheetsWriter 와 같다.""" + from openpyxl.styles import PatternFill + + with self.lock: + wb = self._wb(spreadsheet_id) + if title not in wb.sheetnames: + raise LookupError(f"시트 '{title}' 이(가) 없습니다.") + ws = wb[title] + for (r, c), value in cells.items(): + _put(ws.cell(row=r, column=c), value) + for (r1, c1, r2, c2) in merges: + ws.merge_cells(start_row=r1, start_column=c1, end_row=r2, end_column=c2) + fill = PatternFill("solid", fgColor=highlight) if highlight else PatternFill(fill_type=None) + _style_rows(ws, first_row, last_row, first_col, last_col, left_cols=left_cols, fill=fill) + self._touch() + return { + "created": False, "title": title, "first_row": first_row, "last_row": last_row, + "url": self._url(spreadsheet_id), + } + + def delete_sheet(self, *, spreadsheet_id: str, title: str) -> dict[str, Any]: + """시트 1장 삭제. 없으면 missing, 문서에 그 하나뿐이면 내용만 비운다(cleared).""" + with self.lock: + wb = self._wb(spreadsheet_id) + if title not in wb.sheetnames: + return {"ok": True, "action": "missing", "title": title} + if len(wb.sheetnames) <= 1: + _replace_sheet(wb, title) + action = "cleared" + else: + wb.remove(wb[title]) + wb.active = min(wb.index(wb.active) if wb.active is not None else 0, len(wb.sheetnames) - 1) + action = "deleted" + self._touch() + return {"ok": True, "action": action, "title": title} + + def write_table( + self, + *, + spreadsheet_id: str, + title: str, + cells: dict[tuple[int, int], Any], + merges: list[tuple[int, int, int, int]], + header_row: int, + first_data_row: int, + last_row: int, + first_col: int, + last_col: int, + title_row: int, + widths: dict[int, int], + header_bg: str = "", + row_highlights: list[tuple[int, int, str]] | None = None, + ) -> dict[str, Any]: + """시트를 만들고(있으면 새로 갈아 끼우고) 표를 통째로 기록한다. 좌표 1-based, 색은 "RRGGBB".""" + from openpyxl.styles import Alignment, Font, PatternFill + from openpyxl.utils import get_column_letter + + with self.lock: + wb = self._wb(spreadsheet_id) + created = title not in wb.sheetnames + ws = _replace_sheet(wb, title) + for (r, c), value in cells.items(): + _put(ws.cell(row=r, column=c), value) + for (r1, c1, r2, c2) in merges: + ws.merge_cells(start_row=r1, start_column=c1, end_row=r2, end_column=c2) + + center = Alignment(horizontal="center", vertical="center", wrap_text=True) + head = ws.cell(row=title_row, column=first_col) + head.font = Font(size=16, bold=True) + head.alignment = center + ws.row_dimensions[title_row].height = 28 + header_fill = PatternFill("solid", fgColor=header_bg) if header_bg else PatternFill(fill_type=None) + _style_rows(ws, header_row, header_row, first_col, last_col, left_cols=(), fill=header_fill) + for col in range(first_col, last_col + 1): + ws.cell(row=header_row, column=col).font = Font(bold=True) + if last_row >= first_data_row: + _style_rows(ws, first_data_row, last_row, first_col, last_col, left_cols=(9,), fill=None) + for (r1, r2, color) in (row_highlights or []): + fill = PatternFill("solid", fgColor=color) + for row in range(r1, r2 + 1): + for col in range(first_col, last_col + 1): + ws.cell(row=row, column=col).fill = fill + for col, px in widths.items(): + ws.column_dimensions[get_column_letter(col)].width = round(px / 7.0, 2) + self._touch() + return {"created": created, "title": title, "url": self._url(spreadsheet_id)} + + +def _replace_sheet(wb: Any, title: str) -> Any: + """같은 이름의 빈 시트로 갈아 끼운다(탭 위치 유지). 없으면 맨 뒤에 새로.""" + if title in wb.sheetnames: + index = wb.sheetnames.index(title) + wb.remove(wb[title]) + return wb.create_sheet(title, index) + return wb.create_sheet(title) + + +def _style_rows( + ws: Any, r1: int, r2: int, c1: int, c2: int, *, left_cols: tuple[int, ...], fill: Any +) -> None: + """가운데 정렬·줄바꿈·얇은 검은 테두리, left_cols 만 왼쪽 정렬. fill 이 None 이면 배경은 그대로.""" + from openpyxl.styles import Alignment, Border, Side + + thin = Side(style="thin", color="000000") + box = Border(left=thin, right=thin, top=thin, bottom=thin) + center = Alignment(horizontal="center", vertical="center", wrap_text=True) + left = Alignment(horizontal="left", vertical="center", wrap_text=True) + for row in range(r1, r2 + 1): + for col in range(c1, c2 + 1): + cell = ws.cell(row=row, column=col) + cell.border = box + cell.alignment = left if col in left_cols else center + if fill is not None: + cell.fill = fill + + +_WRITER: DriveXlsxWriter | None = None +_WRITER_LOCK = threading.Lock() + + +def get_writer() -> DriveXlsxWriter: + """프로세스당 하나(설정이 비어 있으면 매번 다시 확인).""" + global _WRITER + with _WRITER_LOCK: + if _WRITER is None or not _WRITER.enabled: + _WRITER = DriveXlsxWriter() + return _WRITER diff --git a/app/modules/cupang/CLAUDE.md b/app/modules/cupang/CLAUDE.md index d1ba209..741c4eb 100644 --- a/app/modules/cupang/CLAUDE.md +++ b/app/modules/cupang/CLAUDE.md @@ -15,10 +15,16 @@ - 양식 생성은 `export.py` 한 곳에서 만들어 xlsx·구글시트가 공유. - 작업 중 상태는 `cupang_box_calc_drafts` 에 이름 붙여 임시 저장/불러오기. -## 구글 시트 동기화 +## 출고리스트 문서 동기화 (드라이브 엑셀 파일) -- `CUPANG_SHEET_ID` + 인증(사용자 OAuth `GOOGLE_SHEETS_OAUTH_REFRESH_TOKEN` 또는 서비스 계정 `GOOGLE_SHEETS_CREDENTIALS[_JSON]`) 설정 시 - 확정과 동시에 Google 스프레드시트에 출고일 시트를 생성/덮어쓰기(`app/integrations/google_sheets.py`, 미설정이면 조용히 skip). +- 출고리스트 문서는 **구글 드라이브에 올린 .xlsx 파일**(`CUPANG_SHEET_ID`, 기본 `router.DEFAULT_SHEET_ID` + = `1J74op7lBZOgE27p4R28I3RWsv0EtXdii`). `router._sheet_target` 이 드라이브에서 형식을 보고 writer 를 고른다: + - .xlsx → `app/integrations/drive_xlsx.py` — 내려받아 openpyxl 로 고친 뒤 같은 파일 id 에 다시 올림 + (인증은 google_drive 와 같음: 서비스 계정 또는 `GOOGLE_SLIDES_OAUTH_REFRESH_TOKEN`/`GOOGLE_SHEETS_OAUTH_REFRESH_TOKEN`, Drive 권한). + `with writer.lock:` 블록 = 내려받기 1번·올리기 1번. 올리기 직전 version 이 바뀌었으면(누가 고침) `_in_sheet` 가 처음부터 다시(3번). + - 구글 시트 문서 → 예전처럼 `google_sheets.py`(Sheets API). 드라이브 인증이 없을 때도 이쪽. + - 엑셀은 openpyxl 로 다시 저장하므로 파일 안 그림·차트는 사라진다(출고리스트에는 없음). +- 인증이 없으면 조용히 skip. 확정과 동시에 출고일 시트를 생성/덮어쓰기. - 출고 삭제(건별/날짜 전체) 시에도 같은 날짜 시트 동기화 — 남은 출고가 있으면 다시 쓰고, 없으면 시트 삭제 (문서에 시트가 하나뿐이면 내용만 비움). @@ -46,10 +52,10 @@ - 광고비·할인 프로모션·장려금은 주차 단위(`cupang_sales_weekly`)로 보관, 순마진은 화면에서 계산. - 초기 데이터는 `scripts/sql/cupang_sales_seed.sql`. -## 밀크런 출고리스트 작성 (팝업 → 구글 시트, 2026-10-23) +## 밀크런 출고리스트 작성 (팝업 → 드라이브 엑셀 파일, 2026-10-23) - 첫 화면 "+ 신규 등록" 옆 엑셀색(#217346) 버튼 → 팝업(`index.html` + `static/cupang-outbound.js`). - 상자 계산 없이 센터 1곳을 **구글 시트에만** 적는다 — cupang_db 출고 묶음은 만들지 않는다(달력에 안 보임). + 상자 계산 없이 센터 1곳을 **출고리스트 엑셀 파일에만** 적는다(위 "출고리스트 문서 동기화") — cupang_db 출고 묶음은 만들지 않는다(달력에 안 보임). - 입력: 작성일(기본 오늘)·출고일·센터입고일(출고일 고르면 +1일 자동) — 날짜 칸은 프로젝트 날짜 팝업 (`PJLib.enhanceDateInput`, project.js 를 `PJ_LIB_ONLY` 로 로드). 입고센터(시트 F열 + 등록 센터, 직접 입력 가능), 출고방식(파렛트/택배), 제품(코드표 `GET /cupang/api/products/all` 검색 → 코드·이름 자동, 수량 수기), 출고(수기), 작업자(기본 `export.WORKER`). diff --git a/app/modules/cupang/router.py b/app/modules/cupang/router.py index ca7be53..5d97b97 100644 --- a/app/modules/cupang/router.py +++ b/app/modules/cupang/router.py @@ -245,21 +245,57 @@ def _shipments_for_date(store: Any, ship_date: str) -> list[dict[str, Any]]: return out +# 출고리스트 문서 — 구글 드라이브에 올려 둔 엑셀(.xlsx) 파일(2026-10-23). 구글 시트 문서여도 된다. +DEFAULT_SHEET_ID = "1J74op7lBZOgE27p4R28I3RWsv0EtXdii" + + def _sheet_target(store: Any) -> tuple[Any, str, dict[str, Any] | None]: - """(writer, spreadsheet_id, skip 사유) — 설정이 없으면 skip 정보를 돌려준다.""" + """(writer, 문서 id, skip 사유) — 쓸 수 없으면 skip 정보를 돌려준다. + + 문서 형식은 드라이브에서 보고 고른다 — .xlsx 파일이면 drive_xlsx(내려받아 고친 뒤 다시 올림), + 구글 시트 문서면 google_sheets. 두 writer 는 같은 메서드를 갖는다.""" import os # noqa: WPS433 - from app.integrations.google_sheets import get_writer # noqa: WPS433 + from app.integrations import drive_xlsx, google_sheets # noqa: WPS433 - spreadsheet_id = (os.getenv("CUPANG_SHEET_ID") or "").strip() - if not spreadsheet_id: - return None, "", {"ok": False, "skipped": True, "reason": "CUPANG_SHEET_ID 미설정"} - writer = get_writer() + spreadsheet_id = (os.getenv("CUPANG_SHEET_ID") or "").strip() or DEFAULT_SHEET_ID + drive = drive_xlsx.get_writer() + if not drive.enabled: + # 드라이브 인증이 없으면 예전처럼 Sheets API 로(구글 시트 문서일 때만 된다) + writer = google_sheets.get_writer() + if not writer.enabled: + return None, "", {"ok": False, "skipped": True, "reason": writer.reason} + return writer, spreadsheet_id, None + try: + kind = drive.file_kind(spreadsheet_id) + except Exception as exc: # noqa: BLE001 - 사유만(비밀값 없음) + return None, "", {"ok": False, "skipped": True, "reason": str(exc) or type(exc).__name__} + if kind == "xlsx": + return drive, spreadsheet_id, None + if kind != "sheets": + return None, "", {"ok": False, "skipped": True, "reason": f"엑셀·구글 시트 파일이 아닙니다({kind})"} + writer = google_sheets.get_writer() if not writer.enabled: return None, "", {"ok": False, "skipped": True, "reason": writer.reason} return writer, spreadsheet_id, None +def _in_sheet(writer: Any, fn: Any) -> Any: + """`with writer.lock:` 안에서 fn() — 읽기~쓰기를 한 덩어리로. + + 엑셀 파일(drive_xlsx)은 내려받은 뒤 올리기 전에 누가 파일을 고쳤으면 처음부터 다시(최대 3번).""" + from app.integrations.drive_xlsx import XlsxChangedError # noqa: WPS433 + + for attempt in range(3): + try: + with writer.lock: + return fn() + except XlsxChangedError: + if attempt == 2: + raise + return None + + def _sync_google_sheet_after_delete(store: Any, ship_date: str) -> dict[str, Any]: """출고 삭제 후 구글 시트를 현재 상태에 맞춘다. @@ -277,7 +313,8 @@ def _sync_google_sheet_after_delete(store: Any, ship_date: str) -> dict[str, Any return _push_to_google_sheet(store, ship_date) try: - res = writer.delete_sheet(spreadsheet_id=spreadsheet_id, title=sheet_title(ship_date)) + res = _in_sheet(writer, lambda: writer.delete_sheet(spreadsheet_id=spreadsheet_id, + title=sheet_title(ship_date))) except Exception as exc: # noqa: BLE001 - 사유만 남긴다 return {"ok": False, "skipped": False, "reason": f"{type(exc).__name__}: {exc}"} return {"ok": True, "skipped": False, **res} @@ -293,10 +330,10 @@ def _log_sheet(action: str, ship_date: str, res: dict[str, Any]) -> None: def _push_to_google_sheet(store: Any, ship_date: str) -> dict[str, Any]: - """확정한 출고일을 Google 스프레드시트에 시트 1장으로 기록. + """확정한 출고일을 출고리스트 문서(드라이브 엑셀 또는 구글 시트)에 시트 1장으로 기록. - - 대상 스프레드시트: 환경변수 `CUPANG_SHEET_ID` - - 인증: 서비스 계정(app/integrations/google_sheets.py). 미설정이면 조용히 skip. + - 대상 문서: 환경변수 `CUPANG_SHEET_ID`(기본 DEFAULT_SHEET_ID), 형식은 `_sheet_target` 이 고른다. + - 인증: 서비스 계정 또는 OAuth(app/integrations/drive_xlsx.py·google_sheets.py). 미설정이면 조용히 skip. - 실패해도 출고 묶음 저장은 이미 끝났으므로 예외를 밖으로 던지지 않는다. """ writer, spreadsheet_id, skip = _sheet_target(store) @@ -308,7 +345,7 @@ def _push_to_google_sheet(store: Any, ship_date: str) -> dict[str, Any]: return {"ok": False, "skipped": True, "reason": "해당 출고일의 출고 묶음 없음"} try: - res = _write_full_sheet(writer, spreadsheet_id, ship_date, shipments) + res = _in_sheet(writer, lambda: _write_full_sheet(writer, spreadsheet_id, ship_date, shipments)) except Exception as exc: # noqa: BLE001 - 시트 기록 실패는 경고로만 알린다 return {"ok": False, "skipped": False, "reason": f"{type(exc).__name__}: {exc}"} return {"ok": True, "skipped": False, **res} @@ -344,7 +381,7 @@ def _write_full_sheet( # ════════════════════════════════════════════════════════════ # 밀크런 출고리스트 직접 작성 — 상자 계산 없이 팝업에서 입력한 센터 1곳을 -# 구글 시트의 출고일 시트(YYYYMMDD(요일)) 맨 아래에 덧붙인다. cupang_db 에는 저장하지 않는다. +# 출고리스트 문서(드라이브 엑셀 파일)의 출고일 시트(YYYYMMDD(요일)) 맨 아래에 덧붙인다. cupang_db 에는 저장하지 않는다. # ════════════════════════════════════════════════════════════ OUTBOUND_SHEET_METHODS: tuple[str, ...] = ("파렛트", "택배") _SHEET_CENTERS_TTL_SECONDS = 600 @@ -418,11 +455,12 @@ def _sheet_centers(writer: Any, spreadsheet_id: str) -> list[str]: cache = _sheet_centers_cache if cache["sheet"] == spreadsheet_id and time.monotonic() - cache["at"] < _SHEET_CENTERS_TTL_SECONDS: return list(cache["names"]) - titles = writer.sheet_titles(spreadsheet_id=spreadsheet_id) - columns = writer.read_ranges( - spreadsheet_id=spreadsheet_id, - ranges=[f"{a1_sheet(t)}!F{FIRST_DATA_ROW}:F" for t in titles], - ) + with writer.lock: # 엑셀 파일이면 한 번만 내려받는다 + titles = writer.sheet_titles(spreadsheet_id=spreadsheet_id) + columns = writer.read_ranges( + spreadsheet_id=spreadsheet_id, + ranges=[f"{a1_sheet(t)}!F{FIRST_DATA_ROW}:F" for t in titles], + ) names = sorted({ str(row[0]).strip() for rows in columns for row in rows if row and str(row[0]).strip() }) @@ -486,7 +524,7 @@ def outbound_sheet_centers( try: names.update(_sheet_centers(writer, spreadsheet_id)) except Exception as exc: # noqa: BLE001 - 목록은 등록 센터만으로도 쓸 수 있다 - reason = f"구글 시트를 읽지 못했습니다({type(exc).__name__})" + reason = f"출고리스트 파일을 읽지 못했습니다({type(exc).__name__})" return JSONResponse({"centers": sorted(names), "reason": reason}) @@ -500,16 +538,24 @@ def outbound_sheet_write( writer, spreadsheet_id, skip = _sheet_target(_store(request)) if skip: raise HTTPException( - status_code=503, detail=f"구글 시트에 쓸 수 없습니다: {skip.get('reason') or '설정 확인 필요'}" + status_code=503, detail=f"출고리스트 파일에 쓸 수 없습니다: {skip.get('reason') or '설정 확인 필요'}" ) + from app.integrations.drive_xlsx import XlsxChangedError # noqa: WPS433 + from app.integrations.google_drive import GoogleDriveError # noqa: WPS433 + try: # 시트 끝 위치를 읽고 쓰는 사이에 다른 요청이 끼어들지 않게 한 덩어리로 - with writer.lock: - res = _append_outbound_entry(writer, spreadsheet_id, entry) + res = _in_sheet(writer, lambda: _append_outbound_entry(writer, spreadsheet_id, entry)) except Exception as exc: # noqa: BLE001 - 사유만 남긴다(비밀값 미출력) _log_sheet("manual-append", entry["ship_date"], {"ok": False, "reason": type(exc).__name__}) + if isinstance(exc, XlsxChangedError): + why = "다른 사람이 파일을 고치는 중입니다" + elif isinstance(exc, GoogleDriveError): + why = str(exc) + else: + why = type(exc).__name__ raise HTTPException( - status_code=502, detail=f"구글 시트에 기록하지 못했습니다({type(exc).__name__}). 잠시 후 다시 시도해 주세요." + status_code=502, detail=f"출고리스트 파일에 기록하지 못했습니다({why}). 잠시 후 다시 시도해 주세요." ) from exc _log_sheet("manual-append", entry["ship_date"], {"ok": True, "action": f"rows {res.get('first_row')}-{res.get('last_row')}"}) center = entry["center_name_snapshot"] diff --git a/app/modules/cupang/templates/cupang/index.html b/app/modules/cupang/templates/cupang/index.html index 0ba90ac..483096e 100644 --- a/app/modules/cupang/templates/cupang/index.html +++ b/app/modules/cupang/templates/cupang/index.html @@ -175,7 +175,7 @@ - +