diff --git a/.env.example b/.env.example
index 3827037..c328a6b 100644
--- a/.env.example
+++ b/.env.example
@@ -144,6 +144,11 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
# CAFE24_MOBILE_DETAIL_FTP_PATH=/sde_design/mobile11/product/detail.html
# CAFE24_PC_DETAIL_FTP_PATH=/sde_design/skin11/product/detail.html
+# ─── 입출고 관리 모듈 (inout_db) — app/modules/inout ───
+# 본사 → 공장 발주, 물류 입고, 미입고 관리. 미설정 시 "설정 필요" 안내만.
+# 초기화: scripts/sql/inout_db_init.sql (docs/INOUT_MODULE.md). 제품(단품)은 아래 ITEMCODE_DB_URL 재사용.
+# INOUT_DB_URL=postgresql://inout_app:replace-me@postgres-db:5432/inout_db
+
# ─── 상품 검색 (itemcode_db 읽기 전용) ───
# cupang 설정 화면에서 제품명을 itemcode_db 에서 검색해 등록한다(읽기만).
# 미설정 시 검색 비활성 → 수동 등록만 가능.
diff --git a/CLAUDE.md b/CLAUDE.md
index f9712fb..96ce7b9 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -42,6 +42,8 @@ Claude Code는 이 저장소에서 작업을 시작하기 전에 **반드시 아
- 긴급 공지 (`app/modules/notice/`, `project_db` 마이그레이션 024 `urgent_notice*`) — 수퍼관리자만 작성(`/notice/`, ERP 왼쪽 아래·Project ⚙ 옵션). 제목·내용(이미지 bytea)·띄울 시각·전체/고른 사람 → ERP 모든 화면(`erp_base.html`·`main.html`·`admin.html` 의 `static/erp-notice.js`) 가로·세로 정가운데에 [확인] 누를 때까지(Esc·바깥 클릭 무시), 확인 기록. 연결 풀은 `ProjectStore.pool` 공유, 새 환경변수 없음. PC 알림 프로그램은 아직 미지원. 상세는 `docs/NOTICE_MODULE.md`
+- 입출고 관리 (`app/modules/inout/`, `inout_db`, 2026-10-16) — 본사 → 공장 제품 제작 발주(발주서 `PO-YYMMDD-NN`, 제품 = `itemcode_db.single_items` 단품만, 검색 `GET /inout/api/items`·저장 때 서버 재확인), 물류 입고를 여러 번 나눠 입력, 품목별 발주·입고·미입고, 미입고 현황(제품별 합계·발주별·지연), 초과 입고는 확인 화면 후 허용(트랜잭션 안에서 발주서 잠그고 판단, `confirm_over`), 잔량 종결·취소(입고 없을 때만). 상태는 저장하지 않고 누적 입고로 계산(`store.order_status`). 권한키 `inout`(조회), **발주 담당·입고 담당·공장은 모듈 옵션**(`/inout/settings`, ERP 관리자, `inout_roles`·`inout_factories`), 관리자는 둘 다. 이카운트 "발주 대비 미입고"·Odoo 분할 입고/종결 참고. 상세 `docs/INOUT_MODULE.md`
+
상세는 `docs/PROJECT_OVERVIEW.md`.
---
diff --git a/app/main.py b/app/main.py
index c66993c..99745a8 100644
--- a/app/main.py
+++ b/app/main.py
@@ -24,6 +24,8 @@ from .modules.dispatch import build_dispatch_store
from .modules.dispatch import router as dispatch_router
from .modules.expense import CategoryStore, build_expense_store
from .modules.expense import router as expense_router
+from .modules.inout import build_inout_items, build_inout_store
+from .modules.inout import router as inout_router
from .modules.malaysia import build_malaysia_itemcode, build_malaysia_store
from .modules.malaysia import router as malaysia_router
from .modules.notice import build_notice_store
@@ -59,6 +61,7 @@ MODULE_LABELS: dict[str, str] = {
"cafe24": "카페24 상품관리",
"performance": "실적",
"asset": "자산관리",
+ "inout": "입출고 관리",
"expense_approver": "개인경비",
"vacation_approver": "휴가",
}
@@ -153,6 +156,7 @@ _MODULE_TEMPLATE_DIRS = [
BASE_DIR / "modules" / "performance" / "templates",
BASE_DIR / "modules" / "asset" / "templates",
BASE_DIR / "modules" / "notice" / "templates",
+ BASE_DIR / "modules" / "inout" / "templates",
]
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
templates.env.loader = ChoiceLoader(
@@ -218,6 +222,10 @@ app.state.performance_store = build_performance_store(dsn=env("PERFORMANCE_DB_UR
app.state.asset_store = build_asset_store(dsn=env("ASSET_DB_URL") or None)
# 긴급 공지(ERP 전체 화면 가운데): project_db 024 — 프로젝트 저장소의 연결 풀을 같이 쓴다(없으면 None → 503).
app.state.notice_store = build_notice_store(app.state.project_store)
+# 입출고 관리(본사 → 공장 발주, 물류 입고, 미입고): INOUT_DB_URL 없으면 store=None(라우터가 "설정 필요" 안내).
+# 제품은 itemcode_db 단품(single_items) 읽기 전용 — ITEMCODE_DB_URL 재사용.
+app.state.inout_store = build_inout_store(dsn=env("INOUT_DB_URL") or None)
+app.state.inout_items = build_inout_items()
# 모듈 라우터 등록 — 신규 모듈 추가 시 여기 한 줄.
app.include_router(expense_router)
@@ -230,6 +238,7 @@ app.include_router(cafe24_router)
app.include_router(performance_router)
app.include_router(asset_router)
app.include_router(notice_router)
+app.include_router(inout_router)
def public_url_for(request: Request, route_name: str) -> str:
@@ -422,6 +431,16 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
"status": "ready",
"category": "관리",
},
+ {
+ "key": "inout",
+ "title": "입출고 관리",
+ "subtitle": "Inbound",
+ "description": "본사에서 공장으로 넣은 제작 발주와 물류 입고 수량을 맞춰 보고, 미입고·초과 입고를 관리합니다.",
+ "url": "/inout/",
+ "health_url": "/inout/health",
+ "status": "ready",
+ "category": "운영",
+ },
]
items.append({
"key": "asset", "title": "자산관리", "subtitle": "Asset Management",
@@ -437,6 +456,7 @@ def _menu_items_for(user_rec: dict[str, Any]) -> list[dict[str, Any]]:
def _icon_svg(name: str) -> str:
"""좌측 사이드바용 인라인 아이콘. 외부 의존 없는 작은 SVG."""
paths = {
+ "inout": '',
"asset": '',
"home": '',
"expense": '',
diff --git a/app/modules/inout/__init__.py b/app/modules/inout/__init__.py
new file mode 100644
index 0000000..ec5190d
--- /dev/null
+++ b/app/modules/inout/__init__.py
@@ -0,0 +1,32 @@
+"""입출고 관리(inout) 모듈 — 본사 → 공장 제품 제작 발주, 물류 입고(분할), 발주 대비 미입고·초과 관리.
+
+- 라우터: `router.py` (prefix=/inout)
+- 저장소: `db.py` (inout_db / PostgreSQL) + `store.py` (상태·검사, 순수 함수)
+- 제품: `itemcode.py` — itemcode_db.single_items(단품) 읽기 전용(ITEMCODE_DB_URL 재사용)
+- 템플릿: `templates/inout/`, 화면 스크립트·스타일 `static/inout.{js,css}`
+
+INOUT_DB_URL 미설정이면 build_inout_store 가 None → 라우터가 "설정 필요" 안내(앱은 죽지 않음).
+권한: 모듈 권한키 `inout`(조회), 발주 담당·입고 담당은 모듈 옵션(inout_roles)에서 지정, ERP 관리자는 둘 다 + 옵션.
+상세 docs/INOUT_MODULE.md.
+"""
+
+from typing import Any
+
+from .router import router
+
+__all__ = ["router", "build_inout_store", "build_inout_items"]
+
+
+def build_inout_store(*, dsn: str | None) -> Any:
+ if not dsn:
+ return None
+ from .db import InoutDBStore # 지연 import
+
+ return InoutDBStore(dsn)
+
+
+def build_inout_items() -> Any:
+ """코드표 단품 리더(ITEMCODE_DB_URL). 미설정이면 enabled=False."""
+ from .itemcode import SingleItemReader # 지연 import
+
+ return SingleItemReader()
diff --git a/app/modules/inout/db.py b/app/modules/inout/db.py
new file mode 100644
index 0000000..7d0fc46
--- /dev/null
+++ b/app/modules/inout/db.py
@@ -0,0 +1,336 @@
+"""inout_db PostgreSQL 저장소 — 공장·담당자·발주서·입고.
+
+- 드라이버: psycopg 3 + pool(다른 모듈과 같은 패턴), 연결 `INOUT_DB_URL`. 스키마는 scripts/sql/inout_db_init.sql(앱이 만들지 않음).
+- 상태(발주·부분입고·입고완료·초과·종결·취소)는 저장하지 않고 품목별 누적 입고로 계산한다(store.order_status) — 어긋날 일이 없다.
+- 쓰기는 한 트랜잭션. 입고 저장은 발주서 행을 잠그고(FOR UPDATE) 그 안에서 누적 입고를 다시 읽어 초과를 판단한다
+ (두 사람이 동시에 입고해도 초과 확인을 건너뛰지 않게).
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+from psycopg.rows import dict_row
+from psycopg_pool import ConnectionPool
+
+from . import store
+
+
+_SCAN_LIMIT = 20000 # 목록에서 상태 거르기 전에 읽는 발주서 상한
+
+
+class OverReceipt(Exception):
+ """확인 없이 발주보다 많이 입고하려 함 — over = [{item_code, item_name, ordered, after, over}]."""
+
+ def __init__(self, over: list[dict[str, Any]]) -> None:
+ super().__init__("초과 입고")
+ self.over = over
+
+
+def _norm_email(e: str) -> str:
+ return (e or "").strip().lower()
+
+
+class InoutDBStore:
+ def __init__(self, dsn: str, *, min_size: int = 1, max_size: int = 5):
+ self._pool = ConnectionPool(conninfo=dsn, min_size=min_size, max_size=max_size,
+ kwargs={"row_factory": dict_row, "autocommit": True}, open=False)
+ self._pool.open(wait=False)
+
+ def close(self) -> None:
+ self._pool.close()
+
+ # ════════════════════════════════════════════════════════════
+ # 공장
+ # ════════════════════════════════════════════════════════════
+ def list_factories(self, *, include_inactive: bool = False) -> list[dict[str, Any]]:
+ where = "" if include_inactive else "WHERE f.is_active"
+ with self._pool.connection() as conn:
+ return conn.execute(
+ "SELECT f.*, (SELECT count(*) FROM inout_orders o WHERE o.factory_id = f.id) AS order_count "
+ f"FROM inout_factories f {where} ORDER BY f.is_active DESC, f.sort_order, f.name"
+ ).fetchall()
+
+ def save_factory(self, *, factory_id: int | None, name: str, contact: str = "", memo: str = "",
+ is_active: bool = True, sort_order: int = 0) -> int:
+ name = (name or "").strip()
+ if not name or len(name) > 100:
+ raise ValueError("공장 이름을 1~100자로 입력하세요.")
+ vals = (name, (contact or "").strip()[:200], (memo or "").strip()[:store.MEMO_MAX], bool(is_active), int(sort_order))
+ with self._pool.connection() as conn:
+ dup = conn.execute("SELECT id FROM inout_factories WHERE lower(name) = lower(%s) AND id <> %s",
+ (name, factory_id or 0)).fetchone()
+ if dup:
+ raise ValueError(f"같은 이름의 공장이 이미 있습니다: {name}")
+ if factory_id:
+ row = conn.execute(
+ "UPDATE inout_factories SET name=%s, contact=%s, memo=%s, is_active=%s, sort_order=%s "
+ "WHERE id=%s RETURNING id", (*vals, factory_id)).fetchone()
+ if not row:
+ raise ValueError("공장을 찾을 수 없습니다.")
+ return int(row["id"])
+ return int(conn.execute(
+ "INSERT INTO inout_factories (name, contact, memo, is_active, sort_order) VALUES (%s,%s,%s,%s,%s) RETURNING id",
+ vals).fetchone()["id"])
+
+ def delete_factory(self, factory_id: int) -> None:
+ """발주 기록이 없는 공장만 지운다(있으면 '사용 안 함'으로 숨김)."""
+ with self._pool.connection() as conn:
+ used = conn.execute("SELECT 1 FROM inout_orders WHERE factory_id=%s LIMIT 1", (factory_id,)).fetchone()
+ if used:
+ raise ValueError("발주 기록이 있는 공장은 지울 수 없습니다 — '사용 안 함'으로 바꾸세요.")
+ conn.execute("DELETE FROM inout_factories WHERE id=%s", (factory_id,))
+
+ # ════════════════════════════════════════════════════════════
+ # 담당자(발주 담당·입고 담당)
+ # ════════════════════════════════════════════════════════════
+ def list_roles(self) -> dict[str, list[str]]:
+ out: dict[str, list[str]] = {r: [] for r in store.ROLES}
+ with self._pool.connection() as conn:
+ for r in conn.execute("SELECT email, role FROM inout_roles ORDER BY email").fetchall():
+ out.setdefault(r["role"], []).append(r["email"])
+ return out
+
+ def roles_of(self, email: str) -> set[str]:
+ with self._pool.connection() as conn:
+ rows = conn.execute("SELECT role FROM inout_roles WHERE email=%s", (_norm_email(email),)).fetchall()
+ return {r["role"] for r in rows}
+
+ def set_role_members(self, role: str, emails: list[str], *, by: str) -> None:
+ """그 역할 담당자를 통째로 바꾼다(한 트랜잭션)."""
+ if role not in store.ROLES:
+ raise ValueError("알 수 없는 담당 종류입니다.")
+ clean = sorted({_norm_email(e) for e in emails if _norm_email(e)})
+ with self._pool.connection() as conn, conn.transaction():
+ conn.execute("DELETE FROM inout_roles WHERE role=%s AND NOT (email = ANY(%s))", (role, clean))
+ for e in clean:
+ conn.execute("INSERT INTO inout_roles (email, role, created_by) VALUES (%s,%s,%s) ON CONFLICT DO NOTHING",
+ (e, role, _norm_email(by)))
+
+ # ════════════════════════════════════════════════════════════
+ # 발주서
+ # ════════════════════════════════════════════════════════════
+ def create_order(self, data: dict[str, Any], names: dict[str, str], *, by: str) -> dict[str, Any]:
+ """data = store.validate_order 결과, names = {코드: 단품 이름}. 반환 {id, order_no}."""
+ with self._pool.connection() as conn, conn.transaction():
+ self._require_factory(conn, data["factory_id"])
+ conn.execute("SELECT pg_advisory_xact_lock(hashtext('inout_order_no'))")
+ prefix = store.order_no(data["order_date"], 0)[:-2]
+ row = conn.execute("SELECT max(order_no) AS m FROM inout_orders WHERE order_no LIKE %s",
+ (prefix + "%",)).fetchone()
+ last = row["m"] if row else None
+ seq = int(last.rsplit("-", 1)[1]) + 1 if last and last.rsplit("-", 1)[1].isdigit() else 1
+ no = store.order_no(data["order_date"], seq)
+ oid = conn.execute(
+ "INSERT INTO inout_orders (order_no, factory_id, order_date, due_date, memo, created_by, updated_by) "
+ "VALUES (%s,%s,%s,%s,%s,%s,%s) RETURNING id",
+ (no, data["factory_id"], data["order_date"], data["due_date"], data["memo"], _norm_email(by), _norm_email(by)),
+ ).fetchone()["id"]
+ for i, ln in enumerate(data["lines"], start=1):
+ conn.execute("INSERT INTO inout_order_lines (order_id, line_no, item_code, item_name, qty, memo) "
+ "VALUES (%s,%s,%s,%s,%s,%s)",
+ (oid, i, ln["item_code"], names.get(ln["item_code"], ""), ln["qty"], ln["memo"]))
+ return {"id": int(oid), "order_no": no}
+
+ def update_order(self, order_id: int, data: dict[str, Any], names: dict[str, str], *, by: str) -> None:
+ """머리글·품목 고치기. 입고된 품목은 뺄 수 없다(입고 기록이 사라지므로) — 수량은 바꿀 수 있다."""
+ with self._pool.connection() as conn, conn.transaction():
+ head = self._lock_order(conn, order_id)
+ if head["cancelled_at"]:
+ raise ValueError("취소된 발주서는 고칠 수 없습니다.")
+ self._require_factory(conn, data["factory_id"], allow_inactive_id=head["factory_id"])
+ existing = {r["item_code"]: r for r in conn.execute(
+ "SELECT l.id, l.item_code, COALESCE(sum(rl.qty), 0) AS received FROM inout_order_lines l "
+ "LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id WHERE l.order_id=%s GROUP BY l.id",
+ (order_id,)).fetchall()}
+ wanted = {ln["item_code"] for ln in data["lines"]}
+ blocked = [c for c, r in existing.items() if c not in wanted and int(r["received"]) > 0]
+ if blocked:
+ raise ValueError("입고 기록이 있는 품목은 뺄 수 없습니다: " + ", ".join(sorted(blocked)))
+ for code, r in existing.items():
+ if code not in wanted:
+ conn.execute("DELETE FROM inout_order_lines WHERE id=%s", (r["id"],))
+ for i, ln in enumerate(data["lines"], start=1):
+ if ln["item_code"] in existing:
+ conn.execute("UPDATE inout_order_lines SET line_no=%s, qty=%s, memo=%s WHERE id=%s",
+ (i, ln["qty"], ln["memo"], existing[ln["item_code"]]["id"]))
+ else:
+ conn.execute("INSERT INTO inout_order_lines (order_id, line_no, item_code, item_name, qty, memo) "
+ "VALUES (%s,%s,%s,%s,%s,%s)",
+ (order_id, i, ln["item_code"], names.get(ln["item_code"], ""), ln["qty"], ln["memo"]))
+ conn.execute("UPDATE inout_orders SET factory_id=%s, order_date=%s, due_date=%s, memo=%s, updated_by=%s WHERE id=%s",
+ (data["factory_id"], data["order_date"], data["due_date"], data["memo"], _norm_email(by), order_id))
+
+ def set_closed(self, order_id: int, *, closed: bool, reason: str = "", by: str) -> None:
+ """종결(남은 미입고를 더 기다리지 않음) / 종결 풀기."""
+ with self._pool.connection() as conn, conn.transaction():
+ head = self._lock_order(conn, order_id)
+ if head["cancelled_at"]:
+ raise ValueError("취소된 발주서입니다.")
+ if closed:
+ conn.execute("UPDATE inout_orders SET closed_at=now(), closed_by=%s, close_reason=%s, updated_by=%s WHERE id=%s",
+ (_norm_email(by), (reason or "").strip()[:store.MEMO_MAX], _norm_email(by), order_id))
+ else:
+ conn.execute("UPDATE inout_orders SET closed_at=NULL, closed_by='', close_reason='', updated_by=%s WHERE id=%s",
+ (_norm_email(by), order_id))
+
+ def cancel_order(self, order_id: int, *, by: str) -> None:
+ """잘못 넣은 발주 — 입고 기록이 없을 때만 취소(기록은 남김)."""
+ with self._pool.connection() as conn, conn.transaction():
+ self._lock_order(conn, order_id)
+ if conn.execute("SELECT 1 FROM inout_receipts WHERE order_id=%s LIMIT 1", (order_id,)).fetchone():
+ raise ValueError("입고 기록이 있는 발주서는 취소할 수 없습니다 — 남은 수량은 '종결'하세요.")
+ conn.execute("UPDATE inout_orders SET cancelled_at=now(), cancelled_by=%s, updated_by=%s WHERE id=%s",
+ (_norm_email(by), _norm_email(by), order_id))
+
+ def get_order(self, order_id: int) -> dict[str, Any] | None:
+ with self._pool.connection() as conn:
+ head = conn.execute(
+ "SELECT o.*, f.name AS factory_name FROM inout_orders o JOIN inout_factories f ON f.id = o.factory_id WHERE o.id=%s",
+ (order_id,)).fetchone()
+ if not head:
+ return None
+ lines = conn.execute(
+ "SELECT l.*, COALESCE(sum(rl.qty), 0)::int AS received FROM inout_order_lines l "
+ "LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id WHERE l.order_id=%s "
+ "GROUP BY l.id ORDER BY l.line_no", (order_id,)).fetchall()
+ receipts = conn.execute("SELECT * FROM inout_receipts WHERE order_id=%s ORDER BY receipt_date, id",
+ (order_id,)).fetchall()
+ rlines = conn.execute(
+ "SELECT rl.receipt_id, rl.order_line_id, rl.qty, l.item_code, l.item_name FROM inout_receipt_lines rl "
+ "JOIN inout_order_lines l ON l.id = rl.order_line_id JOIN inout_receipts r ON r.id = rl.receipt_id "
+ "WHERE r.order_id=%s ORDER BY l.line_no", (order_id,)).fetchall()
+ by_receipt: dict[int, list[dict[str, Any]]] = {}
+ for r in rlines:
+ by_receipt.setdefault(int(r["receipt_id"]), []).append(r)
+ lines = store.decorate_lines(lines)
+ status = store.order_status(lines, closed=bool(head["closed_at"]), cancelled=bool(head["cancelled_at"]))
+ return {**head, "lines": lines, "summary": store.summarize(lines), "status": status,
+ "status_label": store.ORDER_LABELS[status],
+ "receipts": [{**r, "lines": by_receipt.get(int(r["id"]), []),
+ "total": sum(int(x["qty"]) for x in by_receipt.get(int(r["id"]), []))} for r in receipts]}
+
+ def list_orders(self, *, status: str = "active", factory_id: int | None = None, q: str = "",
+ date_from: date | None = None, date_to: date | None = None, limit: int = 500) -> list[dict[str, Any]]:
+ """목록 — 상태는 품목 합계로 계산한 뒤 거른다. q = 발주번호·제품 코드·제품 이름."""
+ where, params = ["TRUE"], []
+ if factory_id:
+ where.append("o.factory_id = %s")
+ params.append(factory_id)
+ if date_from:
+ where.append("o.order_date >= %s")
+ params.append(date_from)
+ if date_to:
+ where.append("o.order_date <= %s")
+ params.append(date_to)
+ if q.strip():
+ like = "%" + q.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
+ where.append("(o.order_no ILIKE %s OR EXISTS (SELECT 1 FROM inout_order_lines x WHERE x.order_id = o.id "
+ "AND (x.item_code ILIKE %s OR x.item_name ILIKE %s)))")
+ params += [like, like, like]
+ with self._pool.connection() as conn:
+ heads = conn.execute(
+ "SELECT o.*, f.name AS factory_name FROM inout_orders o JOIN inout_factories f ON f.id = o.factory_id "
+ # 상태는 품목 합계로 계산해 아래에서 거르므로 넉넉히 읽는다(발주서는 많아야 연 수천 건)
+ f"WHERE {' AND '.join(where)} ORDER BY o.order_date DESC, o.id DESC LIMIT {_SCAN_LIMIT}", params
+ ).fetchall()
+ ids = [h["id"] for h in heads]
+ lines = conn.execute(
+ "SELECT l.order_id, l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
+ "FROM inout_order_lines l LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
+ "WHERE l.order_id = ANY(%s) GROUP BY l.id ORDER BY l.line_no", (ids,)).fetchall() if ids else []
+ by_order: dict[int, list[dict[str, Any]]] = {}
+ for ln in lines:
+ by_order.setdefault(int(ln["order_id"]), []).append(ln)
+ allowed = store.STATUS_FILTERS.get(status, store.STATUS_FILTERS["active"])[1]
+ out = []
+ for h in heads:
+ ls = by_order.get(int(h["id"]), [])
+ st = store.order_status(ls, closed=bool(h["closed_at"]), cancelled=bool(h["cancelled_at"]))
+ if st not in allowed:
+ continue
+ names = [x["item_name"] or x["item_code"] for x in ls]
+ out.append({**h, "status": st, "status_label": store.ORDER_LABELS[st], "summary": store.summarize(ls),
+ "line_count": len(ls), "items_label": (names[0] + (f" 외 {len(names) - 1}종" if len(names) > 1 else "")) if names else ""})
+ if len(out) >= limit:
+ break
+ return out
+
+ # ════════════════════════════════════════════════════════════
+ # 입고
+ # ════════════════════════════════════════════════════════════
+ def add_receipt(self, order_id: int, quantities: dict[int, Any], *, receipt_date: Any, memo: Any,
+ confirm_over: bool, by: str) -> dict[str, Any]:
+ """입고 1건 저장. 발주를 넘는 품목이 있는데 confirm_over 가 아니면 OverReceipt(아무것도 저장 안 함)."""
+ with self._pool.connection() as conn, conn.transaction():
+ head = self._lock_order(conn, order_id)
+ if head["cancelled_at"]:
+ raise ValueError("취소된 발주서에는 입고할 수 없습니다.")
+ if head["closed_at"]:
+ raise ValueError("종결된 발주서입니다 — 입고하려면 발주 담당이 종결을 풀어야 합니다.")
+ lines = conn.execute(
+ "SELECT l.id, l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
+ "FROM inout_order_lines l LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
+ "WHERE l.order_id=%s GROUP BY l.id", (order_id,)).fetchall()
+ data = store.validate_receipt(lines, quantities, receipt_date=receipt_date, memo=memo)
+ if data["over"] and not confirm_over:
+ raise OverReceipt(data["over"])
+ rid = conn.execute("INSERT INTO inout_receipts (order_id, receipt_date, memo, created_by) VALUES (%s,%s,%s,%s) RETURNING id",
+ (order_id, data["receipt_date"], data["memo"], _norm_email(by))).fetchone()["id"]
+ for it in data["items"]:
+ conn.execute("INSERT INTO inout_receipt_lines (receipt_id, order_line_id, qty) VALUES (%s,%s,%s)",
+ (rid, it["order_line_id"], it["qty"]))
+ return {"id": int(rid), "over": data["over"], "total": sum(it["qty"] for it in data["items"])}
+
+ def delete_receipt(self, order_id: int, receipt_id: int, *, by: str) -> None:
+ """잘못 넣은 입고 1건을 지운다(그 수량만큼 다시 미입고)."""
+ with self._pool.connection() as conn, conn.transaction():
+ head = self._lock_order(conn, order_id)
+ if head["cancelled_at"]:
+ raise ValueError("취소된 발주서입니다.")
+ row = conn.execute("DELETE FROM inout_receipts WHERE id=%s AND order_id=%s RETURNING id",
+ (receipt_id, order_id)).fetchone()
+ if not row:
+ raise ValueError("입고 기록을 찾을 수 없습니다.")
+ conn.execute("UPDATE inout_orders SET updated_by=%s WHERE id=%s", (_norm_email(by), order_id))
+
+ # ════════════════════════════════════════════════════════════
+ # 미입고 현황 — 진행 중(종결·취소 아님) 발주의 남은 수량, 그리고 초과 입고
+ # ════════════════════════════════════════════════════════════
+ def outstanding(self, *, factory_id: int | None = None, q: str = "") -> dict[str, list[dict[str, Any]]]:
+ where, params = ["o.closed_at IS NULL", "o.cancelled_at IS NULL"], []
+ if factory_id:
+ where.append("o.factory_id = %s")
+ params.append(factory_id)
+ if q.strip():
+ like = "%" + q.strip().replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
+ where.append("(l.item_code ILIKE %s OR l.item_name ILIKE %s OR o.order_no ILIKE %s)")
+ params += [like, like, like]
+ with self._pool.connection() as conn:
+ rows = conn.execute(
+ "SELECT o.id AS order_id, o.order_no, o.order_date, o.due_date, f.name AS factory_name, "
+ "l.item_code, l.item_name, l.qty, COALESCE(sum(rl.qty), 0)::int AS received "
+ "FROM inout_order_lines l JOIN inout_orders o ON o.id = l.order_id "
+ "JOIN inout_factories f ON f.id = o.factory_id "
+ "LEFT JOIN inout_receipt_lines rl ON rl.order_line_id = l.id "
+ f"WHERE {' AND '.join(where)} GROUP BY l.id, o.id, f.name "
+ "ORDER BY o.due_date NULLS LAST, o.order_date, o.id, l.line_no", params).fetchall()
+ rows = store.decorate_lines(rows)
+ return {"pending": [r for r in rows if r["remaining"] > 0], "over": [r for r in rows if r["over"] > 0]}
+
+ # ── 내부 ──
+ @staticmethod
+ def _lock_order(conn: Any, order_id: int) -> dict[str, Any]:
+ head = conn.execute("SELECT * FROM inout_orders WHERE id=%s FOR UPDATE", (order_id,)).fetchone()
+ if not head:
+ raise LookupError("발주서를 찾을 수 없습니다.")
+ return head
+
+ @staticmethod
+ def _require_factory(conn: Any, factory_id: int, *, allow_inactive_id: int | None = None) -> None:
+ row = conn.execute("SELECT is_active FROM inout_factories WHERE id=%s", (factory_id,)).fetchone()
+ if not row:
+ raise ValueError("공장을 찾을 수 없습니다.")
+ if not row["is_active"] and factory_id != allow_inactive_id:
+ raise ValueError("사용하지 않는 공장입니다(옵션에서 '사용'으로 바꾸세요).")
diff --git a/app/modules/inout/itemcode.py b/app/modules/inout/itemcode.py
new file mode 100644
index 0000000..28e5d0f
--- /dev/null
+++ b/app/modules/inout/itemcode.py
@@ -0,0 +1,82 @@
+"""itemcode_db 읽기 전용 — 단품(single_items)만 검색·확인.
+
+입출고 발주서의 제품은 코드표 DB 의 단품 아이템에서만 고른다(2026-10-16 사용자 요청 — 세트는 공장 발주 대상이 아님).
+itemcode_db 실제 스키마(운영 확인됨, malaysia/itemcode.py 와 같음): single_items(item_code, sabangnet_code, name).
+환경변수 `ITEMCODE_DB_URL`(읽기 전용 역할 itemcode_ro) — cupang·malaysia 모듈과 공유.
+미설정/실패 시 enabled=False, 빈 결과(앱/모듈을 죽이지 않음) — 그때 발주서 저장은 "코드표 연결 필요"로 막는다.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger("inout.itemcode")
+
+_SEARCH_SQL = (
+ "SELECT item_code, name FROM single_items "
+ "WHERE item_code ILIKE %(q)s OR name ILIKE %(q)s "
+ "ORDER BY (item_code ILIKE %(prefix)s) DESC, item_code ASC LIMIT %(limit)s"
+)
+_LOOKUP_SQL = "SELECT item_code, name FROM single_items WHERE upper(item_code) = ANY(%(codes)s)"
+
+
+class SingleItemReader:
+ def __init__(self, dsn: str | None = None) -> None:
+ self._pool: Any = None
+ self.enabled = False
+ self.reason = ""
+ self.last_error = ""
+ self._configure(dsn if dsn is not None else os.getenv("ITEMCODE_DB_URL", "").strip())
+
+ def _configure(self, dsn: str) -> None:
+ if not dsn:
+ self.reason = "ITEMCODE_DB_URL 미설정 — 코드표(단품) 조회 비활성."
+ return
+ try:
+ from psycopg.rows import dict_row
+ from psycopg_pool import ConnectionPool
+
+ self._pool = ConnectionPool(conninfo=dsn, min_size=1, max_size=3,
+ kwargs={"row_factory": dict_row, "autocommit": True}, open=False)
+ self._pool.open(wait=False)
+ self.enabled = True
+ except Exception as exc: # noqa: BLE001 — 설정/드라이버 문제로 모듈을 죽이지 않음
+ self.reason = f"itemcode_db 연결 풀 생성 실패: {type(exc).__name__}"
+
+ def search(self, query: str, *, limit: int = 30) -> list[dict[str, str]]:
+ """코드·이름 부분 일치(코드 앞부분 일치 먼저). 반환 [{"code","name"}]. 실패는 빈 목록."""
+ q = (query or "").strip()
+ if not q or not self.enabled or not self._pool:
+ return []
+ esc = q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+ rows = self._run(_SEARCH_SQL, {"q": f"%{esc}%", "prefix": f"{esc}%", "limit": int(limit)})
+ return [{"code": str(r["item_code"]).strip(), "name": str(r.get("name") or "").strip()} for r in rows or []]
+
+ def lookup(self, codes: list[str]) -> dict[str, str] | None:
+ """코드들 → {코드(대문자): 이름}. 단품 표에 없는 코드는 빠진다. 조회 불가면 None."""
+ if not self.enabled or not self._pool:
+ return None
+ wanted = sorted({c.strip().upper() for c in codes if c and c.strip()})
+ if not wanted:
+ return {}
+ rows = self._run(_LOOKUP_SQL, {"codes": wanted})
+ if rows is None:
+ return None
+ return {str(r["item_code"]).strip().upper(): str(r.get("name") or "").strip() for r in rows}
+
+ def _run(self, sql: str, params: dict[str, Any]) -> list[dict[str, Any]] | None:
+ try:
+ with self._pool.connection() as conn:
+ rows = conn.execute(sql, params).fetchall()
+ self.last_error = ""
+ return rows
+ except Exception as exc: # noqa: BLE001 — 모듈을 죽이지 않음
+ self.last_error = f"{type(exc).__name__}"
+ logger.exception("itemcode(single_items) 조회 실패")
+ return None
+
+ def close(self) -> None:
+ if self._pool is not None:
+ self._pool.close()
diff --git a/app/modules/inout/router.py b/app/modules/inout/router.py
new file mode 100644
index 0000000..bb5e582
--- /dev/null
+++ b/app/modules/inout/router.py
@@ -0,0 +1,507 @@
+"""입출고 관리 모듈 라우터 — 본사 → 공장 발주, 물류 입고(분할), 발주 대비 미입고·초과.
+
+ 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|POST /inout/settings… 옵션 — 공장 목록·발주 담당·입고 담당(ERP 관리자)
+ GET /inout/api/items?q= 코드표 단품 검색(JSON)
+
+권한: 모듈 권한키 `inout`(조회). 발주 담당·입고 담당은 옵션(inout_roles)에서 지정, ERP 관리자는 둘 다 + 옵션.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+from urllib.parse import urlencode
+
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
+
+from app.timezone import today_kst
+
+from . import store
+from .db import OverReceipt
+
+router = APIRouter(prefix="/inout", tags=["inout"])
+
+
+# ────────────────────────────────────────────────────────────
+# 공용 헬퍼
+# ────────────────────────────────────────────────────────────
+def _store(request: Request) -> Any:
+ return getattr(request.app.state, "inout_store", None)
+
+
+def _items(request: Request) -> Any:
+ return getattr(request.app.state, "inout_items", None)
+
+
+def _user(request: Request) -> dict[str, Any]:
+ from app.main import get_current_user_record # noqa: WPS433
+ from app.store import has_module # noqa: WPS433
+
+ user = get_current_user_record(request)
+ if user is None:
+ raise HTTPException(status_code=401, detail="로그인이 필요합니다.")
+ if not has_module(user, "inout"):
+ raise HTTPException(status_code=403, detail="입출고 관리 모듈 권한이 없습니다.")
+ return user
+
+
+def _page_user(request: Request) -> Any:
+ """화면 주소 — 로그인 전이면 로그인으로 보냈다가 돌아온다."""
+ from urllib.parse import quote # noqa: WPS433
+
+ from app.main import get_current_user_record # noqa: WPS433
+
+ if get_current_user_record(request) is None:
+ here = str(request.url.path) + ("?" + request.url.query if request.url.query else "")
+ return RedirectResponse(url="/login?next=" + quote(here, safe=""), status_code=303)
+ return _user(request)
+
+
+def _is_admin(user: dict[str, Any]) -> bool:
+ from app.store import is_admin # noqa: WPS433
+
+ return is_admin(user)
+
+
+def _perms(st: Any, user: dict[str, Any]) -> dict[str, bool]:
+ """발주 담당·입고 담당 — 옵션(inout_roles), ERP 관리자는 둘 다."""
+ admin = _is_admin(user)
+ roles = set() if admin else st.roles_of(user.get("email", ""))
+ return {"admin": admin, "can_order": admin or store.ROLE_ORDER in roles,
+ "can_receive": admin or store.ROLE_RECEIVE in roles}
+
+
+def _require(st: Any, user: dict[str, Any], what: str) -> dict[str, bool]:
+ p = _perms(st, user)
+ if what == "order" and not p["can_order"]:
+ raise HTTPException(status_code=403, detail="발주 담당만 할 수 있습니다(입출고 관리 → 옵션에서 지정).")
+ if what == "receive" and not p["can_receive"]:
+ raise HTTPException(status_code=403, detail="입고 담당만 할 수 있습니다(입출고 관리 → 옵션에서 지정).")
+ if what == "admin" and not p["admin"]:
+ raise HTTPException(status_code=403, detail="옵션은 ERP 관리자만 바꿀 수 있습니다.")
+ return p
+
+
+def _render(request: Request, name: str, user: dict[str, Any], ctx: dict[str, Any], status_code: int = 200) -> HTMLResponse:
+ from app.main import build_erp_nav, render_template # noqa: WPS433
+
+ st = _store(request)
+ perms = _perms(st, user) if st is not None else {"admin": _is_admin(user), "can_order": False, "can_receive": False}
+ return render_template(request, name, {
+ "user": user, "is_admin": perms["admin"], "perms": perms,
+ "nav_items": build_erp_nav(user, active="inout"),
+ "msg": request.query_params.get("msg", ""), "today": today_kst(),
+ **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]]:
+ """폼 검사 + 코드표(단품) 확인. keep_codes = 이미 발주서에 있던 코드(코드표에서 빠졌어도 그대로 둔다)."""
+ 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:
+ 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])]
+ reader = _items(request)
+ 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),
+ }, 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 = _validated(request, st, vals, keep_codes=set())
+ res = st.create_order(data, names, by=user.get("email", ""))
+ 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']}", 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 = _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", ""))
+ 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, status_code: int = 200) -> HTMLResponse:
+ return _render(request, "inout/order_detail.html", user, {
+ "tab": "orders", "order": order, "error": error, "over": over or [],
+ "receipt_form": receipt_form or {"receipt_date": today_kst().isoformat(), "memo": "", "qty": {}},
+ "can_receive_now": order["status"] in (store.ST_OPEN, store.ST_PARTIAL, store.ST_DONE, store.ST_OVER),
+ }, status_code=status_code)
+
+
+@router.get("/orders/{order_id}", response_class=HTMLResponse)
+def order_detail(request: Request, order_id: int) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ return _detail(request, user, st, _order_or_404(st, order_id))
+
+
+@router.post("/orders/{order_id}/close")
+async def order_close(request: Request, order_id: int) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ _require(st, user, "order")
+ form = await request.form()
+ try:
+ st.set_closed(order_id, closed=True, reason=str(form.get("reason") or ""), by=user.get("email", ""))
+ except (ValueError, LookupError) as exc:
+ return _redirect(f"/inout/orders/{order_id}", str(exc))
+ return _redirect(f"/inout/orders/{order_id}", "종결했습니다 — 남은 미입고는 미입고 현황에서 빠집니다.")
+
+
+@router.post("/orders/{order_id}/reopen")
+def order_reopen(request: Request, order_id: int) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ _require(st, user, "order")
+ try:
+ st.set_closed(order_id, closed=False, by=user.get("email", ""))
+ except (ValueError, LookupError) as exc:
+ return _redirect(f"/inout/orders/{order_id}", str(exc))
+ return _redirect(f"/inout/orders/{order_id}", "종결을 풀었습니다.")
+
+
+@router.post("/orders/{order_id}/cancel")
+def order_cancel(request: Request, order_id: int) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ _require(st, user, "order")
+ try:
+ st.cancel_order(order_id, by=user.get("email", ""))
+ except (ValueError, LookupError) as exc:
+ return _redirect(f"/inout/orders/{order_id}", str(exc))
+ return _redirect(f"/inout/orders/{order_id}", "발주서를 취소했습니다.")
+
+
+# ────────────────────────────────────────────────────────────
+# 입고
+# ────────────────────────────────────────────────────────────
+@router.post("/orders/{order_id}/receipts", response_class=HTMLResponse)
+async def receipt_add(request: Request, order_id: int) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ _require(st, user, "receive")
+ form = await request.form()
+ qty: dict[int, str] = {}
+ for k, v in form.items():
+ if k.startswith("qty_") and k[4:].isdigit():
+ qty[int(k[4:])] = str(v)
+ rf = {"receipt_date": str(form.get("receipt_date") or ""), "memo": str(form.get("memo") or ""), "qty": qty}
+ try:
+ res = st.add_receipt(order_id, qty, receipt_date=rf["receipt_date"], memo=rf["memo"],
+ confirm_over=form.get("confirm_over") == "1", by=user.get("email", ""))
+ except OverReceipt as exc:
+ return _detail(request, user, st, _order_or_404(st, order_id), receipt_form=rf, over=exc.over, 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), status_code=400)
+ note = f"입고 {res['total']:,}개를 저장했습니다." + (" (초과 입고 포함)" if res["over"] 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}", "입고 기록을 지웠습니다 — 그만큼 다시 미입고로 잡힙니다.")
+
+
+# ────────────────────────────────────────────────────────────
+# 옵션 — 공장·발주 담당·입고 담당(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"])
+
+
+@router.get("/settings", response_class=HTMLResponse)
+def settings(request: Request) -> Any:
+ got = _ctx(request)
+ if not isinstance(got, tuple):
+ return got
+ st, user = got
+ _require(st, user, "admin")
+ 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)
+ return _render(request, "inout/settings.html", user, {
+ "tab": "settings", "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 "없음"),
+ })
+
+
+@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 ""),
+ contact=str(form.get("contact") 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 _redirect("/inout/settings", str(exc))
+ return _redirect("/inout/settings", "공장을 저장했습니다.")
+
+
+@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 _redirect("/inout/settings", str(exc))
+ return _redirect("/inout/settings", "공장을 지웠습니다.")
+
+
+@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 _redirect("/inout/settings", "담당자를 저장했습니다.")
+
+
+# ────────────────────────────────────────────────────────────
+# API · 상태
+# ────────────────────────────────────────────────────────────
+@router.get("/api/items")
+def api_items(request: Request, q: str = "") -> JSONResponse:
+ """코드표 단품 검색 — 발주서 제품 고르기."""
+ _user(request)
+ 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"}
diff --git a/app/modules/inout/store.py b/app/modules/inout/store.py
new file mode 100644
index 0000000..f240f60
--- /dev/null
+++ b/app/modules/inout/store.py
@@ -0,0 +1,204 @@
+"""입출고 관리 — 상수·검사·상태 계산(순수 함수, DB 없음).
+
+흐름(2026-10-16 사용자 요청, 상용 ERP 참고 — 이카운트 "발주 대비 미입고 현황"·Odoo 분할 입고/잔량 종결):
+ 발주 담당이 공장에 발주서(단품 코드·수량)를 넣고 → 물류에 들어올 때마다 입고 담당이 그날 들어온 수량을 입력(여러 번 나눠도 됨)
+ → 품목마다 발주 − 누적 입고 = 미입고. 다 들어오면 입고완료, 더 들어오면 초과입고(확인 후 허용, 빨강 표시).
+ 더 안 들어올 잔량은 발주 담당이 "종결"(이카운트 발주 종결 · Odoo No backorder) — 미입고 현황에서 빠지고 종결로 남는다.
+"""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Any, Iterable
+
+ROLE_ORDER = "order" # 발주 담당
+ROLE_RECEIVE = "receive" # 입고 담당
+ROLES = (ROLE_ORDER, ROLE_RECEIVE)
+ROLE_LABELS = {ROLE_ORDER: "발주 담당", ROLE_RECEIVE: "입고 담당"}
+
+MAX_QTY = 10_000_000
+MAX_LINES = 200
+MEMO_MAX = 500
+
+# 품목 상태
+LINE_NONE, LINE_PARTIAL, LINE_DONE, LINE_OVER = "none", "partial", "done", "over"
+LINE_LABELS = {LINE_NONE: "미입고", LINE_PARTIAL: "부분입고", LINE_DONE: "입고완료", LINE_OVER: "초과입고"}
+
+# 발주서 상태 — 진행(open·partial)은 미입고 현황에 나온다
+ST_OPEN, ST_PARTIAL, ST_DONE, ST_OVER, ST_CLOSED, ST_CANCELLED = "open", "partial", "done", "over", "closed", "cancelled"
+ORDER_LABELS = {ST_OPEN: "발주", ST_PARTIAL: "부분입고", ST_DONE: "입고완료", ST_OVER: "초과입고",
+ ST_CLOSED: "종결", ST_CANCELLED: "취소"}
+ACTIVE_STATUSES = (ST_OPEN, ST_PARTIAL) # 아직 더 들어올 것이 있는 발주
+STATUS_FILTERS = { # 목록 거르기
+ "active": ("진행 중", ACTIVE_STATUSES),
+ "done": ("완료", (ST_DONE, ST_OVER)),
+ "closed": ("종결·취소", (ST_CLOSED, ST_CANCELLED)),
+ "all": ("전체", tuple(ORDER_LABELS)),
+}
+
+
+def line_status(qty: int, received: int) -> str:
+ if received <= 0:
+ return LINE_NONE
+ if received < qty:
+ return LINE_PARTIAL
+ return LINE_DONE if received == qty else LINE_OVER
+
+
+def order_status(lines: Iterable[dict[str, Any]], *, closed: bool = False, cancelled: bool = False) -> str:
+ """lines: [{qty, received}]. 취소·종결이 먼저, 그다음 입고 합계로."""
+ if cancelled:
+ return ST_CANCELLED
+ if closed:
+ return ST_CLOSED
+ sts = [line_status(int(x["qty"]), int(x.get("received") or 0)) for x in lines]
+ if not sts or all(s == LINE_NONE for s in sts):
+ return ST_OPEN
+ if any(s in (LINE_NONE, LINE_PARTIAL) for s in sts):
+ return ST_PARTIAL
+ return ST_OVER if any(s == LINE_OVER for s in sts) else ST_DONE
+
+
+def summarize(lines: list[dict[str, Any]]) -> dict[str, int]:
+ """발주·입고·미입고(0 아래로 안 내려감)·초과 합계."""
+ ordered = sum(int(x["qty"]) for x in lines)
+ received = sum(int(x.get("received") or 0) for x in lines)
+ remaining = sum(max(int(x["qty"]) - int(x.get("received") or 0), 0) for x in lines)
+ over = sum(max(int(x.get("received") or 0) - int(x["qty"]), 0) for x in lines)
+ pct = min(100, round(received * 100 / ordered)) if ordered else 0
+ return {"ordered": ordered, "received": received, "remaining": remaining, "over": over, "pct": pct}
+
+
+def decorate_lines(lines: list[dict[str, Any]]) -> list[dict[str, Any]]:
+ """화면용 — 품목마다 미입고·초과·상태 이름."""
+ out = []
+ for x in lines:
+ qty, rec = int(x["qty"]), int(x.get("received") or 0)
+ st = line_status(qty, rec)
+ out.append({**x, "received": rec, "remaining": max(qty - rec, 0), "over": max(rec - qty, 0),
+ "status": st, "status_label": LINE_LABELS[st]})
+ return out
+
+
+# ── 입력 검사 ────────────────────────────────────────────────
+def parse_qty(raw: Any, *, label: str = "수량", allow_zero: bool = False) -> int:
+ s = str(raw if raw is not None else "").replace(",", "").strip()
+ if not s:
+ if allow_zero:
+ return 0
+ raise ValueError(f"{label}을(를) 입력하세요.")
+ try:
+ n = int(s)
+ except ValueError:
+ raise ValueError(f"{label}은(는) 정수로 입력하세요.") from None
+ if n < 0 or (n == 0 and not allow_zero):
+ raise ValueError(f"{label}은(는) {0 if allow_zero else 1} 이상이어야 합니다.")
+ if n > MAX_QTY:
+ raise ValueError(f"{label}이(가) 너무 큽니다.")
+ return n
+
+
+def parse_date(raw: Any, *, label: str, required: bool = True) -> date | None:
+ s = str(raw or "").strip()
+ if not s:
+ if required:
+ raise ValueError(f"{label}을(를) 입력하세요.")
+ return None
+ try:
+ return date.fromisoformat(s)
+ except ValueError:
+ raise ValueError(f"{label} 형식이 올바르지 않습니다(YYYY-MM-DD).") from None
+
+
+def validate_order(*, factory_id: Any, order_date: Any, due_date: Any, memo: Any,
+ codes: list[str], quantities: list[str], line_memos: list[str] | None = None) -> dict[str, Any]:
+ """발주서 폼 → 정리된 값. 빈 줄(코드·수량 둘 다 없음)은 건너뛴다. 같은 제품 두 줄은 오류."""
+ errors: list[str] = []
+ try:
+ fid = int(str(factory_id or "").strip())
+ except ValueError:
+ fid = 0
+ if fid <= 0:
+ errors.append("공장을 고르세요.")
+ od = dd = None
+ try:
+ od = parse_date(order_date, label="발주일")
+ except ValueError as exc:
+ errors.append(str(exc))
+ try:
+ dd = parse_date(due_date, label="입고 예정일", required=False)
+ except ValueError as exc:
+ errors.append(str(exc))
+ if od and dd and dd < od:
+ errors.append("입고 예정일이 발주일보다 빠릅니다.")
+ line_memos = line_memos or []
+ lines: list[dict[str, Any]] = []
+ seen: set[str] = set()
+ for i, code in enumerate(codes):
+ code = (code or "").strip().upper()
+ raw_qty = quantities[i] if i < len(quantities) else ""
+ if not code and not str(raw_qty or "").strip():
+ continue
+ if not code:
+ errors.append(f"{i + 1}번째 줄: 제품을 고르세요.")
+ continue
+ if code in seen:
+ errors.append(f"{code}: 같은 제품이 두 줄에 있습니다 — 한 줄로 합쳐 주세요.")
+ continue
+ seen.add(code)
+ try:
+ qty = parse_qty(raw_qty, label=f"{code} 발주 수량")
+ except ValueError as exc:
+ errors.append(str(exc))
+ continue
+ lines.append({"item_code": code, "qty": qty,
+ "memo": str(line_memos[i] if i < len(line_memos) else "").strip()[:MEMO_MAX]})
+ if not lines and not any("줄" in e or "수량" in e for e in errors):
+ errors.append("발주할 제품을 한 줄 이상 넣으세요.")
+ if len(lines) > MAX_LINES:
+ errors.append(f"한 발주서에 {MAX_LINES}개 제품까지 넣을 수 있습니다.")
+ if errors:
+ raise ValueError("\n".join(errors))
+ return {"factory_id": fid, "order_date": od, "due_date": dd, "memo": str(memo or "").strip()[:MEMO_MAX], "lines": lines}
+
+
+def validate_receipt(order_lines: list[dict[str, Any]], quantities: dict[int, Any], *,
+ receipt_date: Any, memo: Any) -> dict[str, Any]:
+ """입고 입력 — quantities: {발주 줄 id: 입력값}. 빈칸·0 은 이번에 안 들어온 것.
+ over = 이번 입고로 발주를 넘는 품목(확인 받은 뒤 저장). order_lines 는 지금까지 누적 입고(received)를 포함."""
+ errors: list[str] = []
+ try:
+ rd = parse_date(receipt_date, label="입고일")
+ except ValueError as exc:
+ errors.append(str(exc))
+ rd = None
+ by_id = {int(x["id"]): x for x in order_lines}
+ items: list[dict[str, Any]] = []
+ over: list[dict[str, Any]] = []
+ for lid, raw in quantities.items():
+ line = by_id.get(int(lid))
+ if line is None:
+ errors.append("이 발주서에 없는 품목이 들어 있습니다.")
+ continue
+ try:
+ qty = parse_qty(raw, label=f"{line['item_code']} 입고 수량", allow_zero=True)
+ except ValueError as exc:
+ errors.append(str(exc))
+ continue
+ if qty == 0:
+ continue
+ items.append({"order_line_id": int(lid), "qty": qty})
+ after = int(line.get("received") or 0) + qty
+ if after > int(line["qty"]):
+ over.append({"item_code": line["item_code"], "item_name": line.get("item_name", ""),
+ "ordered": int(line["qty"]), "after": after, "over": after - int(line["qty"])})
+ if not items and not errors:
+ errors.append("입고 수량을 한 품목 이상 넣으세요.")
+ if errors:
+ raise ValueError("\n".join(errors))
+ return {"receipt_date": rd, "memo": str(memo or "").strip()[:MEMO_MAX], "items": items, "over": over}
+
+
+def order_no(order_date: date, seq: int) -> str:
+ """PO-YYMMDD-NN — 발주일 기준 그날 순번(01부터)."""
+ return f"PO-{order_date:%y%m%d}-{seq:02d}"
diff --git a/app/modules/inout/templates/inout/_macros.html b/app/modules/inout/templates/inout/_macros.html
new file mode 100644
index 0000000..5af00c6
--- /dev/null
+++ b/app/modules/inout/templates/inout/_macros.html
@@ -0,0 +1,18 @@
+{# 상태 배지 — 발주서(open·partial·done·over·closed·cancelled) / 품목(none·partial·done·over) #}
+{% macro status_badge(status, label) -%}
+{{ label }}
+{%- endmacro %}
+
+{# 진행률 막대 — 입고 ÷ 발주 #}
+{% macro progress(summary) -%}
+
+
+{{ summary.pct }}%
+{%- endmacro %}
+
+{# 입고 예정일 — 지났는데 남은 게 있으면 빨강 "지연 N일" #}
+{% macro due(due_date, today, active) -%}
+{% if due_date %}{{ due_date.strftime('%Y-%m-%d') }}{% if active and due_date < today %} 지연 {{ (today - due_date).days }}일{% elif active %} D-{{ (due_date - today).days }}{% endif %}{% else %}-{% endif %}
+{%- endmacro %}
+
+{% macro n(v) -%}{{ '{:,}'.format(v or 0) }}{%- endmacro %}
diff --git a/app/modules/inout/templates/inout/_nav.html b/app/modules/inout/templates/inout/_nav.html
new file mode 100644
index 0000000..ed4f7a3
--- /dev/null
+++ b/app/modules/inout/templates/inout/_nav.html
@@ -0,0 +1,14 @@
+{# 입출고 관리 공용 상단: 탭(발주 목록·미입고 현황·옵션) + 새 발주서 + 알림 문구(?msg=) #}
+
+ 발주 목록
+ 미입고 현황
+ {% if perms.admin %}옵션{% endif %}
+
+
+ {% if perms.can_order %}발주 담당{% endif %}
+ {% if perms.can_receive %}입고 담당{% endif %}
+ {% if not perms.can_order and not perms.can_receive %}조회만 가능 — 담당 지정은 옵션(관리자){% endif %}
+
+ {% if perms.can_order %}+ 새 발주서{% endif %}
+