Files
king 212a3dd6b0 feat(입출고): 날짜 칸을 ERP 공용 달력으로
발주 목록 기간, 발주일, 입고 예정일, 입고일을 erp-datepop 으로 교체.
국경일·대체공휴일을 빨강·이름으로 표시하고 마우스를 올리면 이름을 보여 준다.
필수 칸은 지우기를 빼고, 잠긴 입고일은 버튼도 비활성화.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-05 14:11:45 +09:00

1273 lines
67 KiB
Python

"""입출고 관리 모듈 라우터 — 본사 → 공장 발주, 물류 입고(분할), 발주 대비 미입고·초과.
GET /inout/ 발주 목록(상태·공장·기간·검색)
GET /inout/pending 미입고 현황(품목별 합계 + 발주별) · 초과 입고
GET|POST /inout/orders/new 발주서 작성(발주 담당)
GET /inout/orders/{id} 발주서 — 품목별 발주·입고·미입고, 입고 기록, 입고 입력(입고 담당)
GET|POST /inout/orders/{id}/edit 발주서 고치기(발주 담당)
POST /inout/orders/{id}/close|reopen|cancel 종결·종결 풀기·취소(발주 담당)
POST /inout/orders/{id}/receipts 입고 저장(입고 담당) — 발주 초과면 확인 화면, confirm_over=1 로 다시 보내야 저장
POST /inout/orders/{id}/receipts/{rid}/delete 잘못 넣은 입고 지우기(입고 담당)
GET /inout/settings?panel=1 옵션 팝업 내용(톱니, ERP 관리자) — 공장 목록·발주 담당·입고 담당
POST /inout/settings/… 옵션 저장 — 팝업(X-Inout-Options: 1)이면 JSON, 아니면 목록으로 이동
POST /inout/settings/products/import|save · /products/{code}/exclude|restore 옵션 → 상품 정보(단가·무게·은 함유량, 004)
POST /inout/orders/{id}/receipts/{rid}/photos · /orders/{id}/photos/{pid}/delete|rotate · GET /inout/photos/{pid} 입고증 사진
GET|POST /inout/orders/{id}/mail 발주 메일 미리보기·발송(발주 담당 본인 Gmail, 사람이 눌러야 보냄)
GET|POST /inout/orders/{id}/receipts/{rid}/mail 입고 요청 메일(물류센터, 입고 담당 본인 Gmail, 005)
POST /inout/settings/logistics 옵션 → 물류센터(입고 요청 메일 받는 주소·참조, 005)
POST /inout/settings/order-mail 옵션 → 공장(발주 메일 참조 기본값 — 처음엔 king@dbxcorp.co.kr)
GET /inout/orders/{id}/receipts/{rid}/sabangnet.xlsx 사방넷 입고 파일(상품코드=사방넷 코드·가용수량=입고 수량·불용수량=상품 이름)
GET /inout/gmail/connect · /gmail/callback · POST /gmail/disconnect Gmail 연결(사람별, gmail.send 만)
GET /inout/api/items?q= 코드표 단품 검색(JSON)
권한: 모듈 권한키 `inout`(조회). 발주 담당·입고 담당은 옵션(inout_roles)에서 지정, ERP 관리자는 둘 다 + 옵션.
"""
from __future__ import annotations
import logging
from datetime import date
from typing import Any
from urllib.parse import urlencode
from fastapi import APIRouter, Body, HTTPException, Query, Request
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, Response
from app.timezone import today_kst
from . import store
from .db import OverReceipt
_log = logging.getLogger(__name__)
router = APIRouter(prefix="/inout", tags=["inout"])
# ────────────────────────────────────────────────────────────
# 공용 헬퍼
# ────────────────────────────────────────────────────────────
def _store(request: Request) -> Any:
return getattr(request.app.state, "inout_store", None)
def _items(request: Request) -> Any:
return getattr(request.app.state, "inout_items", None)
def _user(request: Request) -> dict[str, Any]:
from app.main import get_current_user_record # noqa: WPS433
from app.store import has_module # noqa: WPS433
user = get_current_user_record(request)
if user is None:
raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
if not has_module(user, "inout"):
raise HTTPException(status_code=403, detail="입출고 관리 모듈 권한이 없습니다.")
return user
def _page_user(request: Request) -> Any:
"""화면 주소 — 로그인 전이면 로그인으로 보냈다가 돌아온다."""
from app.main import get_current_user_record # noqa: WPS433
from app.store import login_redirect # noqa: WPS433
if get_current_user_record(request) is None:
return login_redirect(request)
return _user(request)
def _is_admin(user: dict[str, Any]) -> bool:
from app.store import is_admin # noqa: WPS433
return is_admin(user)
def _perms(st: Any, user: dict[str, Any]) -> dict[str, bool]:
"""발주 담당·입고 담당 — 옵션(inout_roles), ERP 관리자는 둘 다."""
admin = _is_admin(user)
roles = set() if admin else st.roles_of(user.get("email", ""))
return {"admin": admin, "can_order": admin or store.ROLE_ORDER in roles,
"can_receive": admin or store.ROLE_RECEIVE in roles,
"super": bool(user.get("is_super_admin"))} # 발주 삭제(2026-10-17) — 수퍼관리자 한 명만
def _require(st: Any, user: dict[str, Any], what: str) -> dict[str, bool]:
p = _perms(st, user)
if what == "order" and not p["can_order"]:
raise HTTPException(status_code=403, detail="발주 담당만 할 수 있습니다(입출고 관리 → 옵션에서 지정).")
if what == "receive" and not p["can_receive"]:
raise HTTPException(status_code=403, detail="입고 담당만 할 수 있습니다(입출고 관리 → 옵션에서 지정).")
if what == "mail" and not (p["can_order"] or p["can_receive"]): # Gmail 연결 — 발주 메일·입고 요청 메일 보내는 사람
raise HTTPException(status_code=403, detail="발주 담당·입고 담당만 Gmail 을 연결할 수 있습니다.")
if what == "admin" and not p["admin"]:
raise HTTPException(status_code=403, detail="옵션은 ERP 관리자만 바꿀 수 있습니다.")
if what == "super" and not p["super"]:
raise HTTPException(status_code=403, detail="발주 삭제는 수퍼관리자만 할 수 있습니다.")
return p
def _date_holidays() -> dict[str, str]:
"""날짜 칸 달력(erp-datepop)의 국경일·대체공휴일 — 프로젝트 달력과 같은 표."""
try:
from app.modules.project.store import KR_HOLIDAYS # noqa: WPS433
return dict(KR_HOLIDAYS)
except Exception: # noqa: BLE001 — 표를 못 읽어도 날짜 입력은 된다
return {}
def _render(request: Request, name: str, user: dict[str, Any], ctx: dict[str, Any], status_code: int = 200) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
st = _store(request)
perms = _perms(st, user) if st is not None else {"admin": _is_admin(user), "can_order": False, "can_receive": False}
return render_template(request, name, {
"user": user, "is_admin": perms["admin"], "perms": perms,
"nav_items": build_erp_nav(user, active="inout"),
"msg": request.query_params.get("msg", ""), "today": today_kst(), "date_holidays": _date_holidays(),
"open_options": request.query_params.get("options") == "1" and perms["admin"], # 톱니 팝업 바로 열기
**ctx,
}, status_code=status_code)
def _config_needed(request: Request, user: dict[str, Any]) -> HTMLResponse:
from app.main import build_erp_nav, render_template # noqa: WPS433
return render_template(request, "denied.html", {
"reason": "입출고 관리 모듈이 아직 설정되지 않았습니다. scripts/sql/inout_db_init.sql 로 inout_db 를 만들고 "
"INOUT_DB_URL 환경변수를 설정한 뒤 컨테이너를 재기동하세요.",
"user": user, "is_admin": _is_admin(user), "nav_items": build_erp_nav(user, active="inout"),
}, status_code=503)
def _ctx(request: Request) -> Any:
"""화면 공통 — (st, user) 또는 응답(로그인·설정 필요)."""
user = _page_user(request)
if not isinstance(user, dict):
return user
st = _store(request)
if st is None:
return _config_needed(request, user)
return st, user
def _redirect(url: str, msg: str = "") -> RedirectResponse:
return RedirectResponse(url=url + (("&" if "?" in url else "?") + urlencode({"msg": msg}) if msg else ""), status_code=303)
def _order_or_404(st: Any, order_id: int) -> dict[str, Any]:
order = st.get_order(order_id)
if order is None:
raise HTTPException(status_code=404, detail="발주서를 찾을 수 없습니다.")
return order
def _opt_int(v: Any) -> int | None:
try:
n = int(str(v or "").strip())
except ValueError:
return None
return n if n > 0 else None
def _opt_date(v: Any) -> date | None:
try:
return date.fromisoformat(str(v or "").strip())
except ValueError:
return None
# ────────────────────────────────────────────────────────────
# 발주 목록 · 미입고 현황
# ────────────────────────────────────────────────────────────
@router.get("/", response_class=HTMLResponse)
def index(request: Request, status: str = "", factory: str = "", q: str = "", date_from: str = Query("", alias="from"),
date_to: str = Query("", alias="to")) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
saved = st.get_list_status(user.get("email", ""))
if status not in store.STATUS_FILTERS: # 주소에 상태가 없으면 이 사람이 마지막으로 고른 보기
status = saved if saved in store.STATUS_FILTERS else "active"
elif status != saved:
st.save_list_status(user.get("email", ""), status)
orders = st.list_orders(status=status, factory_id=_opt_int(factory), q=q, date_from=_opt_date(date_from),
date_to=_opt_date(date_to))
return _render(request, "inout/index.html", user, {
"tab": "orders", "orders": orders, "factories": st.list_factories(include_inactive=True),
"filters": {"status": status, "factory": _opt_int(factory), "q": q, "from": date_from, "to": date_to},
"status_filters": store.STATUS_FILTERS,
})
@router.get("/pending", response_class=HTMLResponse)
def pending(request: Request, factory: str = "", q: str = "") -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
data = st.outstanding(factory_id=_opt_int(factory), q=q)
by_item: dict[str, dict[str, Any]] = {}
for r in data["pending"]:
it = by_item.setdefault(r["item_code"], {"item_code": r["item_code"], "item_name": r["item_name"],
"remaining": 0, "orders": 0, "earliest_due": None})
it["remaining"] += r["remaining"]
it["orders"] += 1
if r["due_date"] and (it["earliest_due"] is None or r["due_date"] < it["earliest_due"]):
it["earliest_due"] = r["due_date"]
items = sorted(by_item.values(), key=lambda x: (-x["remaining"], x["item_code"]))
return _render(request, "inout/pending.html", user, {
"tab": "pending", "rows": data["pending"], "over": data["over"], "items": items,
"factories": st.list_factories(include_inactive=True), "filters": {"factory": _opt_int(factory), "q": q},
"total_remaining": sum(r["remaining"] for r in data["pending"]),
})
# ────────────────────────────────────────────────────────────
# 발주서 작성·수정
# ────────────────────────────────────────────────────────────
def _form_values(form: Any) -> dict[str, Any]:
return {"factory_id": form.get("factory_id", ""), "order_date": form.get("order_date", ""),
"due_date": form.get("due_date", ""), "memo": form.get("memo", ""),
"codes": form.getlist("item_code"), "names": form.getlist("item_name"),
"quantities": form.getlist("qty"), "line_memos": form.getlist("line_memo")}
def _validated(request: Request, st: Any, vals: dict[str, Any], *,
keep_codes: set[str]) -> tuple[dict[str, Any], dict[str, str], dict[str, dict[str, Any]]]:
"""폼 검사 + 제품 확인 → (값, {코드: 이름}, {코드: 상품 정보 행}). keep_codes = 이미 발주서에 있던 코드(그대로 둔다).
옵션 → 상품 정보에 불러온 단품이 있으면 그 목록에서만(지운 단품은 안 됨, 단가 등 사본은 여기서), 없으면 코드표(004 이전과 같게)."""
data = store.validate_order(factory_id=vals["factory_id"], order_date=vals["order_date"], due_date=vals["due_date"],
memo=vals["memo"], codes=vals["codes"], quantities=vals["quantities"],
line_memos=vals["line_memos"])
new_codes = [ln["item_code"] for ln in data["lines"] if ln["item_code"] not in keep_codes]
names: dict[str, str] = {}
if new_codes and st.catalog_count() > 0:
found_rows = st.catalog_lookup(new_codes)
missing = [c for c in new_codes if c not in found_rows]
if missing:
raise ValueError("상품 정보에 없는 단품입니다(옵션 → 상품 정보에서 불러오거나 되살리세요): " + ", ".join(missing))
return data, {c: found_rows[c]["item_name"] for c in new_codes}, found_rows
if new_codes:
reader = _items(request)
found = reader.lookup(new_codes) if reader is not None else None
if found is None:
raise ValueError("코드표 DB(itemcode_db)에 연결할 수 없어 제품을 확인하지 못했습니다 — 잠시 뒤 다시 저장하세요"
+ ("" if reader is None or reader.enabled else " (ITEMCODE_DB_URL 미설정)") + ".")
missing = [c for c in new_codes if c not in found]
if missing:
raise ValueError("코드표 단품에 없는 제품입니다: " + ", ".join(missing))
names = {c: found[c] for c in new_codes}
return data, names, {}
def _form_page(request: Request, user: dict[str, Any], st: Any, *, order: dict[str, Any] | None, vals: dict[str, Any],
error: str = "", status_code: int = 200) -> HTMLResponse:
lines = [{"code": (c or "").strip().upper(), "name": vals["names"][i] if i < len(vals["names"]) else "",
"qty": vals["quantities"][i] if i < len(vals["quantities"]) else "",
"memo": vals["line_memos"][i] if i < len(vals["line_memos"]) else ""}
for i, c in enumerate(vals["codes"]) if (c or "").strip() or (i < len(vals["quantities"]) and vals["quantities"][i])]
# 단가 — 이미 있던 품목은 발주 당시 값(사본), 새 품목은 지금 상품 정보 값(004). 금액은 화면이 수량 × 단가로 계산.
snap = {x["item_code"]: x.get("unit_price") for x in (order["lines"] if order else [])}
catalog = st.catalog_lookup([ln["code"] for ln in lines if ln["code"] and ln["code"] not in snap])
boxes = st.catalog_lookup([ln["code"] for ln in lines if ln["code"]]) if st.boxes_ready() else {}
for ln in lines:
price = snap[ln["code"]] if ln["code"] in snap else (catalog.get(ln["code"]) or {}).get("unit_price")
ln["price"] = float(price) if price is not None else None
ln["price_label"] = store.fmt_num(price) if price is not None else ""
bx = boxes.get(ln["code"]) or {} # 박스 입수(007) — 지금 상품 정보 값(발주 품목에 남기지 않음)
ln.update(store.box_info(bx))
reader = _items(request)
catalog_n = st.catalog_count()
return _render(request, "inout/order_form.html", user, {
"tab": "orders", "order": order, "vals": vals, "lines": lines, "error": error,
"factories": [f for f in st.list_factories(include_inactive=True)
if f["is_active"] or (order and f["id"] == order["factory_id"])],
"items_enabled": bool(reader is not None and reader.enabled) or catalog_n > 0, "from_catalog": catalog_n > 0,
"boxes_ready": st.boxes_ready(), "pallet_boxes": store.PALLET_BOXES,
}, status_code=status_code)
@router.get("/orders/new", response_class=HTMLResponse)
def order_new(request: Request) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
vals = {"factory_id": "", "order_date": today_kst().isoformat(), "due_date": "", "memo": "",
"codes": [], "names": [], "quantities": [], "line_memos": []}
return _form_page(request, user, st, order=None, vals=vals)
@router.post("/orders/new", response_class=HTMLResponse)
async def order_create(request: Request) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
vals = _form_values(await request.form())
try:
data, names, specs = _validated(request, st, vals, keep_codes=set())
res = st.create_order(data, names, by=user.get("email", ""), specs=specs)
except ValueError as exc:
return _form_page(request, user, st, order=None, vals=vals, error=str(exc), status_code=400)
return _redirect(f"/inout/orders/{res['id']}?mail=1", f"발주서 {res['order_no']} 을(를) 만들었습니다.") # 메일 미리보기 바로
@router.get("/orders/{order_id}/edit", response_class=HTMLResponse)
def order_edit(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
order = _order_or_404(st, order_id)
vals = {"factory_id": str(order["factory_id"]), "order_date": order["order_date"].isoformat(),
"due_date": order["due_date"].isoformat() if order["due_date"] else "", "memo": order["memo"],
"codes": [x["item_code"] for x in order["lines"]], "names": [x["item_name"] for x in order["lines"]],
"quantities": [str(x["qty"]) for x in order["lines"]], "line_memos": [x["memo"] for x in order["lines"]]}
return _form_page(request, user, st, order=order, vals=vals)
@router.post("/orders/{order_id}/edit", response_class=HTMLResponse)
async def order_update(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
order = _order_or_404(st, order_id)
vals = _form_values(await request.form())
try:
data, names, specs = _validated(request, st, vals, keep_codes={x["item_code"] for x in order["lines"]})
st.update_order(order_id, data, names, by=user.get("email", ""), specs=specs)
except ValueError as exc:
return _form_page(request, user, st, order=order, vals=vals, error=str(exc), status_code=400)
return _redirect(f"/inout/orders/{order_id}", "발주서를 고쳤습니다.")
# ────────────────────────────────────────────────────────────
# 발주서 화면 · 종결 · 취소
# ────────────────────────────────────────────────────────────
def _detail(request: Request, user: dict[str, Any], st: Any, order: dict[str, Any], *, receipt_form: dict[str, Any] | None = None,
error: str = "", over: list[dict[str, Any]] | None = None, photos_lost: bool = False,
status_code: int = 200) -> HTMLResponse:
perms = _perms(st, user)
return _render(request, "inout/order_detail.html", user, {
"tab": "orders", "order": order, "error": error, "over": over or [], "photos_lost": photos_lost,
"open_mail": request.query_params.get("mail") == "1" and perms["can_order"] and not order["cancelled_at"],
# 입고 저장 뒤 ?rmail={입고 id} — 입고 요청 메일 미리보기를 바로 연다(005)
"open_rmail": _opt_int(request.query_params.get("rmail")) if perms["can_receive"] else None,
# 입고 담당(발주 담당 아님)은 품목을 이름·발주 수량(+ 이번 입고 칸)만 — 2026-10-16 사용자 요청
"items_limited": perms["can_receive"] and not perms["can_order"],
"show_prices": perms["can_order"], "totals": store.order_totals(order["lines"]),
"fmt_num": store.fmt_num, "line_amount": store.line_amount, "silver_g": store.silver_g, "line_usage": store.line_usage,
"max_photos": store.MAX_PHOTOS,
"receipt_form": receipt_form or {"receipt_date": today_kst().isoformat(), "memo": "", "qty": {}},
"can_receive_now": order["status"] in (store.ST_OPEN, store.ST_PARTIAL, store.ST_DONE, store.ST_OVER),
}, status_code=status_code)
@router.get("/orders/{order_id}", response_class=HTMLResponse)
def order_detail(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
return _detail(request, user, st, _order_or_404(st, order_id))
@router.post("/orders/{order_id}/close")
async def order_close(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
form = await request.form()
try:
st.set_closed(order_id, closed=True, reason=str(form.get("reason") or ""), by=user.get("email", ""))
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", "종결했습니다 — 남은 미입고는 미입고 현황에서 빠집니다.")
@router.post("/orders/{order_id}/reopen")
def order_reopen(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
try:
st.set_closed(order_id, closed=False, by=user.get("email", ""))
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", "종결을 풀었습니다.")
@router.post("/orders/{order_id}/cancel")
def order_cancel(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
try:
st.cancel_order(order_id, by=user.get("email", ""))
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", "발주서를 취소했습니다.")
@router.post("/orders/{order_id}/delete")
async def order_delete(request: Request, order_id: int) -> Any:
"""발주 목록 🗑 — 수퍼관리자만. 품목·입고 기록·입고증 사진·메일 기록까지 완전히 지운다(되돌릴 수 없음)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "super")
form = await request.form()
back = str(form.get("back") or "")
back = back if back.startswith("/inout/") and "//" not in back else "/inout/" # 보던 목록(거르기)으로 — 다른 사이트로는 안 보냄
try:
r = st.delete_order(order_id)
except LookupError as exc:
return _redirect(back, str(exc))
_log.warning("inout order deleted: %s (receipts=%d) by %s", r["order_no"], r["receipts"], user.get("email", ""))
return _redirect(back, f"발주서 {r['order_no']}를 삭제했습니다" + (f"(입고 기록 {r['receipts']}건 포함)." if r["receipts"] else "."))
# ────────────────────────────────────────────────────────────
# 입고
# ────────────────────────────────────────────────────────────
@router.post("/orders/{order_id}/receipts", response_class=HTMLResponse)
async def receipt_add(request: Request, order_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
form = await request.form()
qty: dict[int, str] = {}
for k, v in form.items():
if k.startswith("qty_") and k[4:].isdigit():
qty[int(k[4:])] = str(v)
rf = {"receipt_date": str(form.get("receipt_date") or ""), "memo": str(form.get("memo") or ""), "qty": qty}
had_photos = False
try:
raw_photos = await _read_photos(form)
had_photos = any(data for _n, data in raw_photos)
photos = store.validate_photos(raw_photos)
res = st.add_receipt(order_id, qty, receipt_date=rf["receipt_date"], memo=rf["memo"],
confirm_over="1" in form.getlist("confirm_over"), by=user.get("email", ""), photos=photos)
except OverReceipt as exc:
# 화면이 다시 그려지면 고른 파일은 사라진다 — 사진을 골랐었다면 다시 첨부하라고 알린다
return _detail(request, user, st, _order_or_404(st, order_id), receipt_form=rf, over=exc.over,
photos_lost=had_photos, status_code=409)
except LookupError:
raise HTTPException(status_code=404, detail="발주서를 찾을 수 없습니다.") from None
except ValueError as exc:
return _detail(request, user, st, _order_or_404(st, order_id), receipt_form=rf, error=str(exc),
photos_lost=had_photos, status_code=400)
note = (f"입고 {res['total']:,}개를 저장했습니다." + (" (초과 입고 포함)" if res["over"] else "")
+ (f" 입고증 사진 {res['photos']}장." if res.get("photos") else ""))
# 바로 입고 요청 메일 미리보기(물류센터) — 보내기는 사람이 [메일 발송]을 눌러야
return _redirect(f"/inout/orders/{order_id}?rmail={res['id']}", note)
@router.post("/orders/{order_id}/receipts/{receipt_id}/delete")
def receipt_delete(request: Request, order_id: int, receipt_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
try:
st.delete_receipt(order_id, receipt_id, by=user.get("email", ""))
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", "입고 기록을 지웠습니다 — 그만큼 다시 미입고로 잡힙니다.")
# ────────────────────────────────────────────────────────────
# 입고증 사진(003) — 입고와 함께 / 나중에 더하기 / 지우기 / 보기
# ────────────────────────────────────────────────────────────
_PHOTO_HEADERS = {
"X-Content-Type-Options": "nosniff",
"Content-Security-Policy": "default-src 'none'; img-src 'self'; style-src 'unsafe-inline'; sandbox",
"Cache-Control": "private, no-cache",
}
async def _read_photos(form: Any) -> list[tuple[str, bytes]]:
"""폼의 photos 파일들 → [(이름, 내용)]. 한 장은 한도 + 1바이트까지만 읽는다(너무 크면 검사에서 거절)."""
out: list[tuple[str, bytes]] = []
for f in form.getlist("photos"):
if not hasattr(f, "read"):
continue
if len(out) > store.MAX_PHOTOS:
raise ValueError(f"입고 한 건에 사진은 {store.MAX_PHOTOS}장까지입니다.")
out.append((str(getattr(f, "filename", "") or ""), await f.read(store.MAX_PHOTO_BYTES + 1)))
return out
@router.post("/orders/{order_id}/receipts/{receipt_id}/photos")
async def receipt_photos_add(request: Request, order_id: int, receipt_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
try:
n = st.add_receipt_photos(order_id, receipt_id, await _read_photos(await request.form()), by=user.get("email", ""))
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", f"입고증 사진 {n}장을 더했습니다.")
@router.post("/orders/{order_id}/photos/{photo_id}/delete")
def receipt_photo_delete(request: Request, order_id: int, photo_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
try:
st.delete_receipt_photo(order_id, photo_id)
except (ValueError, LookupError) as exc:
return _redirect(f"/inout/orders/{order_id}", str(exc))
return _redirect(f"/inout/orders/{order_id}", "사진을 지웠습니다.")
@router.post("/orders/{order_id}/photos/{photo_id}/rotate")
def receipt_photo_rotate(request: Request, order_id: int, photo_id: int, degrees: int = Query(...)) -> Any:
"""크게 보기 창의 회전 버튼 — 창을 닫지 않게 JSON 으로 답한다(화면이 사진을 다시 받아 그림)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "receive")
try:
st.rotate_receipt_photo(order_id, photo_id, degrees)
except (ValueError, LookupError) as exc:
return JSONResponse({"error": str(exc)}, status_code=400)
return JSONResponse({"ok": True})
@router.get("/photos/{photo_id}")
def photo_view(request: Request, photo_id: int) -> Response:
_user(request)
st = _store(request)
row = st.get_photo(photo_id) if st is not None else None
if row is None:
raise HTTPException(status_code=404, detail="사진을 찾을 수 없습니다.")
from hashlib import md5 # noqa: WPS433
from urllib.parse import quote # noqa: WPS433
data = bytes(row["data"])
# 돌린 사진이 하루 동안 예전 모습으로 남지 않게 — 브라우저가 매번 내용이 같은지 묻는다(no-cache + ETag)
etag = '"' + md5(data, usedforsecurity=False).hexdigest() + '"'
if request.headers.get("if-none-match") == etag:
return Response(status_code=304, headers={"ETag": etag, "Cache-Control": _PHOTO_HEADERS["Cache-Control"]})
name = quote(str(row["filename"] or f"photo-{photo_id}"))
disp = "attachment" if row["content_type"] == "image/heic" else "inline" # HEIC 은 브라우저가 못 보여 줌 → 내려받기
return Response(content=data, media_type=row["content_type"],
headers={**_PHOTO_HEADERS, "ETag": etag, "Content-Disposition": f"{disp}; filename*=UTF-8''{name}"})
# ────────────────────────────────────────────────────────────
# 발주 메일 — 발주 담당 본인 Gmail(003). 연결은 사람마다 한 번, 보내기는 [메일 발송]을 눌렀을 때만.
# ────────────────────────────────────────────────────────────
def _callback_url(request: Request) -> str:
from app.main import public_url_for # noqa: WPS433
return public_url_for(request, "inout_gmail_callback")
def _safe_next(nxt: Any) -> str:
s = str(nxt or "")
return s if s.startswith("/inout/") and "//" not in s and "\\" not in s else "/inout/"
@router.get("/gmail/connect")
async def gmail_connect(request: Request, next: str = "/inout/") -> Any: # noqa: A002 — 쿼리 이름
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "mail")
from app.main import ALLOWED_DOMAIN, public_url_for # noqa: WPS433
from . import gmail # noqa: WPS433
try:
client = gmail.oauth_client()
except gmail.GmailError as exc:
return _redirect(_safe_next(next), str(exc))
request.session["_inout_gmail_next"] = _safe_next(next)
request.session.pop("_gmail_origin", None) # 휴가·안내문 발송에서 시작한 연결 표시가 남아 있으면 지움
return await client.authorize_redirect(
request, public_url_for(request, "inout_gmail_callback"),
access_type="offline", prompt="consent", include_granted_scopes="true",
login_hint=user.get("email", ""), hd=ALLOWED_DOMAIN)
@router.get("/gmail/callback", name="inout_gmail_callback")
async def gmail_callback(request: Request) -> Any:
if request.session.get("_gmail_origin") in _GMAIL_ORIGINS:
return await _gmail_callback_vacation(request)
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "mail")
from authlib.integrations.starlette_client import OAuthError # noqa: WPS433
from . import gmail # noqa: WPS433
nxt = _safe_next(request.session.pop("_inout_gmail_next", "/inout/"))
email = user.get("email", "")
try:
token = await gmail.oauth_client().authorize_access_token(request)
refresh, scopes = gmail.check_grant(token, expected_email=email)
st.save_gmail_token(email, refresh_token_enc=gmail.encrypt_token(email, refresh), scopes=scopes)
except OAuthError as exc:
msg = "Gmail 연결을 취소했습니다." if exc.error == "access_denied" else f"Gmail 연결 실패({exc.error})"
return _redirect(nxt, msg)
except (gmail.GmailError, ValueError) as exc:
return _redirect(nxt, str(exc))
return _redirect(nxt, "Gmail 을 연결했습니다 — 이제 [메일 발송]으로 보낼 수 있습니다.")
# 다른 모듈에서 시작한 [Gmail 연결] — 세션 _gmail_origin = 모듈 키 → (돌아갈 기본 주소, 권한 없을 때 문구, 연결 뒤 문구)
_GMAIL_ORIGINS: dict[str, tuple[str, str, str]] = {
"vacation": ("/vacation/options", "휴가 관리 모듈 권한이 없습니다.", "Gmail 을 연결했습니다 — 이제 휴가 메일이 내 Gmail 로 나갑니다."),
"outreach": ("/outreach/", "안내문 발송 모듈 권한이 없습니다.", "Gmail 을 연결했습니다 — 이제 안내문 메일을 내 Gmail 로 보낼 수 있습니다."),
}
async def _gmail_callback_vacation(request: Request) -> Any:
"""휴가 옵션·안내문 발송의 [Gmail 연결](2026-10-27) — 같은 구글 리디렉션 주소를 함께 쓰므로 여기로 돌아온다(구글 클라우드 설정 추가 없음).
입출고 담당 권한 대신 그 모듈 권한(_GMAIL_ORIGINS)을 보고, 토큰은 입출고와 같은 inout_gmail_tokens 에(한 사람 = 연결 하나, 모듈이 같이 씀).
돌아갈 주소 = 세션 _gmail_next(그 모듈 경로 아래만, 예전 휴가 _vacation_gmail_next 도 읽음)."""
from urllib.parse import quote # noqa: WPS433
from authlib.integrations.starlette_client import OAuthError # noqa: WPS433
from app.main import get_current_user_record # noqa: WPS433
from app.store import has_module # noqa: WPS433
from . import gmail # noqa: WPS433
origin = str(request.session.pop("_gmail_origin", "") or "")
home, denied, done = _GMAIL_ORIGINS[origin]
nxt = str(request.session.pop("_gmail_next", "") or request.session.pop("_vacation_gmail_next", "") or "")
request.session.pop("_vacation_gmail_next", None)
if not nxt.startswith(f"/{origin}/") or "//" in nxt or "\\" in nxt:
nxt = home
user = get_current_user_record(request)
if user is None:
return RedirectResponse(url="/login?next=" + quote(nxt, safe=""), status_code=303)
# 휴가 협의자는 휴가 권한이 없어도 연결한다 — 휴가 연결 시작 때 그 신청의 협의자인지 확인해 세션에 남긴 값(2026-11-02)
if not request.session.pop("_gmail_consultant", False) and not has_module(user, origin):
raise HTTPException(status_code=403, detail=denied)
st = _store(request)
if st is None:
return _redirect(nxt, "Gmail 연결 저장소(입출고 DB)가 설정되지 않아 연결할 수 없습니다.")
email = user.get("email", "")
try:
token = await gmail.oauth_client().authorize_access_token(request)
refresh, scopes = gmail.check_grant(token, expected_email=email)
st.save_gmail_token(email, refresh_token_enc=gmail.encrypt_token(email, refresh), scopes=scopes)
except OAuthError as exc:
msg = "Gmail 연결을 취소했습니다." if exc.error == "access_denied" else f"Gmail 연결 실패({exc.error})"
return _redirect(nxt, msg)
except (gmail.GmailError, ValueError) as exc:
return _redirect(nxt, str(exc))
return _redirect(nxt, done)
@router.post("/gmail/disconnect")
def gmail_disconnect(request: Request) -> JSONResponse:
user = _user(request)
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail="입출고 관리 모듈이 설정되지 않았습니다.")
from . import gmail # noqa: WPS433
row = st.gmail_token(user.get("email", ""))
if row:
try:
gmail.revoke(gmail.decrypt_token(user.get("email", ""), row["refresh_token_enc"]))
except (gmail.GmailError, gmail.GmailNotConnected):
pass
st.delete_gmail_token(user.get("email", ""))
return JSONResponse({"ok": True, "message": "Gmail 연결을 끊었습니다."})
def _mail_order(request: Request, order_id: int) -> tuple[Any, dict[str, Any], dict[str, Any]]:
user = _user(request)
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail="입출고 관리 모듈이 설정되지 않았습니다.")
_require(st, user, "order")
order = _order_or_404(st, order_id)
if order["cancelled_at"]:
raise HTTPException(status_code=400, detail="취소된 발주서는 메일로 보낼 수 없습니다.")
if store.is_simple_mail_factory(order["factory_name"]) and st.boxes_ready(): # 박스 칸 — 발주 품목에 없어 지금 상품 정보 값
found = st.catalog_lookup([x["item_code"] for x in order["lines"]])
for x in order["lines"]:
x.update(store.box_info(found.get(x["item_code"]) or {}))
return st, user, order
@router.get("/orders/{order_id}/mail")
def mail_preview(request: Request, order_id: int) -> JSONResponse:
"""메일 미리보기 — 받는 사람(공장 이메일)·제목·본문, Gmail 연결 여부, 보낸 기록."""
st, user, order = _mail_order(request, order_id)
from . import gmail # noqa: WPS433
mail = store.order_mail(order, sender_name=str(user.get("name") or ""), sender_email=user.get("email", ""))
tok = st.gmail_token(user.get("email", ""))
return JSONResponse({
"connected": tok is not None, "configured": gmail.configured(),
"connect_url": f"/inout/gmail/connect?{urlencode({'next': f'/inout/orders/{order_id}?mail=1'})}",
"callback_url": _callback_url(request), # 구글 클라우드 승인된 리디렉션 URI 에 등록해야 하는 주소(안내용)
"from": user.get("email", ""), "to": order.get("factory_email") or "", "factory": order["factory_name"],
"cc": st.get_settings()[store.SETTING_ORDER_MAIL_CC], # 참조 기본(옵션 → 공장, 처음엔 king@dbxcorp.co.kr)
"notice_to": _receive_emails(st), # 발송하면 이 입고 담당들에게 발주 알림이 따로 감
"subject": mail["subject"], "html": mail["html"],
"sent": [{"at": store.fmt_datetime(m["sent_at"]), "by": m["sent_by"], "to": m["to_addrs"]} for m in order["mails"]],
})
@router.post("/orders/{order_id}/mail")
def mail_send(request: Request, order_id: int, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""[메일 발송] — 사람이 누를 때만. 이미 보낸 발주서는 resend=true 를 함께 보내야(실수로 두 번 보내지 않게)."""
st, user, order = _mail_order(request, order_id)
from . import gmail # noqa: WPS433
email = user.get("email", "")
try:
to = store.parse_emails(payload.get("to"), label="받는 사람", required=True)
cc = store.parse_emails(payload.get("cc"), label="참조")
# 미리보기 창에서 본문을 고쳤으면 그 HTML(2026-10-27) — 안 고쳤으면 보내지 않고 서버가 만든 본문 그대로
edited = store.clean_mail_html(payload["html"]) if payload.get("html") else None
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from None
if order["mails"] and not payload.get("resend"):
return JSONResponse({"ok": False, "resend_needed": True,
"message": f"이미 {len(order['mails'])}번 보낸 발주서입니다. 다시 보낼까요?"}, status_code=409)
row = st.gmail_token(email)
if row is None:
return JSONResponse({"ok": False, "reconnect": True, "message": "Gmail 이 연결되지 않았습니다 — 먼저 [Gmail 연결]을 하세요."},
status_code=409)
mail = store.order_mail(order, sender_name=str(user.get("name") or ""), sender_email=email)
if edited is not None:
mail = {**mail, "html": edited, "text": store.mail_html_to_text(edited)}
try:
refresh = gmail.decrypt_token(email, row["refresh_token_enc"])
raw = gmail.build_message(sender_name=str(user.get("name") or ""), sender_email=email, to=to, cc=cc,
subject=mail["subject"], text=mail["text"], html=mail["html"])
gid = gmail.send(refresh, raw)
except gmail.GmailNotConnected as exc:
st.delete_gmail_token(email)
return JSONResponse({"ok": False, "reconnect": True, "message": str(exc)}, status_code=409)
except gmail.GmailError as exc:
st.mark_gmail(email, error=str(exc))
return JSONResponse({"ok": False, "message": str(exc)}, status_code=502)
st.add_order_mail(order_id, sent_by=email, to=to, cc=cc, subject=mail["subject"], gmail_id=gid)
st.mark_gmail(email)
note = _send_order_notice(st, user, order, refresh, subject=mail["subject"])
return JSONResponse({"ok": True, "message": f"메일을 보냈습니다 → {', '.join(to)}" + (f" · {note}" if note else ""),
"notice": note})
def _receive_emails(st: Any) -> list[str]:
"""발주 알림 받는 사람 = 옵션 → 담당자의 입고 담당(지정된 사람만, ERP 관리자는 자동으로 넣지 않음)."""
return list(st.list_roles().get(store.ROLE_RECEIVE) or [])
def _send_order_notice(st: Any, user: dict[str, Any], order: dict[str, Any], refresh: str, *, subject: str) -> str:
"""발주 메일을 보낸 뒤 입고 담당들에게 따로 자동 발송(2026-10-19) — 같은 Gmail·같은 제목, 내용은 발주번호·발주일·품목(코드·이름·수량).
공장 메일은 이미 나갔으므로 여기 실패는 막지 않고 안내 문구만 돌려준다."""
from . import gmail # noqa: WPS433
to = _receive_emails(st)
if not to:
return "입고 담당이 옵션에 없어 발주 알림 메일은 보내지 않았습니다"
email = user.get("email", "")
m = store.order_notice_mail(order, subject=subject, sender_name=str(user.get("name") or ""), sender_email=email)
try:
raw = gmail.build_message(sender_name=str(user.get("name") or ""), sender_email=email, to=to, cc=[],
subject=m["subject"], text=m["text"], html=m["html"])
gmail.send(refresh, raw)
except (gmail.GmailError, gmail.GmailNotConnected) as exc:
_log.warning("inout order notice mail failed: %s (%s)", order.get("order_no"), exc)
return f"입고 담당 알림 메일은 보내지 못했습니다({exc})"
return f"입고 담당 {len(to)}명에게 발주 알림 메일도 보냈습니다"
# ────────────────────────────────────────────────────────────
# 입고 요청 메일 — 입고 담당 본인 Gmail(005). 입고 저장 뒤 미리보기 → [메일 발송], 받는 사람 = 옵션 → 물류센터 이메일.
# 본문 = 입고 상품 표 + 입고증 사진(본문 안 이미지, 가로 600px 이하 — store.mail_images).
# ────────────────────────────────────────────────────────────
def _mail_receipt(request: Request, order_id: int, receipt_id: int) -> tuple[Any, dict[str, Any], dict[str, Any], dict[str, Any]]:
user = _user(request)
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail="입출고 관리 모듈이 설정되지 않았습니다.")
_require(st, user, "receive")
order = _order_or_404(st, order_id)
receipt = next((r for r in order["receipts"] if int(r["id"]) == receipt_id), None)
if receipt is None:
raise HTTPException(status_code=404, detail="입고 기록을 찾을 수 없습니다.")
return st, user, order, receipt
def _receipt_mail_parts(st: Any, user: dict[str, Any], order: dict[str, Any],
receipt: dict[str, Any]) -> tuple[dict[str, str], list[dict[str, Any]], int]:
images, skipped = store.mail_images(st.receipt_photo_data(int(receipt["id"])))
mail = store.receipt_mail(order, receipt, images=images, skipped=skipped,
sender_name=str(user.get("name") or ""), sender_email=user.get("email", ""))
return mail, images, skipped
@router.get("/orders/{order_id}/receipts/{receipt_id}/mail")
def receipt_mail_preview(request: Request, order_id: int, receipt_id: int) -> JSONResponse:
"""입고 요청 메일 미리보기 — 받는 사람(물류센터)·참조(기본 king@·bj@)·제목·본문(사진은 미리보기용 data: 로), 보낸 기록."""
st, user, order, receipt = _mail_receipt(request, order_id, receipt_id)
from . import gmail # noqa: WPS433
conf = st.get_settings()
mail, images, skipped = _receipt_mail_parts(st, user, order, receipt)
tok = st.gmail_token(user.get("email", ""))
return JSONResponse({
"kind": "receipt", "connected": tok is not None, "configured": gmail.configured(), "ready": st.settings_ready(),
"connect_url": f"/inout/gmail/connect?{urlencode({'next': f'/inout/orders/{order_id}?rmail={receipt_id}'})}",
"callback_url": _callback_url(request),
"from": user.get("email", ""), "to": conf[store.SETTING_LOGISTICS_EMAILS], "cc": conf[store.SETTING_RECEIPT_MAIL_CC],
"subject": mail["subject"], "html": store.inline_preview_html(mail["html"], images),
"photos": len(images), "photos_skipped": skipped,
"sent": [{"at": store.fmt_datetime(m["sent_at"]), "by": m["sent_by"], "to": m["to_addrs"]} for m in receipt["mails"]],
})
@router.post("/orders/{order_id}/receipts/{receipt_id}/mail")
def receipt_mail_send(request: Request, order_id: int, receipt_id: int, payload: dict[str, Any] = Body(...)) -> JSONResponse:
"""[메일 발송] — 사람이 누를 때만. 이미 보낸 입고는 resend=true 를 함께(실수로 두 번 보내지 않게)."""
st, user, order, receipt = _mail_receipt(request, order_id, receipt_id)
from . import gmail # noqa: WPS433
email = user.get("email", "")
try:
to = store.parse_emails(payload.get("to"), label="받는 사람", required=True)
cc = store.parse_emails(payload.get("cc"), label="참조")
except ValueError as exc:
raise HTTPException(status_code=400, detail=str(exc)) from None
if receipt["mails"] and not payload.get("resend"):
return JSONResponse({"ok": False, "resend_needed": True,
"message": f"이 입고는 이미 {len(receipt['mails'])}번 입고 요청 메일을 보냈습니다. 다시 보낼까요?"},
status_code=409)
row = st.gmail_token(email)
if row is None:
return JSONResponse({"ok": False, "reconnect": True, "message": "Gmail 이 연결되지 않았습니다 — 먼저 [Gmail 연결]을 하세요."},
status_code=409)
mail, images, _skipped = _receipt_mail_parts(st, user, order, receipt)
try:
refresh = gmail.decrypt_token(email, row["refresh_token_enc"])
raw = gmail.build_message(sender_name=str(user.get("name") or ""), sender_email=email, to=to, cc=cc,
subject=mail["subject"], text=mail["text"], html=mail["html"], inline_images=images)
gid = gmail.send(refresh, raw)
except gmail.GmailNotConnected as exc:
st.delete_gmail_token(email)
return JSONResponse({"ok": False, "reconnect": True, "message": str(exc)}, status_code=409)
except gmail.GmailError as exc:
st.mark_gmail(email, error=str(exc))
return JSONResponse({"ok": False, "message": str(exc)}, status_code=502)
st.add_receipt_mail(receipt_id, sent_by=email, to=to, cc=cc, subject=mail["subject"], gmail_id=gid)
st.mark_gmail(email)
return JSONResponse({"ok": True, "message": f"입고 요청 메일을 보냈습니다 → {', '.join(to)}"})
@router.get("/orders/{order_id}/receipts/{receipt_id}/sabangnet.xlsx")
def receipt_sabangnet_file(request: Request, order_id: int, receipt_id: int) -> Any:
"""사방넷 입고 파일(2026-10-19) — 입고 1건을 엑셀로. 1행 제목 상품코드·가용수량·불용수량,
상품코드 = 코드표 사방넷 코드, 가용수량 = 입고 수량, 불용수량 = 상품 이름(사용자 지정). 발주·입고 담당.
사방넷 코드가 없는 품목이 하나라도 있거나 코드표를 못 읽으면 파일을 만들지 않고 발주서로 돌아가 안내한다(빈 칸 업로드 방지)."""
from urllib.parse import quote # noqa: WPS433
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "mail")
order = _order_or_404(st, order_id)
receipt = next((r for r in order["receipts"] if int(r["id"]) == receipt_id), None)
if receipt is None:
raise HTTPException(status_code=404, detail="입고 기록을 찾을 수 없습니다.")
reader = _items(request)
codes = reader.sabangnet_codes([x["item_code"] for x in receipt["lines"]]) if reader is not None else None
back = f"/inout/orders/{order_id}"
if codes is None:
why = (getattr(reader, "last_error", "") or getattr(reader, "reason", "")) if reader is not None else "없음"
return _redirect(back, f"코드표(itemcode_db)를 읽지 못해 사방넷 입고 파일을 만들 수 없습니다 — {why}")
rows, missing = store.sabangnet_rows(receipt, codes)
if missing:
return _redirect(back, "코드표에 사방넷 코드가 없는 상품이 있어 사방넷 입고 파일을 만들지 않았습니다: " + ", ".join(missing))
name = store.sabangnet_filename(order, receipt)
return Response(content=store.sabangnet_xlsx(rows),
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
headers={"Content-Disposition": f"attachment; filename=\"sabangnet_{receipt_id}.xlsx\"; filename*=UTF-8''{quote(name)}"})
# ────────────────────────────────────────────────────────────
# 옵션 — 공장·발주 담당·입고 담당(ERP 관리자)
# ────────────────────────────────────────────────────────────
def _candidates() -> list[dict[str, str]]:
"""담당자 후보 — 입출고 모듈 권한이 있는 등록 사용자."""
from app.main import user_store # noqa: WPS433
from app.store import has_module # noqa: WPS433
out = []
for u in user_store.list_all():
if has_module(u, "inout"):
out.append({"email": str(u.get("email") or "").lower(), "name": str(u.get("name") or ""),
"picture": str(u.get("picture") or "")}) # 옵션 → 담당자 = 아이콘 + 이름(2026-10-21)
return sorted(out, key=lambda x: x["email"])
def _options_ctx(request: Request, st: Any) -> dict[str, Any]:
roles = st.list_roles()
cands = _candidates()
known = {c["email"] for c in cands}
for emails in roles.values(): # 권한이 빠졌어도 담당으로 남아 있는 사람은 보여 줘야 뺄 수 있다
for e in emails:
if e not in known:
cands.append({"email": e, "name": "(입출고 모듈 권한 없음)", "picture": ""})
known.add(e)
reader = _items(request)
products = st.list_products()
bags_ready = st.bags_ready()
for pr in products:
pr["silver_g"] = store.silver_g(pr.get("weight_g"), pr.get("silver_pct"))
pr["is_bag"] = bags_ready and store.is_bag(pr.get("item_name"))
return {"products": products, "excluded": st.list_excluded(), "products_ready": st.products_ready(),
"groups": st.list_groups(), "groups_ready": st.groups_ready(), "colors": store.COLORS,
"boxes_ready": st.boxes_ready(),
"fmt_num": store.fmt_num,
"factories": st.list_factories(include_inactive=True), "roles": roles, "role_labels": store.ROLE_LABELS,
"settings": st.get_settings(), "settings_ready": st.settings_ready(),
"candidates": cands,
"items_status": "연결됨" if reader is not None and reader.enabled else (reader.reason if reader else "없음")}
def _is_popup(request: Request) -> bool:
"""옵션 팝업(inout.js)이 보낸 요청 — 이동 대신 JSON 으로 답하고 팝업이 제자리에서 다시 그린다."""
return request.headers.get("x-inout-options") == "1"
def _options_done(request: Request, message: str, *, ok: bool = True) -> Any:
if _is_popup(request):
return JSONResponse({"ok": ok, "message": message}, status_code=200 if ok else 400)
return _redirect("/inout/?options=1", message)
@router.get("/settings", response_class=HTMLResponse)
def settings(request: Request, panel: int = 0) -> Any:
"""옵션 — 팝업(톱니)으로 연다. panel=1 = 팝업 안 내용만, 그 밖엔 발주 목록으로 가서 팝업을 띄운다(예전 주소 호환)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
if not panel:
return RedirectResponse(url="/inout/?options=1", status_code=303)
from app.main import render_template # noqa: WPS433
return render_template(request, "inout/_options_panel.html", _options_ctx(request, st))
@router.post("/settings/factories")
async def settings_factory_save(request: Request) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
form = await request.form()
try:
st.save_factory(factory_id=_opt_int(form.get("id")), name=str(form.get("name") or ""),
manager=str(form.get("manager") or ""), contact=str(form.get("contact") or ""),
email=str(form.get("email") or ""),
memo=str(form.get("memo") or ""), is_active=form.get("is_active") == "1",
sort_order=_opt_int(form.get("sort_order")) or 0)
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, "공장을 저장했습니다.")
@router.post("/settings/logistics")
async def settings_logistics_save(request: Request) -> Any:
"""옵션 → 물류센터 — 입고 요청 메일 받는 주소(물류센터 입고 담당자)·참조 기본값(005)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
form = await request.form()
try:
st.save_settings({
store.SETTING_LOGISTICS_EMAILS: store.clean_emails(form.get("logistics_emails"), label="물류센터 담당자 이메일"),
store.SETTING_RECEIPT_MAIL_CC: store.clean_emails(form.get("receipt_mail_cc"), label="참조"),
}, by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, "물류센터 이메일을 저장했습니다.")
@router.post("/settings/order-mail")
async def settings_order_mail_save(request: Request) -> Any:
"""옵션 → 공장 — 발주 메일 참조 기본값(2026-10-19, 저장은 005 의 inout_settings)."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
form = await request.form()
try:
st.save_settings({store.SETTING_ORDER_MAIL_CC: store.clean_emails(form.get("order_mail_cc"), label="발주 메일 참조")},
by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, "발주 메일 참조를 저장했습니다.")
@router.post("/settings/factories/{factory_id}/delete")
def settings_factory_delete(request: Request, factory_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
try:
st.delete_factory(factory_id)
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, "공장을 지웠습니다.")
@router.post("/settings/roles")
async def settings_roles(request: Request) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
form = await request.form()
for role in store.ROLES:
st.set_role_members(role, [str(e) for e in form.getlist(f"{role}_email")], by=user.get("email", ""))
return _options_done(request, "담당자를 저장했습니다.")
@router.post("/settings/products/import")
def settings_products_import(request: Request) -> Any:
"""[단품 불러오기] — 코드표 단품 전체 → 상품 정보. 값을 넣은 상품·제외한 단품은 그대로."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
reader = _items(request)
items = reader.list_all() if reader is not None else None
if items is None:
return _options_done(request, "코드표 DB(itemcode_db)에 연결할 수 없어 단품을 불러오지 못했습니다"
+ ("" if reader is None or reader.enabled else " (ITEMCODE_DB_URL 미설정)") + ".", ok=False)
try:
r = st.import_products(items, by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
parts = [f"새 단품 {r['added']}개"]
if r["renamed"]:
parts.append(f"이름 바뀐 {r['renamed']}개")
if r["kept"]:
parts.append(f"값을 넣은 {r['kept']}개는 그대로")
if r["excluded"]:
parts.append(f"지운 {r['excluded']}개는 건너뜀")
return _options_done(request, "단품을 불러왔습니다 — " + ", ".join(parts) + ".")
@router.post("/settings/products/save")
def settings_products_save(request: Request, payload: dict[str, Any] = Body(...)) -> Any:
"""단가·무게·은 함유량 저장 — rows = [{code, unit_price, weight_g, silver_pct}](바뀐 줄만). 하나라도 틀리면 아무것도 저장 안 함."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
rows, errors = [], []
for r in (payload.get("rows") or [])[:5000]:
code = str((r or {}).get("code") or "").strip().upper()
try:
row = {"code": code, **store.validate_product_values(r)}
if "boxes_per_pallet" in (r or {}): # 008 — 봉투·백(박스당 수량·1파렛트당 박스 수량)
row.update(store.validate_bag_values(r))
elif "body_per_box" in (r or {}): # 007 — 통·뚜껑 박스 입수(빈칸 = 없음)
row.update(store.validate_box_values(r))
if "group_id" in (r or {}): # 006 — 그룹(빈칸 = 그룹 없음)·상품 자기 색상
gid = str(r.get("group_id") or "").strip()
if gid and not gid.isdigit():
raise ValueError("그룹이 올바르지 않습니다.")
row["group_id"] = int(gid) if gid else None
row["color"] = store.norm_color(r.get("color"))
rows.append(row)
except ValueError as exc:
errors.append(f"{code}: {exc}")
if errors:
return _options_done(request, "저장하지 못했습니다 — " + " / ".join(errors[:5]) + (" …" if len(errors) > 5 else ""), ok=False)
if not rows:
return _options_done(request, "바뀐 값이 없습니다.", ok=False)
try:
n = st.save_products(rows, by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, f"상품 정보 {n}개를 저장했습니다.")
@router.post("/settings/groups")
async def settings_group_save(request: Request) -> Any:
"""상품 그룹 만들기·고치기(006) — 이름·은 함유량·색상·순서. 그룹 상품 모두에 은 함유량·색상이 적용된다."""
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
form = await request.form()
try:
vals = store.validate_group(dict(form))
gid = _opt_int(form.get("id"))
st.save_group(group_id=gid, by=user.get("email", ""), **vals)
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, f"그룹 '{vals['name']}' 을(를) {'저장' if gid else '추가'}했습니다.")
@router.post("/settings/groups/{group_id}/delete")
def settings_group_delete(request: Request, group_id: int) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
try:
name = st.delete_group(group_id)
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, f"그룹 '{name}' 을(를) 지웠습니다 — 그 상품들은 그룹 없음(상품마다 값)으로 바뀝니다.")
@router.post("/settings/products/{code}/exclude")
def settings_product_exclude(request: Request, code: str) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
try:
st.exclude_product(code.strip().upper(), by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, f"{code} 를 지웠습니다 — 다음 불러오기에서도 빠집니다(제외 목록에서 되살릴 수 있음).")
@router.post("/settings/products/{code}/restore")
def settings_product_restore(request: Request, code: str) -> Any:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "admin")
try:
st.restore_product(code.strip().upper(), by=user.get("email", ""))
except ValueError as exc:
return _options_done(request, str(exc), ok=False)
return _options_done(request, f"{code} 를 되살렸습니다.")
# ────────────────────────────────────────────────────────────
# API · 상태
# ────────────────────────────────────────────────────────────
@router.get("/api/items")
def api_items(request: Request, q: str = "") -> JSONResponse:
"""발주서 제품 고르기 — 옵션 → 상품 정보(불러온 단품, 지운 것 제외)가 있으면 거기서, 없으면 코드표 단품."""
_user(request)
st = _store(request)
if st is not None and st.catalog_count() > 0:
rows = st.catalog_search(q, limit=30)
return JSONResponse({"enabled": True, "source": "products", "items": [
{"code": r["item_code"], "name": r["item_name"],
"unit_price": store.fmt_num(r["unit_price"]) if r["unit_price"] is not None else "",
"price": float(r["unit_price"]) if r["unit_price"] is not None else None,
"weight_g": store.fmt_num(r["weight_g"]) if r["weight_g"] is not None else "",
"silver_pct": store.fmt_num(r["silver_pct"], 4) if r["silver_pct"] is not None else "",
"color": r.get("color") or "none",
**store.box_info(r)} for r in rows]})
reader = _items(request)
if reader is None or not reader.enabled:
return JSONResponse({"items": [], "enabled": False,
"message": "코드표 DB(ITEMCODE_DB_URL)가 연결되지 않았습니다."})
return JSONResponse({"items": reader.search(q, limit=30), "enabled": True})
@router.get("/api/calendar")
def api_calendar(request: Request, month: str = "") -> JSONResponse:
"""오른쪽 달력(2026-10-21) — month=YYYY-MM(없으면 이번 달) 앞뒤 주까지(6주 칸)의 날짜별 발주·입고.
days = {"YYYY-MM-DD": {"orders": [...], "receipts": [...]}}, holidays = {"YYYY-MM-DD": 이름}."""
from datetime import timedelta # noqa: WPS433
_user(request)
st = _store(request)
if st is None:
raise HTTPException(status_code=503, detail="입출고 관리 DB 가 설정되지 않았습니다.")
today = today_kst()
try:
y, m = (int(x) for x in month.split("-", 1)) if month else (today.year, today.month)
first = date(y, m, 1)
except ValueError:
raise HTTPException(status_code=400, detail="month 는 YYYY-MM 입니다.") from None
start = first - timedelta(days=(first.weekday() + 1) % 7) # 일요일 시작
end = start + timedelta(days=41)
data = st.calendar(start, end)
days: dict[str, dict[str, list[dict[str, Any]]]] = {}
for o in data["orders"]:
days.setdefault(o["order_date"].isoformat(), {"orders": [], "receipts": []})["orders"].append({
"id": int(o["id"]), "order_no": o["order_no"], "factory": o["factory_name"], "qty": int(o["qty"]),
"item": (o["first_item"] or "") + (f" 외 {int(o['kinds']) - 1}종" if int(o["kinds"]) > 1 else "")})
for r in data["receipts"]:
days.setdefault(r["receipt_date"].isoformat(), {"orders": [], "receipts": []})["receipts"].append({
"id": int(r["id"]), "order_id": int(r["order_id"]), "order_no": r["order_no"], "factory": r["factory_name"],
"qty": int(r["qty"])})
holidays: dict[str, str] = {}
try:
from app.modules.project.store import holiday_name # noqa: WPS433 — 프로젝트 달력과 같은 공휴일 표
d = start
while d <= end:
name = holiday_name(d.isoformat())
if name:
holidays[d.isoformat()] = name
d += timedelta(days=1)
except Exception: # noqa: BLE001 — 공휴일 표가 없어도 달력은 보인다
holidays = {}
return JSONResponse({"month": f"{first:%Y-%m}", "start": start.isoformat(), "end": end.isoformat(),
"today": today.isoformat(), "days": days, "holidays": holidays})
@router.get("/health")
def health(request: Request) -> dict[str, str]:
return {"status": "ok" if _store(request) is not None else "not_configured"}