0ba6192e95
공장 이름에 대성화학·인천공장이 들어가면 품목 표를 번호·제품 코드· 제품명·수량·박스당 수량·박스 수·비고로 만들고, 요약 표와 글 본문에서도 금액·무게·PP·은을 뺀다. 박스 값은 메일을 만들 때의 상품 정보로 계산한다. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1263 lines
67 KiB
Python
1263 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 _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 = "", 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"}
|