feat(inout): 입출고 관리 모듈 — 공장 제작 발주 · 물류 입고 · 미입고/초과 관리

- 새 모듈 app/modules/inout(/inout/, 권한키 inout) + 새 DB inout_db(사용자 승인, scripts/sql/inout_db_init.sql — 멱등).
- 발주 담당이 공장에 발주서(PO-YYMMDD-NN, 제품 = itemcode_db 단품만 — 검색 + 저장 때 서버 재확인),
  입고 담당이 물류에 들어온 수량을 여러 번 나눠 입력 → 품목별 발주·입고·미입고, 진행률, 입고 예정일 지연.
- 미입고 현황: 제품별 합계 · 발주별(예정일 순) · 초과 입고. 잔량 종결/풀기, 입고 없는 발주 취소, 입고 기록 지우기.
- 초과 입고: 확인 화면(409, 입력 유지) 후 [초과 입고로 저장] — 트랜잭션 안에서 발주서 잠그고 판단, Enter 는 일반 저장.
- 옵션(ERP 관리자): 공장 목록, 발주 담당·입고 담당 지정(inout_roles). 관리자는 둘 다.
- 상태는 저장하지 않고 누적 입고로 계산(store.order_status). 이카운트 "발주 대비 미입고"·Odoo 분할 입고/종결 참고.
- 테스트: 순수 로직, 실제 PostgreSQL(앱 계정 inout_app — 권한 포함), 실제 앱 화면 흐름(권한별). 문서 INOUT_MODULE.md 등.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-10-16 15:21:05 +09:00
parent 80b7becd45
commit 6f3bffd840
26 changed files with 2712 additions and 0 deletions
+20
View File
@@ -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": '<path d="M3 7l9-4 9 4v10l-9 4-9-4z"/><path d="M3 7l9 4 9-4"/><path d="M12 11v10"/>',
"asset": '<rect x="3" y="3" width="18" height="13" rx="2"/><path d="M8 21h8M12 16v5"/><path d="M7 7h10M7 11h6"/>',
"home": '<path d="M3 11 12 3l9 8"/><path d="M5 10v10h14V10"/>',
"expense": '<rect x="3" y="6" width="18" height="13" rx="2"/><path d="M3 10h18"/><path d="M7 15h4"/>',
+32
View File
@@ -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()
+336
View File
@@ -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("사용하지 않는 공장입니다(옵션에서 '사용'으로 바꾸세요).")
+82
View File
@@ -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()
+507
View File
@@ -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"}
+204
View File
@@ -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}"
@@ -0,0 +1,18 @@
{# 상태 배지 — 발주서(open·partial·done·over·closed·cancelled) / 품목(none·partial·done·over) #}
{% macro status_badge(status, label) -%}
<span class="io-badge io-st-{{ status }}">{{ label }}</span>
{%- endmacro %}
{# 진행률 막대 — 입고 ÷ 발주 #}
{% macro progress(summary) -%}
<span class="io-progress" title="입고 {{ '{:,}'.format(summary.received) }} / 발주 {{ '{:,}'.format(summary.ordered) }}">
<span class="io-progress-bar{% if summary.over %} is-over{% endif %}" style="width:{{ summary.pct }}%"></span>
</span><span class="io-progress-pct">{{ summary.pct }}%</span>
{%- endmacro %}
{# 입고 예정일 — 지났는데 남은 게 있으면 빨강 "지연 N일" #}
{% macro due(due_date, today, active) -%}
{% if due_date %}{{ due_date.strftime('%Y-%m-%d') }}{% if active and due_date < today %} <span class="io-late">지연 {{ (today - due_date).days }}일</span>{% elif active %} <span class="erp-muted">D-{{ (due_date - today).days }}</span>{% endif %}{% else %}<span class="erp-muted">-</span>{% endif %}
{%- endmacro %}
{% macro n(v) -%}{{ '{:,}'.format(v or 0) }}{%- endmacro %}
@@ -0,0 +1,14 @@
{# 입출고 관리 공용 상단: 탭(발주 목록·미입고 현황·옵션) + 새 발주서 + 알림 문구(?msg=) #}
<div class="io-nav">
<a class="erp-btn {% if tab == 'orders' %}erp-btn-primary{% else %}erp-btn-outline{% endif %}" href="/inout/">발주 목록</a>
<a class="erp-btn {% if tab == 'pending' %}erp-btn-primary{% else %}erp-btn-outline{% endif %}" href="/inout/pending">미입고 현황</a>
{% if perms.admin %}<a class="erp-btn {% if tab == 'settings' %}erp-btn-primary{% else %}erp-btn-outline{% endif %}" href="/inout/settings">옵션</a>{% endif %}
<span class="io-nav-gap"></span>
<span class="io-roles erp-muted">
{% if perms.can_order %}<span class="erp-badge erp-badge-neutral">발주 담당</span>{% endif %}
{% if perms.can_receive %}<span class="erp-badge erp-badge-neutral">입고 담당</span>{% endif %}
{% if not perms.can_order and not perms.can_receive %}조회만 가능 — 담당 지정은 옵션(관리자){% endif %}
</span>
{% if perms.can_order %}<a class="erp-btn erp-btn-primary" href="/inout/orders/new">+ 새 발주서</a>{% endif %}
</div>
{% if msg %}<p class="io-flash" role="status">{{ msg }}</p>{% endif %}
@@ -0,0 +1,61 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import status_badge, progress, due, n %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261016a" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="io-filter" method="get" action="/inout/">
{# 상태 = 링크(다른 거르기 값 유지). 검색 칸 Enter 는 아래 [찾기] — 상태는 숨은 칸 값 그대로 #}
{% set keep = {'factory': filters.factory or '', 'q': filters.q, 'from': filters['from'], 'to': filters['to']} %}
<div class="io-seg" role="group" aria-label="상태">
{% for key, f in status_filters.items() %}
<a href="/inout/?{{ dict(keep, status=key) | urlencode }}" class="io-seg-btn{% if filters.status == key %} is-active{% endif %}"
{% if filters.status == key %}aria-current="true"{% endif %}>{{ f[0] }}</a>
{% endfor %}
</div>
<input type="hidden" name="status" value="{{ filters.status }}" />
<select class="erp-select" name="factory" aria-label="공장" onchange="this.form.submit()">
<option value="">전체 공장</option>
{% for f in factories %}<option value="{{ f.id }}" {% if filters.factory == f.id %}selected{% endif %}>{{ f.name }}{% if not f.is_active %} (사용 안 함){% endif %}</option>{% endfor %}
</select>
<label class="io-date">발주일 <input class="erp-input" type="date" name="from" value="{{ filters['from'] }}" /></label>
<span class="erp-muted">~</span>
<input class="erp-input" type="date" name="to" value="{{ filters['to'] }}" aria-label="발주일 끝" />
<input class="erp-input io-search" type="search" name="q" value="{{ filters.q }}" placeholder="발주번호·제품 코드·제품 이름" />
<button type="submit" class="erp-btn erp-btn-outline">찾기</button>
</form>
<div class="erp-card-block">
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr>
<th>발주번호</th><th>공장</th><th>제품</th><th>발주일</th><th>입고 예정일</th>
<th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">미입고</th><th>진행</th><th>상태</th>
</tr></thead>
<tbody>
{% for o in orders %}
{% set active = o.status in ('open', 'partial') %}
<tr class="io-row-link" data-href="/inout/orders/{{ o.id }}">
<td><a href="/inout/orders/{{ o.id }}" class="io-order-no">{{ o.order_no }}</a></td>
<td>{{ o.factory_name }}</td>
<td class="io-items">{{ o.items_label }}<div class="erp-row-sub">{{ o.line_count }}종</div></td>
<td>{{ o.order_date.strftime('%Y-%m-%d') }}</td>
<td>{{ due(o.due_date, today, active) }}</td>
<td class="io-num">{{ n(o.summary.ordered) }}</td>
<td class="io-num">{{ n(o.summary.received) }}</td>
<td class="io-num{% if o.summary.remaining and active %} io-remaining{% endif %}">{{ n(o.summary.remaining) }}{% if o.summary.over %}<div class="io-over-sub">초과 +{{ n(o.summary.over) }}</div>{% endif %}</td>
<td class="io-progress-cell">{{ progress(o.summary) }}</td>
<td>{{ status_badge(o.status, o.status_label) }}</td>
</tr>
{% else %}
<tr><td colspan="10" class="erp-empty">{% if filters.status == 'active' %}진행 중인 발주가 없습니다.{% else %}조건에 맞는 발주가 없습니다.{% endif %}</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261016a" defer></script>{% endblock %}
@@ -0,0 +1,133 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import status_badge, progress, due, n %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261016a" />{% endblock %}
{% block content %}
{% set active = order.status in ('open', 'partial') %}
{% set receiving = perms.can_receive and can_receive_now %}
<section class="io">
{% include "inout/_nav.html" %}
<div class="erp-card-block io-head">
<div class="io-head-main">
<div class="io-head-title">
<h2>{{ order.order_no }}</h2>{{ status_badge(order.status, order.status_label) }}
</div>
<dl class="io-head-meta">
<div><dt>공장</dt><dd>{{ order.factory_name }}</dd></div>
<div><dt>발주일</dt><dd>{{ order.order_date.strftime('%Y-%m-%d') }}</dd></div>
<div><dt>입고 예정일</dt><dd>{{ due(order.due_date, today, active) }}</dd></div>
<div><dt>진행</dt><dd>{{ progress(order.summary) }}</dd></div>
{% if order.memo %}<div class="io-wide"><dt>메모</dt><dd>{{ order.memo }}</dd></div>{% endif %}
{% if order.closed_at %}<div class="io-wide"><dt>종결</dt><dd>{{ order.closed_at.strftime('%Y-%m-%d') }} · {{ order.closed_by }}{% if order.close_reason %} — {{ order.close_reason }}{% endif %}</dd></div>{% endif %}
{% if order.cancelled_at %}<div class="io-wide"><dt>취소</dt><dd>{{ order.cancelled_at.strftime('%Y-%m-%d') }} · {{ order.cancelled_by }}</dd></div>{% endif %}
</dl>
</div>
<div class="io-kpis io-kpis-head">
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">발주</div><div class="erp-summary-value">{{ n(order.summary.ordered) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">입고</div><div class="erp-summary-value">{{ n(order.summary.received) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini{% if order.summary.remaining and active %} io-kpi-remaining{% endif %}"><div class="erp-summary-label">미입고</div><div class="erp-summary-value">{{ n(order.summary.remaining) }}</div></div>
{% if order.summary.over %}<div class="erp-summary-card erp-summary-card--mini io-kpi-over"><div class="erp-summary-label">초과</div><div class="erp-summary-value">+{{ n(order.summary.over) }}</div></div>{% endif %}
</div>
{% if perms.can_order and not order.cancelled_at %}
<div class="io-head-actions">
<a class="erp-btn erp-btn-outline erp-btn-sm" href="/inout/orders/{{ order.id }}/edit">발주서 고치기</a>
{% if order.closed_at %}
<form method="post" action="/inout/orders/{{ order.id }}/reopen"><button class="erp-btn erp-btn-outline erp-btn-sm" type="submit">종결 풀기</button></form>
{% elif order.summary.remaining %}
<form method="post" action="/inout/orders/{{ order.id }}/close" class="io-close-form" data-erp-confirm="남은 미입고 {{ n(order.summary.remaining) }}개를 더 기다리지 않고 종결할까요? 미입고 현황에서 빠집니다.">
<input class="erp-input io-close-reason" type="text" name="reason" maxlength="500" placeholder="종결 사유(선택)" />
<button class="erp-btn erp-btn-outline erp-btn-sm" type="submit">잔량 종결</button>
</form>
{% endif %}
{% if not order.receipts %}
<form method="post" action="/inout/orders/{{ order.id }}/cancel" data-erp-confirm="이 발주서를 취소할까요? (입고 기록이 없을 때만)">
<button class="erp-btn erp-btn-danger erp-btn-sm" type="submit">발주 취소</button>
</form>
{% endif %}
</div>
{% endif %}
</div>
{% if error %}<div class="io-error" role="alert">{% for line in error.split('\n') %}<div>{{ line }}</div>{% endfor %}</div>{% endif %}
<form method="post" action="/inout/orders/{{ order.id }}/receipts" class="erp-card-block io-block" id="io-receipt-form">
{# Enter 키 = 이 버튼(일반 저장). 없으면 폼의 첫 제출 버튼인 [초과 입고로 저장]이 눌려 확인 없이 초과가 저장된다 #}
{% if receiving %}<button type="submit" class="io-default-submit" tabindex="-1" aria-hidden="true">입고 저장</button>{% endif %}
<div class="erp-card-block-head">
<h2>품목</h2>
{% if receiving %}<span class="erp-muted">물류에 들어온 수량을 [이번 입고]에 넣고 저장 — 여러 번 나눠 넣어도 됩니다</span>
{% elif perms.can_receive and order.closed_at %}<span class="erp-muted">종결된 발주서 — 입고하려면 발주 담당이 종결을 풀어야 합니다</span>{% endif %}
</div>
{% if over %}
<div class="io-over-box" role="alert">
<b>발주보다 많이 입고하려고 합니다.</b> 맞으면 [초과 입고로 저장]을 누르세요.
<ul>{% for o in over %}<li><span class="io-code">{{ o.item_code }}</span> {{ o.item_name }} — 발주 {{ n(o.ordered) }}개, 입고 후 {{ n(o.after) }}개 (<b>+{{ n(o.over) }}</b>)</li>{% endfor %}</ul>
<button type="submit" class="erp-btn erp-btn-danger" name="confirm_over" value="1">초과 입고로 저장</button>
<span class="erp-muted">숫자를 고치려면 아래 칸을 고친 뒤 [입고 저장]</span>
</div>
{% endif %}
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th class="io-col-no">#</th><th>제품 코드</th><th>제품</th><th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">미입고</th><th>상태</th>
{% if receiving %}<th class="io-col-recv">이번 입고</th>{% endif %}</tr></thead>
<tbody>
{% for ln in order.lines %}
<tr>
<td class="io-col-no">{{ loop.index }}</td>
<td class="io-code">{{ ln.item_code }}</td>
<td>{{ ln.item_name }}{% if ln.memo %}<div class="erp-row-sub">{{ ln.memo }}</div>{% endif %}</td>
<td class="io-num">{{ n(ln.qty) }}</td>
<td class="io-num">{{ n(ln.received) }}</td>
<td class="io-num{% if ln.remaining and active %} io-remaining{% endif %}">{{ n(ln.remaining) }}{% if ln.over %}<div class="io-over-sub">초과 +{{ n(ln.over) }}</div>{% endif %}</td>
<td>{{ status_badge(ln.status, ln.status_label) }}</td>
{% if receiving %}<td class="io-col-recv"><input class="erp-input io-qty io-recv" type="text" inputmode="numeric" name="qty_{{ ln.id }}"
value="{{ receipt_form.qty.get(ln.id, '') }}" data-remaining="{{ ln.remaining }}" placeholder="{{ ln.remaining if ln.remaining else '' }}"
aria-label="{{ ln.item_code }} 이번 입고 수량" /></td>{% endif %}
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% if receiving %}
<div class="io-receipt-bar">
<label class="erp-field"><span>입고일 *</span><input type="date" name="receipt_date" value="{{ receipt_form.receipt_date }}" required /></label>
<label class="erp-field io-grow"><span>메모</span><input type="text" name="memo" value="{{ receipt_form.memo }}" maxlength="500" placeholder="차량·박스 수·검수 메모 등" /></label>
<button type="button" class="erp-btn erp-btn-outline" id="io-fill-remaining">남은 수량 모두 채우기</button>
<button type="submit" class="erp-btn erp-btn-primary">입고 저장 <span id="io-recv-total"></span></button>
</div>
{% endif %}
</form>
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>입고 기록</h2><span class="erp-muted">{{ order.receipts|length }}회</span></div>
{% if order.receipts %}
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>입고일</th><th>품목별 수량</th><th class="io-num">합계</th><th>입력</th>{% if perms.can_receive and not order.cancelled_at %}<th></th>{% endif %}</tr></thead>
<tbody>
{% for r in order.receipts %}
<tr>
<td>{{ r.receipt_date.strftime('%Y-%m-%d') }}{% if r.memo %}<div class="erp-row-sub">{{ r.memo }}</div>{% endif %}</td>
<td>{% for x in r.lines %}<span class="io-chip"><span class="io-code">{{ x.item_code }}</span> {{ n(x.qty) }}</span>{% endfor %}</td>
<td class="io-num">{{ n(r.total) }}</td>
<td class="erp-muted">{{ r.created_by }}<div class="erp-row-sub">{{ r.created_at.strftime('%Y-%m-%d %H:%M') }}</div></td>
{% if perms.can_receive and not order.cancelled_at %}
<td><form method="post" action="/inout/orders/{{ order.id }}/receipts/{{ r.id }}/delete"
data-erp-confirm="{{ r.receipt_date.strftime('%Y-%m-%d') }} 입고 {{ n(r.total) }}개 기록을 지울까요? 그만큼 다시 미입고가 됩니다.">
<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm">지우기</button></form></td>
{% endif %}
</tr>
{% endfor %}
</tbody>
</table>
</div>
{% else %}
<p class="erp-empty">아직 입고된 것이 없습니다.</p>
{% endif %}
</div>
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261016a" defer></script>{% endblock %}
@@ -0,0 +1,79 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261016a" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="erp-card-block io-order-form" method="post" id="io-order-form"
action="{% if order %}/inout/orders/{{ order.id }}/edit{% else %}/inout/orders/new{% endif %}">
<div class="erp-card-block-head">
<h2>{% if order %}발주서 고치기 · {{ order.order_no }}{% else %}새 발주서{% endif %}</h2>
<span class="erp-muted">제품은 코드표의 단품에서 고릅니다</span>
</div>
{% if error %}<div class="io-error" role="alert">{% for line in error.split('\n') %}<div>{{ line }}</div>{% endfor %}</div>{% endif %}
{% if not items_enabled %}<div class="io-error" role="alert">코드표 DB(ITEMCODE_DB_URL)가 연결되지 않아 제품을 검색할 수 없습니다 — 관리자에게 알려 주세요.</div>{% endif %}
<div class="erp-form-grid">
<label class="erp-field"><span>공장 *</span>
<select name="factory_id" required>
<option value="">공장 고르기</option>
{% for f in factories %}<option value="{{ f.id }}" {% if vals.factory_id|string == f.id|string %}selected{% endif %}>{{ f.name }}</option>{% endfor %}
</select>
{% if not factories %}<span class="io-hint">공장이 없습니다 — 관리자가 옵션에서 먼저 공장을 추가해야 합니다.</span>{% endif %}
</label>
<label class="erp-field"><span>발주일 *</span><input type="date" name="order_date" value="{{ vals.order_date }}" required /></label>
<label class="erp-field"><span>입고 예정일</span><input type="date" name="due_date" value="{{ vals.due_date }}" /></label>
<label class="erp-field"><span>메모</span><input type="text" name="memo" value="{{ vals.memo }}" maxlength="500" placeholder="공장 전달 사항 등" /></label>
</div>
<div class="erp-table-wrap">
<table class="erp-table io-table io-lines" id="io-lines">
<thead><tr><th class="io-col-no">#</th><th>제품(코드·이름으로 검색)</th><th class="io-col-qty">발주 수량</th><th>줄 메모</th><th class="io-col-del"></th></tr></thead>
<tbody>
{% for ln in lines %}
{% set received = (order.lines | selectattr('item_code', 'equalto', ln.code) | map(attribute='received') | first) if order else 0 %}
<tr class="io-line">
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="{{ ln.code }}" />
<input type="hidden" name="item_name" value="{{ ln.name }}" />
<input class="erp-input io-item-search" type="text" value="{{ ln.code }}{% if ln.name %} · {{ ln.name }}{% endif %}" autocomplete="off"
placeholder="코드 또는 이름" {% if received %}readonly title="입고된 제품은 바꿀 수 없습니다(수량은 바꿀 수 있음)"{% endif %} />
{% if received %}<div class="erp-row-sub">입고 {{ '{:,}'.format(received) }}개 — 제품은 그대로, 수량만 바꿀 수 있습니다</div>{% endif %}
</td>
<td class="io-col-qty"><input class="erp-input io-qty" type="text" inputmode="numeric" name="qty" value="{{ ln.qty }}" placeholder="0" /></td>
<td><input class="erp-input" type="text" name="line_memo" value="{{ ln.memo }}" maxlength="500" /></td>
<td class="io-col-del">{% if not received %}<button type="button" class="erp-btn erp-btn-outline erp-btn-sm io-del" aria-label="이 줄 지우기" title="이 줄 지우기">✕</button>{% endif %}</td>
</tr>
{% endfor %}
</tbody>
<tfoot><tr><td colspan="5">
<button type="button" class="erp-btn erp-btn-outline erp-btn-sm" id="io-add-line">+ 제품 줄 추가</button>
<span class="erp-muted io-total">합계 <b id="io-total-qty">0</b>개 · <b id="io-total-lines">0</b>종</span>
</td></tr></tfoot>
</table>
</div>
<template id="io-line-tpl">
<tr class="io-line">
<td class="io-col-no"></td>
<td class="io-item-cell">
<input type="hidden" name="item_code" value="" />
<input type="hidden" name="item_name" value="" />
<input class="erp-input io-item-search" type="text" value="" autocomplete="off" placeholder="코드 또는 이름" />
</td>
<td class="io-col-qty"><input class="erp-input io-qty" type="text" inputmode="numeric" name="qty" value="" placeholder="0" /></td>
<td><input class="erp-input" type="text" name="line_memo" value="" maxlength="500" /></td>
<td class="io-col-del"><button type="button" class="erp-btn erp-btn-outline erp-btn-sm io-del" aria-label="이 줄 지우기" title="이 줄 지우기">✕</button></td>
</tr>
</template>
<div class="io-form-actions">
<a class="erp-btn erp-btn-outline" href="{% if order %}/inout/orders/{{ order.id }}{% else %}/inout/{% endif %}">취소</a>
<button type="submit" class="erp-btn erp-btn-primary">{% if order %}고친 내용 저장{% else %}발주서 저장{% endif %}</button>
</div>
</form>
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261016a" defer></script>{% endblock %}
@@ -0,0 +1,91 @@
{% extends "erp_base.html" %}
{% from "inout/_macros.html" import due, n %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261016a" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<form class="io-filter" method="get" action="/inout/pending">
<select class="erp-select" name="factory" aria-label="공장" onchange="this.form.submit()">
<option value="">전체 공장</option>
{% for f in factories %}<option value="{{ f.id }}" {% if filters.factory == f.id %}selected{% endif %}>{{ f.name }}{% if not f.is_active %} (사용 안 함){% endif %}</option>{% endfor %}
</select>
<input class="erp-input io-search" type="search" name="q" value="{{ filters.q }}" placeholder="제품 코드·제품 이름·발주번호" />
<button type="submit" class="erp-btn erp-btn-outline">찾기</button>
<span class="io-nav-gap"></span>
<span class="erp-muted">진행 중인 발주(종결·취소 제외)의 남은 수량</span>
</form>
<div class="io-kpis">
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 수량</div><div class="erp-summary-value">{{ n(total_remaining) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 제품</div><div class="erp-summary-value">{{ n(items|length) }}종</div></div>
<div class="erp-summary-card erp-summary-card--mini"><div class="erp-summary-label">미입고 발주 줄</div><div class="erp-summary-value">{{ n(rows|length) }}</div></div>
<div class="erp-summary-card erp-summary-card--mini{% if over %} io-kpi-over{% endif %}"><div class="erp-summary-label">초과 입고</div><div class="erp-summary-value">{{ n(over|length) }}건</div></div>
</div>
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>제품별 미입고 합계</h2><span class="erp-muted">여러 발주에 걸친 남은 수량을 제품마다 더한 값</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>제품 코드</th><th>제품</th><th class="io-num">미입고</th><th class="io-num">발주 건수</th><th>가장 이른 입고 예정일</th></tr></thead>
<tbody>
{% for it in items %}
<tr>
<td class="io-code">{{ it.item_code }}</td><td>{{ it.item_name }}</td>
<td class="io-num io-remaining">{{ n(it.remaining) }}</td><td class="io-num">{{ it.orders }}</td>
<td>{{ due(it.earliest_due, today, True) }}</td>
</tr>
{% else %}
<tr><td colspan="5" class="erp-empty">미입고된 제품이 없습니다. 모두 들어왔습니다.</td></tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% if rows %}
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>발주별 미입고</h2><span class="erp-muted">입고 예정일이 이른 순 — 지난 것은 빨강</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>입고 예정일</th><th>발주번호</th><th>공장</th><th>제품 코드</th><th>제품</th>
<th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">미입고</th></tr></thead>
<tbody>
{% for r in rows %}
<tr class="io-row-link{% if r.due_date and r.due_date < today %} is-late{% endif %}" data-href="/inout/orders/{{ r.order_id }}">
<td>{{ due(r.due_date, today, True) }}</td>
<td><a href="/inout/orders/{{ r.order_id }}" class="io-order-no">{{ r.order_no }}</a><div class="erp-row-sub">발주 {{ r.order_date.strftime('%Y-%m-%d') }}</div></td>
<td>{{ r.factory_name }}</td><td class="io-code">{{ r.item_code }}</td><td>{{ r.item_name }}</td>
<td class="io-num">{{ n(r.qty) }}</td><td class="io-num">{{ n(r.received) }}</td>
<td class="io-num io-remaining">{{ n(r.remaining) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endif %}
{% if over %}
<div class="erp-card-block io-block io-block-over">
<div class="erp-card-block-head"><h2>초과 입고</h2><span class="erp-muted">발주보다 많이 들어온 제품 — 공장과 확인이 필요합니다</span></div>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>발주번호</th><th>공장</th><th>제품 코드</th><th>제품</th><th class="io-num">발주</th><th class="io-num">입고</th><th class="io-num">초과</th></tr></thead>
<tbody>
{% for r in over %}
<tr class="io-row-link" data-href="/inout/orders/{{ r.order_id }}">
<td><a href="/inout/orders/{{ r.order_id }}" class="io-order-no">{{ r.order_no }}</a></td><td>{{ r.factory_name }}</td>
<td class="io-code">{{ r.item_code }}</td><td>{{ r.item_name }}</td>
<td class="io-num">{{ n(r.qty) }}</td><td class="io-num">{{ n(r.received) }}</td><td class="io-num io-over">+{{ n(r.over) }}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
{% endif %}
</section>
{% endblock %}
{% block scripts %}<script src="/static/inout.js?v=20261016a" defer></script>{% endblock %}
@@ -0,0 +1,74 @@
{% extends "erp_base.html" %}
{% block head_extra %}<link rel="stylesheet" href="/static/inout.css?v=20261016a" />{% endblock %}
{% block content %}
<section class="io">
{% include "inout/_nav.html" %}
<div class="io-settings">
<form method="post" action="/inout/settings/roles" class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>담당자</h2><span class="erp-muted">ERP 관리자는 지정 없이도 둘 다 할 수 있습니다</span></div>
<p class="io-help">
<b>발주 담당</b> — 발주서 작성·고치기·잔량 종결·취소. <b>입고 담당</b> — 물류에 들어온 입고 수량 입력·지우기.
그 밖의 사람은 조회만 합니다. 후보 = ERP 관리자 화면에서 <b>입출고 관리</b> 권한을 받은 사용자.
</p>
<div class="erp-table-wrap">
<table class="erp-table io-table">
<thead><tr><th>사용자</th>{% for role, label in role_labels.items() %}<th class="io-col-check">{{ label }}</th>{% endfor %}</tr></thead>
<tbody>
{% for c in candidates %}
<tr>
<td>{{ c.name or c.email }}<div class="erp-row-sub">{{ c.email }}</div></td>
{% for role in role_labels %}
<td class="io-col-check"><input type="checkbox" name="{{ role }}_email" value="{{ c.email }}" {% if c.email in roles[role] %}checked{% endif %}
aria-label="{{ c.email }} {{ role_labels[role] }}" /></td>
{% endfor %}
</tr>
{% else %}
<tr><td colspan="3" class="erp-empty">입출고 관리 권한을 받은 사용자가 없습니다 — ERP 관리자 화면에서 먼저 권한을 주세요.</td></tr>
{% endfor %}
</tbody>
</table>
</div>
<div class="io-form-actions"><button type="submit" class="erp-btn erp-btn-primary">담당자 저장</button></div>
</form>
<div class="erp-card-block io-block">
<div class="erp-card-block-head"><h2>공장(발주처)</h2><span class="erp-muted">발주 기록이 있는 공장은 지우지 말고 '사용 안 함'으로</span></div>
{# 줄마다 폼 하나(표 안에 폼을 넣을 수 없어 격자로) — 머리 줄과 같은 열 #}
<div class="io-factories" role="table" aria-label="공장 목록">
<div class="io-factory-row io-factory-head" role="row">
<span>이름</span><span>담당자·연락처</span><span>메모</span><span>순서</span><span>사용</span><span>발주</span><span></span>
</div>
{% for f in factories %}
<form method="post" action="/inout/settings/factories" class="io-factory-row{% if not f.is_active %} io-inactive{% endif %}" role="row">
<input type="hidden" name="id" value="{{ f.id }}" />
<input class="erp-input" type="text" name="name" value="{{ f.name }}" maxlength="100" required aria-label="공장 이름" />
<input class="erp-input" type="text" name="contact" value="{{ f.contact }}" maxlength="200" aria-label="담당자·연락처" />
<input class="erp-input" type="text" name="memo" value="{{ f.memo }}" maxlength="500" aria-label="메모" />
<input class="erp-input" type="number" name="sort_order" value="{{ f.sort_order }}" aria-label="순서" />
<label class="io-check"><input type="checkbox" name="is_active" value="1" {% if f.is_active %}checked{% endif %} aria-label="사용" /></label>
<span class="erp-muted">{{ f.order_count }}건</span>
<span class="io-factory-btns">
<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm">저장</button>
{% if not f.order_count %}<button type="submit" class="erp-btn erp-btn-outline erp-btn-sm" formaction="/inout/settings/factories/{{ f.id }}/delete"
formnovalidate data-erp-confirm-btn="공장 '{{ f.name }}' 을(를) 지울까요?">지우기</button>{% endif %}
</span>
</form>
{% endfor %}
<form method="post" action="/inout/settings/factories" class="io-factory-row io-new-factory" role="row">
<input class="erp-input" type="text" name="name" maxlength="100" required placeholder="새 공장 이름" aria-label="새 공장 이름" />
<input class="erp-input" type="text" name="contact" maxlength="200" placeholder="담당자·연락처" aria-label="담당자·연락처" />
<input class="erp-input" type="text" name="memo" maxlength="500" placeholder="메모" aria-label="메모" />
<input class="erp-input" type="number" name="sort_order" value="0" aria-label="순서" />
<input type="hidden" name="is_active" value="1" />
<span></span><span></span>
<span class="io-factory-btns"><button type="submit" class="erp-btn erp-btn-primary erp-btn-sm">+ 공장 추가</button></span>
</form>
</div>
</div>
<p class="erp-muted io-foot">코드표(단품) 연결: {{ items_status }}</p>
</div>
</section>
{% endblock %}
+124
View File
@@ -0,0 +1,124 @@
/* 입출고 관리(inout) — ERP 공용(erp.css·erp-shell.css) 위에 이 화면만의 것 */
/* 공용 .erp-page 는 width:100% + 안쪽 여백(content-box)이라 표가 넓으면 48px 넘친다 — 이 화면에서만 테두리 기준으로 */
.erp-page:has(> .io) { box-sizing: border-box; }
.io { display: flex; flex-direction: column; gap: 14px; min-width: 0; } /* 넓은 표는 안에서 가로 스크롤(페이지가 화면보다 넓어지지 않게) */
.io-nav { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.io-nav-gap { flex: 1 1 auto; }
.io-roles { display: inline-flex; gap: 4px; align-items: center; }
.io-flash { margin: 0; padding: 10px 14px; border-radius: 8px; background: #eef6ff; color: #0b4a8b; font-size: 13px; border: 1px solid #cfe3fb; }
.io-error { margin: 12px 20px 0; padding: 10px 14px; border-radius: 8px; background: #fbe9e6; color: #a1261b; border: 1px solid #efc6bf; font-size: 13px; }
.io > .io-error { margin: 0; }
.io-hint { color: #a1261b; font-size: 12px; }
.io-help { margin: 0; padding: 12px 20px 0; font-size: 12.5px; color: var(--color-midtone-gray); line-height: 1.6; }
.io-foot { margin: 0; }
/* 거르기 줄 */
.io-filter { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }
.io-filter .erp-input, .io-filter .erp-select { width: auto; }
.io-search { min-width: 220px; }
.io-filter input[type="date"] { width: 150px; }
.io-date { display: inline-flex; align-items: center; gap: 6px; font-size: 12px; color: var(--color-midtone-gray); }
.io-seg { display: inline-flex; padding: 2px; border: 1px solid var(--color-subtle-ash); border-radius: 10px; background: #fff; }
.io-seg-btn { padding: 5px 12px; border-radius: 8px; font-size: 12.5px; color: var(--color-rich-black); text-decoration: none; white-space: nowrap; }
.io-seg-btn:hover { background: var(--color-ghost-gray); }
.io-seg-btn.is-active, .io-seg-btn.is-active:hover { background: var(--color-deep-black); color: #fff; }
/* 표 */
.io-table td, .io-table th { white-space: nowrap; }
.io-table td.io-items { white-space: normal; min-width: 160px; }
.io-num { text-align: right !important; font-variant-numeric: tabular-nums; }
.io-code { font-family: ui-monospace, Consolas, monospace; font-size: 12px; }
.io-order-no { font-weight: 600; color: var(--color-rich-black); text-decoration: none; font-family: ui-monospace, Consolas, monospace; }
.io-order-no:hover { text-decoration: underline; }
.io-row-link { cursor: pointer; }
.io-row-link.is-late td:first-child { box-shadow: inset 3px 0 0 #d93025; }
.io-remaining { color: #b45309; font-weight: 600; }
.io-over, .io-over-sub { color: #d93025; font-weight: 600; }
.io-over-sub { font-size: 11px; }
.io-late { color: #d93025; font-weight: 600; font-size: 12px; }
.io-block { overflow: visible; }
/* 상태 배지 */
.io-badge { display: inline-flex; align-items: center; padding: 2px 8px; border-radius: 999px; font-size: 11.5px; font-weight: 600; white-space: nowrap; border: 1px solid transparent; }
.io-st-open, .io-st-none { background: #eef0f2; color: #3d4148; }
.io-st-partial { background: #fff4e0; color: #9a5b00; border-color: #f6dcae; }
.io-st-done { background: #e6f8e9; color: #1e7a34; border-color: #c2efc8; }
.io-st-over { background: #fbe9e6; color: #b3261e; border-color: #efc6bf; }
.io-st-closed { background: #f4f4f5; color: #6b6f76; border-color: #dcdde0; }
.io-st-cancelled { background: #fff; color: #9aa0a6; border-color: #dcdde0; text-decoration: line-through; }
/* 진행률 */
.io-progress { display: inline-block; width: 80px; height: 6px; border-radius: 999px; background: #eceef1; overflow: hidden; vertical-align: middle; }
.io-progress-bar { display: block; height: 100%; background: #1e8e3e; border-radius: inherit; }
.io-progress-bar.is-over { background: #d93025; }
.io-progress-pct { margin-left: 6px; font-size: 12px; color: var(--color-midtone-gray); font-variant-numeric: tabular-nums; }
/* 요약 숫자 */
.io-kpis { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 10px; }
.io-kpi-remaining .erp-summary-value { color: #b45309; }
.io-kpi-over .erp-summary-value { color: #d93025; }
/* 발주서 머리 */
.io-head { padding: 16px 20px; display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 12px 20px; overflow: visible; }
.io-head-title { display: flex; align-items: center; gap: 10px; }
.io-head-title h2 { margin: 0; font-size: 18px; font-family: ui-monospace, Consolas, monospace; }
.io-head-meta { display: flex; flex-wrap: wrap; gap: 8px 24px; margin: 12px 0 0; }
.io-head-meta dt { font-size: 11.5px; color: var(--color-midtone-gray); }
.io-head-meta dd { margin: 2px 0 0; font-size: 13.5px; }
.io-head-meta .io-wide { flex-basis: 100%; }
.io-kpis-head { grid-template-columns: repeat(auto-fit, minmax(96px, 1fr)); align-self: start; min-width: 320px; }
.io-head-actions { grid-column: 1 / -1; display: flex; flex-wrap: wrap; gap: 8px; align-items: center; padding-top: 12px; border-top: 1px solid var(--color-subtle-ash); }
.io-head-actions form { display: inline-flex; gap: 6px; align-items: center; margin: 0; }
.io-close-reason { width: 200px; }
/* 입고 입력 */
.io-col-no { width: 36px; color: var(--color-midtone-gray); }
.io-col-recv { width: 130px; background: #f6fbf7; }
.io-table thead th.io-col-recv { background: #eaf6ee; color: #1e7a34; font-weight: 600; }
.io-qty { width: 110px; text-align: right; font-variant-numeric: tabular-nums; }
.io-receipt-bar { display: flex; align-items: flex-end; gap: 10px; flex-wrap: wrap; padding: 14px 20px; border-top: 1px solid var(--color-subtle-ash); background: #fafbfc; }
.io-receipt-bar .erp-field input { min-width: 150px; }
.io-grow { flex: 1 1 260px; }
.io-default-submit { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0 0 0 0); border: 0; }
.io-over-box { margin: 12px 20px 0; padding: 12px 16px; border-radius: 8px; background: #fbe9e6; border: 1px solid #efc6bf; color: #7a1d14; font-size: 13px; }
.io-over-box ul { margin: 6px 0 10px; padding-left: 18px; }
.io-chip { display: inline-block; margin: 2px 6px 2px 0; padding: 1px 8px; border-radius: 6px; background: var(--color-ghost-gray); font-size: 12px; white-space: nowrap; }
/* 발주서 폼 */
.io-order-form { overflow: visible; }
.io-lines .io-col-qty { width: 130px; }
.io-lines .io-col-del { width: 48px; text-align: center; }
.io-lines tfoot td { padding: 10px 16px; border-top: 1px solid var(--color-subtle-ash); }
.io-item-cell { position: relative; min-width: 320px; }
.io-item-search { width: 100%; }
.io-item-search.is-invalid { border-color: #d93025; box-shadow: 0 0 0 3px rgba(217, 48, 37, .12); }
.io-item-search[readonly] { background: var(--color-ghost-gray); }
.io-total { margin-left: 12px; }
.io-form-actions { display: flex; justify-content: flex-end; gap: 8px; padding: 14px 20px; border-top: 1px solid var(--color-subtle-ash); }
/* 검색 드롭다운 — 표 가로 스크롤 상자에 잘리지 않게 화면 기준(fixed), 위치는 inout.js 가 입력칸에 맞춤 */
.io-suggest { position: fixed; z-index: 1000; max-height: 280px; overflow-y: auto;
background: #fff; border: 1px solid var(--color-subtle-ash); border-radius: 8px; box-shadow: 0 8px 24px rgba(0, 0, 0, .12); }
.io-suggest-item { padding: 7px 12px; font-size: 13px; cursor: pointer; white-space: normal; }
.io-suggest-item:hover, .io-suggest-item.is-active { background: #eef6ff; }
.io-suggest-empty { padding: 10px 12px; font-size: 12.5px; color: var(--color-midtone-gray); white-space: normal; }
/* 옵션 */
.io-settings { display: flex; flex-direction: column; gap: 14px; }
.io-col-check { width: 90px; text-align: center !important; }
.io-factories { padding: 6px 12px 12px; }
.io-factory-row { display: grid; grid-template-columns: minmax(140px, 1.2fr) minmax(140px, 1.2fr) minmax(120px, 1.5fr) 70px 50px 60px auto;
gap: 8px; align-items: center; padding: 6px 8px; margin: 0; border-bottom: 1px solid var(--color-subtle-ash); }
.io-factory-head { font-size: 12px; color: var(--color-midtone-gray); font-weight: 500; }
.io-factory-row .erp-input { width: 100%; min-width: 0; }
.io-factory-row.io-inactive .erp-input { color: var(--color-midtone-gray); background: var(--color-ghost-gray); }
.io-new-factory { border-bottom: 0; background: #fafbfc; border-radius: 8px; }
.io-factory-btns { display: inline-flex; gap: 6px; justify-content: flex-end; }
.io-check { display: inline-flex; justify-content: center; }
@media (max-width: 900px) {
.io-kpis { grid-template-columns: repeat(2, minmax(0, 1fr)); }
.io-head { grid-template-columns: 1fr; }
.io-kpis-head { min-width: 0; }
.io-factory-row { grid-template-columns: 1fr 1fr; }
.io-factory-head { display: none; }
}
+227
View File
@@ -0,0 +1,227 @@
/* 입출고 관리(inout) 화면 스크립트 — 화면 전환·저장은 서버(폼)가 하고, 여기는 입력을 돕기만 한다.
· 목록 줄 누르기 = 발주서로
· 발주서 폼: 제품 줄 추가·지우기·번호·합계, 코드표 단품 검색(GET /inout/api/items?q=) 드롭다운
· 발주서 화면: [남은 수량 모두 채우기], 이번 입고 합계
· data-erp-confirm-btn: 버튼별 확인(formaction 이 있는 버튼 — 공용 data-erp-confirm 은 form.submit() 이라 누른 버튼이 사라짐) */
(function () {
"use strict";
function confirmMsg(msg) {
return window.erpConfirm ? window.erpConfirm(msg) : Promise.resolve(window.confirm(msg));
}
function alertMsg(msg) {
return window.erpAlert ? window.erpAlert(msg) : Promise.resolve(window.alert(msg));
}
function num(v) {
const n = parseInt(String(v || "").replace(/[,\s]/g, ""), 10);
return Number.isFinite(n) && n > 0 ? n : 0;
}
function fmt(n) { return n.toLocaleString("ko-KR"); }
// ── 목록 줄 누르기 → 발주서 ──
document.addEventListener("click", function (e) {
const row = e.target.closest(".io-row-link");
if (!row || e.target.closest("a, button, input, select, label")) return;
if (window.getSelection && String(window.getSelection())) return; // 글자 고르는 중
location.href = row.dataset.href;
});
// ── 버튼별 확인 ──
document.addEventListener("click", function (e) {
const btn = e.target.closest("[data-erp-confirm-btn]");
if (!btn || btn.dataset.confirmed === "1") return;
e.preventDefault();
confirmMsg(btn.dataset.erpConfirmBtn).then(function (ok) {
if (!ok) return;
btn.dataset.confirmed = "1";
if (btn.form.requestSubmit) btn.form.requestSubmit(btn); else btn.click();
});
});
// ── 발주서 폼 ──
const form = document.getElementById("io-order-form");
if (form) initOrderForm(form);
function initOrderForm(form) {
const body = form.querySelector("#io-lines tbody");
const tpl = document.getElementById("io-line-tpl");
const totalQty = document.getElementById("io-total-qty");
const totalLines = document.getElementById("io-total-lines");
function renumber() {
let q = 0, k = 0;
body.querySelectorAll(".io-line").forEach(function (tr, i) {
tr.querySelector(".io-col-no").textContent = String(i + 1);
const n = num(tr.querySelector(".io-qty").value);
if (tr.querySelector('input[name="item_code"]').value) { k++; q += n; }
});
totalQty.textContent = fmt(q);
totalLines.textContent = fmt(k);
}
function addLine(focus) {
const tr = tpl.content.firstElementChild.cloneNode(true);
body.appendChild(tr);
wireSearch(tr.querySelector(".io-item-search"));
renumber();
if (focus) tr.querySelector(".io-item-search").focus();
return tr;
}
form.querySelector("#io-add-line").addEventListener("click", function () { addLine(true); });
body.addEventListener("click", function (e) {
const del = e.target.closest(".io-del");
if (!del) return;
const tr = del.closest(".io-line");
const search = tr.querySelector(".io-item-search");
if (search && search._ioBox) search._ioBox.remove(); // body 에 붙은 드롭다운도 함께
tr.remove();
if (!body.querySelector(".io-line")) addLine(false);
renumber();
});
body.addEventListener("input", renumber); // 수량을 바꾸거나 제품 글을 고치면(고른 것 풀림) 다시 셈
body.addEventListener("io-chosen", renumber); // 검색 목록에서 제품을 고르면
body.querySelectorAll(".io-item-search").forEach(wireSearch);
if (!body.querySelector(".io-line")) { addLine(false); addLine(false); addLine(false); }
renumber();
form.addEventListener("submit", function (e) {
// 검색 글만 있고 목록에서 고르지 않은 줄, 같은 제품 두 줄 — 서버도 막지만 여기서 먼저 알려 준다
const codes = [];
let bad = null;
body.querySelectorAll(".io-line").forEach(function (tr) {
const code = tr.querySelector('input[name="item_code"]').value;
const text = tr.querySelector(".io-item-search").value.trim();
if (!code && text && !bad) bad = { tr: tr, msg: "'" + text + "' — 검색 목록에서 제품을 골라 주세요." };
if (code && codes.indexOf(code) >= 0 && !bad) bad = { tr: tr, msg: code + " — 같은 제품이 두 줄에 있습니다. 한 줄로 합쳐 주세요." };
if (code) codes.push(code);
});
if (bad) {
e.preventDefault();
bad.tr.querySelector(".io-item-search").classList.add("is-invalid");
alertMsg(bad.msg).then(function () { bad.tr.querySelector(".io-item-search").focus(); });
}
});
}
// 코드표 단품 검색 드롭다운 — 고르면 숨은 칸(코드·이름)을 채우고 수량 칸으로. 글을 다시 고치면 고른 것을 지운다.
function wireSearch(input) {
if (!input || input.readOnly || input.dataset.wired) return;
input.dataset.wired = "1";
const cell = input.closest(".io-item-cell");
const codeEl = cell.querySelector('input[name="item_code"]');
const nameEl = cell.querySelector('input[name="item_name"]');
const box = document.createElement("div");
box.className = "io-suggest";
box.setAttribute("role", "listbox");
box.hidden = true;
document.body.appendChild(box); // 표 가로 스크롤 상자 밖(fixed) — 아래 줄에서도 잘리지 않게
input._ioBox = box;
let timer = 0, seq = 0, items = [], active = -1;
function place() {
const r = input.getBoundingClientRect();
const below = window.innerHeight - r.bottom;
box.style.left = r.left + "px";
box.style.width = Math.max(r.width, 320) + "px";
if (below < 200 && r.top > below) { box.style.top = ""; box.style.bottom = (window.innerHeight - r.top + 2) + "px"; }
else { box.style.bottom = ""; box.style.top = (r.bottom + 2) + "px"; }
}
window.addEventListener("resize", function () { if (!box.hidden) place(); });
document.addEventListener("scroll", function () { if (!box.hidden) place(); }, true);
function close() { box.hidden = true; active = -1; input.setAttribute("aria-expanded", "false"); }
function paint() {
box.innerHTML = "";
if (!items.length) {
const empty = document.createElement("div");
empty.className = "io-suggest-empty";
empty.textContent = box.dataset.message || "맞는 단품이 없습니다.";
box.appendChild(empty);
}
items.forEach(function (it, i) {
const opt = document.createElement("div");
opt.className = "io-suggest-item" + (i === active ? " is-active" : "");
opt.setAttribute("role", "option");
const c = document.createElement("span");
c.className = "io-code";
c.textContent = it.code;
opt.appendChild(c);
opt.appendChild(document.createTextNode(" " + it.name));
opt.addEventListener("mousedown", function (e) { e.preventDefault(); choose(i); });
box.appendChild(opt);
});
box.hidden = false;
place();
input.setAttribute("aria-expanded", "true");
}
function choose(i) {
const it = items[i];
if (!it) return;
codeEl.value = it.code;
nameEl.value = it.name;
input.value = it.code + " · " + it.name;
input.classList.remove("is-invalid");
close();
const qty = input.closest("tr").querySelector(".io-qty");
if (qty) qty.focus();
input.dispatchEvent(new Event("io-chosen", { bubbles: true }));
}
async function search(q) {
const my = ++seq;
try {
const res = await fetch("/inout/api/items?q=" + encodeURIComponent(q), { headers: { Accept: "application/json" } });
const data = await res.json();
if (my !== seq) return;
items = data.items || [];
box.dataset.message = data.enabled === false ? (data.message || "코드표가 연결되지 않았습니다.") : "";
active = items.length ? 0 : -1;
paint();
} catch (_) {
if (my !== seq) return;
items = [];
box.dataset.message = "검색하지 못했습니다. 잠시 뒤 다시 입력하세요.";
paint();
}
}
input.setAttribute("aria-autocomplete", "list");
input.addEventListener("input", function () {
codeEl.value = ""; // 글을 고치면 고른 제품은 풀린다(다시 골라야 저장)
nameEl.value = "";
clearTimeout(timer);
const q = input.value.trim();
if (!q) { close(); return; }
timer = setTimeout(function () { search(q); }, 200);
});
input.addEventListener("keydown", function (e) {
if (box.hidden) return;
if (e.key === "ArrowDown" || e.key === "ArrowUp") {
e.preventDefault();
if (!items.length) return;
active = (active + (e.key === "ArrowDown" ? 1 : items.length - 1)) % items.length;
paint();
} else if (e.key === "Enter") {
e.preventDefault(); // 고르기만 — 폼 저장 아님
choose(active < 0 ? 0 : active);
} else if (e.key === "Escape") {
close();
}
});
input.addEventListener("blur", function () { setTimeout(close, 120); });
}
// ── 발주서 화면: 입고 입력 ──
const recvForm = document.getElementById("io-receipt-form");
if (recvForm) {
const total = document.getElementById("io-recv-total");
const inputs = Array.from(recvForm.querySelectorAll(".io-recv"));
const paintTotal = function () {
const t = inputs.reduce(function (s, i) { return s + num(i.value); }, 0);
if (total) total.textContent = t ? "(" + fmt(t) + "개)" : "";
};
recvForm.addEventListener("input", paintTotal);
const fill = document.getElementById("io-fill-remaining");
if (fill) fill.addEventListener("click", function () {
inputs.forEach(function (i) { if (!i.value.trim() && num(i.dataset.remaining)) i.value = i.dataset.remaining; });
paintTotal();
});
paintTotal();
}
})();
+1
View File
@@ -34,6 +34,7 @@ MODULE_KEYS: tuple[str, ...] = (
"cafe24",
"performance",
"asset",
"inout",
"expense_approver",
"vacation_approver",
)