Files
dbx-main/app/modules/inout/router.py
T
king fde37515c8 feat(inout): 전체 입고 완료 표기 · 날짜 서식 yyyy.mm.dd(요일)
- 모든 품목이 입고완료·초과입고면 목록·발주서 머리에 초록 "✓ 전체 입고 완료"(초과가 있으면 "초과 포함")
- 화면·메일·메일 기록 날짜를 모두 2026.10.17(토) / 2026.10.17(토) 15:14 로(ymd·ymdhm 매크로, store.fmt_date·fmt_datetime)
- 발주서 품목 합계 줄 왼쪽 여백

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-17 01:37:15 +09:00

871 lines
43 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 · GET /inout/photos/{pid} 입고증 사진
GET|POST /inout/orders/{id}/mail 발주 메일 미리보기·발송(발주 담당 본인 Gmail, 사람이 눌러야 보냄)
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
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
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 urllib.parse import quote # noqa: WPS433
from app.main import get_current_user_record # noqa: WPS433
if get_current_user_record(request) is None:
here = str(request.url.path) + ("?" + request.url.query if request.url.query else "")
return RedirectResponse(url="/login?next=" + quote(here, safe=""), status_code=303)
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}
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 == "admin" and not p["admin"]:
raise HTTPException(status_code=403, detail="옵션은 ERP 관리자만 바꿀 수 있습니다.")
return p
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(),
"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 = "active", 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
status = status if status in store.STATUS_FILTERS else "active"
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])
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 ""
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,
}, 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"],
# 입고 담당(발주 담당 아님)은 품목을 이름·발주 수량(+ 이번 입고 칸)만 — 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,
"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}/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}", 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, max-age=86400",
}
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.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 urllib.parse import quote # noqa: WPS433
name = quote(str(row["filename"] or f"photo-{photo_id}"))
disp = "attachment" if row["content_type"] == "image/heic" else "inline" # HEIC 은 브라우저가 못 보여 줌 → 내려받기
return Response(content=bytes(row["data"]), media_type=row["content_type"],
headers={**_PHOTO_HEADERS, "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, "order")
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)
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:
got = _ctx(request)
if not isinstance(got, tuple):
return got
st, user = got
_require(st, user, "order")
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 을 연결했습니다 — 이제 [메일 발송]으로 보낼 수 있습니다.")
@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="취소된 발주서는 메일로 보낼 수 없습니다.")
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"],
"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="참조")
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)
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)
return JSONResponse({"ok": True, "message": f"메일을 보냈습니다 → {', '.join(to)}"})
# ────────────────────────────────────────────────────────────
# 옵션 — 공장·발주 담당·입고 담당(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 "")})
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": "(입출고 모듈 권한 없음)"})
known.add(e)
reader = _items(request)
products = st.list_products()
for pr in products:
pr["silver_g"] = store.silver_g(pr.get("weight_g"), pr.get("silver_pct"))
return {"products": products, "excluded": st.list_excluded(), "products_ready": st.products_ready(),
"fmt_num": store.fmt_num,
"factories": st.list_factories(include_inactive=True), "roles": roles, "role_labels": store.ROLE_LABELS,
"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/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:
rows.append({"code": code, **store.validate_product_values(r)})
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/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 ""} 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("/health")
def health(request: Request) -> dict[str, str]:
return {"status": "ok" if _store(request) is not None else "not_configured"}