215b937f1e
- 발주 목록 줄 끝 휴지통 — 수퍼관리자에게만 보이고 서버도 수퍼관리자만 허용(ERP 관리자도 403) - 확인 창 후 품목·입고 기록·입고증 사진·발주 메일 기록까지 완전히 삭제(CASCADE), 서버 로그에 남김 - 지운 뒤 보던 목록(거르기 그대로)으로 — 다른 사이트 주소는 무시 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
896 lines
45 KiB
Python
896 lines
45 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
|
|
|
|
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 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,
|
|
"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 == "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 _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}/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}", 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"}
|