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:
@@ -144,6 +144,11 @@ CUSTOMER_ORDER_LIST_URL=/orderlist/
|
||||
# CAFE24_MOBILE_DETAIL_FTP_PATH=/sde_design/mobile11/product/detail.html
|
||||
# CAFE24_PC_DETAIL_FTP_PATH=/sde_design/skin11/product/detail.html
|
||||
|
||||
# ─── 입출고 관리 모듈 (inout_db) — app/modules/inout ───
|
||||
# 본사 → 공장 발주, 물류 입고, 미입고 관리. 미설정 시 "설정 필요" 안내만.
|
||||
# 초기화: scripts/sql/inout_db_init.sql (docs/INOUT_MODULE.md). 제품(단품)은 아래 ITEMCODE_DB_URL 재사용.
|
||||
# INOUT_DB_URL=postgresql://inout_app:replace-me@postgres-db:5432/inout_db
|
||||
|
||||
# ─── 상품 검색 (itemcode_db 읽기 전용) ───
|
||||
# cupang 설정 화면에서 제품명을 itemcode_db 에서 검색해 등록한다(읽기만).
|
||||
# 미설정 시 검색 비활성 → 수동 등록만 가능.
|
||||
|
||||
@@ -42,6 +42,8 @@ Claude Code는 이 저장소에서 작업을 시작하기 전에 **반드시 아
|
||||
|
||||
- 긴급 공지 (`app/modules/notice/`, `project_db` 마이그레이션 024 `urgent_notice*`) — 수퍼관리자만 작성(`/notice/`, ERP 왼쪽 아래·Project ⚙ 옵션). 제목·내용(이미지 bytea)·띄울 시각·전체/고른 사람 → ERP 모든 화면(`erp_base.html`·`main.html`·`admin.html` 의 `static/erp-notice.js`) 가로·세로 정가운데에 [확인] 누를 때까지(Esc·바깥 클릭 무시), 확인 기록. 연결 풀은 `ProjectStore.pool` 공유, 새 환경변수 없음. PC 알림 프로그램은 아직 미지원. 상세는 `docs/NOTICE_MODULE.md`
|
||||
|
||||
- 입출고 관리 (`app/modules/inout/`, `inout_db`, 2026-10-16) — 본사 → 공장 제품 제작 발주(발주서 `PO-YYMMDD-NN`, 제품 = `itemcode_db.single_items` 단품만, 검색 `GET /inout/api/items`·저장 때 서버 재확인), 물류 입고를 여러 번 나눠 입력, 품목별 발주·입고·미입고, 미입고 현황(제품별 합계·발주별·지연), 초과 입고는 확인 화면 후 허용(트랜잭션 안에서 발주서 잠그고 판단, `confirm_over`), 잔량 종결·취소(입고 없을 때만). 상태는 저장하지 않고 누적 입고로 계산(`store.order_status`). 권한키 `inout`(조회), **발주 담당·입고 담당·공장은 모듈 옵션**(`/inout/settings`, ERP 관리자, `inout_roles`·`inout_factories`), 관리자는 둘 다. 이카운트 "발주 대비 미입고"·Odoo 분할 입고/종결 참고. 상세 `docs/INOUT_MODULE.md`
|
||||
|
||||
상세는 `docs/PROJECT_OVERVIEW.md`.
|
||||
|
||||
---
|
||||
|
||||
+20
@@ -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"/>',
|
||||
|
||||
@@ -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()
|
||||
@@ -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("사용하지 않는 공장입니다(옵션에서 '사용'으로 바꾸세요).")
|
||||
@@ -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()
|
||||
@@ -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"}
|
||||
@@ -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 %}
|
||||
@@ -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; }
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
})();
|
||||
@@ -34,6 +34,7 @@ MODULE_KEYS: tuple[str, ...] = (
|
||||
"cafe24",
|
||||
"performance",
|
||||
"asset",
|
||||
"inout",
|
||||
"expense_approver",
|
||||
"vacation_approver",
|
||||
)
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
| `malaysia_stock_db` | 말레이시아 창고 재고관리 — 창고/아이템/세트 BOM/입출고 이력/일일 재고조사 |
|
||||
| `cafe24_db` | 카페24 연동 — OAuth 토큰/상품 캐시/상세페이지 버전/예약/감사·API 로그 |
|
||||
| `performance_db` | 실적(쇼핑몰 통합 매출) — 쇼핑몰 설정/수수료율 이력/API 인증정보(암호문)/연결 상태/매출 사건/동기화 기록 |
|
||||
| `inout_db` | 입출고 관리 — 공장/발주 담당·입고 담당/발주서·발주 품목/입고·입고 품목 (2026-10-16, 앱 계정 `inout_app`, `INOUT_DB_URL`, 초기화 `scripts/sql/inout_db_init.sql`, 상세 `docs/INOUT_MODULE.md`) |
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -264,6 +264,23 @@ docker exec -i postgres-db psql -v ON_ERROR_STOP=1 -U postgres -d project_db < s
|
||||
docker exec postgres-db psql -U postgres -d project_db -c "SELECT to_regclass('goal_meeting_tasks') AS t;"
|
||||
```
|
||||
|
||||
## 입출고 관리 DB 생성 (inout_db, 2026-10-16)
|
||||
|
||||
새 DB 라 기존 DB·데이터는 건드리지 않는다(초기화 SQL 은 멱등, DROP·TRUNCATE 없음). 비밀번호는 영문·숫자로(DSN 에 그대로 들어감).
|
||||
|
||||
```bash
|
||||
cd /opt/www/main && git pull
|
||||
docker exec postgres-db psql -U postgres -lqt | cut -d| -f1 | grep -w inout_db || echo "inout_db 없음 — 새로 만든다"
|
||||
read -s -p "inout_app password: " APP_PWD; echo
|
||||
docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/inout_db_init.sql
|
||||
grep -q "^INOUT_DB_URL=" .env || echo "INOUT_DB_URL=postgresql://inout_app:${APP_PWD}@postgres-db:5432/inout_db" >> .env
|
||||
docker compose up --build -d web
|
||||
curl -s http://127.0.0.1:<web 포트>/inout/health # {"status":"ok"}
|
||||
```
|
||||
|
||||
그다음 ERP 관리자 화면에서 쓸 사람에게 **입출고 관리** 권한 → 입출고 관리 → 옵션에서 공장·발주 담당·입고 담당 지정.
|
||||
백업: 매일 `docker exec postgres-db pg_dump -U postgres inout_db > /var/backups/postgres/inout_db_$(date +%F).sql`.
|
||||
|
||||
## 긴급 공지 마이그레이션 (024)
|
||||
|
||||
024는 `urgent_notices`·`urgent_notice_targets`·`urgent_notice_acks`·`urgent_notice_images` 테이블만 추가한다(기존 값 그대로, 다시 실행 가능).
|
||||
@@ -370,6 +387,7 @@ docker compose down # 컨테이너 제거 (볼륨 유지)
|
||||
| `APP_ENCRYPTION_KEY` | 쇼핑몰 API 인증정보 암호화 마스터 키(32바이트, `openssl rand -hex 32`). DB 에 저장하지 않음. **분실 시 저장된 인증정보 복구 불가 — 별도 안전 보관**. 쇼핑몰별 ID/Key/Secret 은 `.env` 에 넣지 않고 실적 → 설정 화면에서 입력 |
|
||||
| `APP_ENCRYPTION_KEY_VERSION` | 현재 마스터 키 버전(기본 1). 교체 시 올리고 예전 키는 `APP_ENCRYPTION_KEY_V{n}` 로 남긴 뒤 설정 화면에서 재암호화(`docs/PERFORMANCE_MODULE.md`) |
|
||||
| `PERFORMANCE_SYNC_DAYS` | [매출 업데이트] 수집 기간(오늘 포함 최근 N일, 기본 7, 최대 90) |
|
||||
| `INOUT_DB_URL` | 입출고 관리 DB DSN (예: `postgresql://inout_app:<pwd>@postgres-db:5432/inout_db`). 미설정 시 입출고 모듈 비활성(설정 필요 안내). 권한키 `inout`. 제품은 `ITEMCODE_DB_URL`(단품) 재사용 |
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
# 입출고 관리(inout) 모듈
|
||||
|
||||
> `app/modules/inout/` · DB `inout_db` · URL `/inout/` · 권한키 `inout` · 2026-10-16 신설
|
||||
|
||||
본사가 공장에 **제품 제작 발주**를 넣고, 공장 물건이 **물류에 입고**될 때마다 입고 수량을 입력해서
|
||||
발주한 제품이 다 들어왔는지, **미입고**(덜 들어옴)·**초과 입고**(더 들어옴)가 있는지 관리한다.
|
||||
|
||||
## 1. 참고한 상용 프로그램
|
||||
|
||||
| 프로그램 | 가져온 것 |
|
||||
|---|---|
|
||||
| 이카운트 ERP | 입고(구매입력)를 **발주서를 불러와서** 처리(발주번호 + 품목코드가 기준), **발주 대비 미입고 현황**(거래처별·품목별) |
|
||||
| Odoo | 한 발주를 **여러 번 나눠 입고**, 덜 들어온 잔량은 "나중에 받기" 또는 **"더 안 받음(종결)"** 선택, 초과 입고는 확인 후 허용 |
|
||||
|
||||
## 2. 흐름과 상태
|
||||
|
||||
```
|
||||
발주(open) ──입고 일부──▶ 부분입고(partial) ──남은 것 다 입고──▶ 입고완료(done)
|
||||
│ │ └─발주보다 많이──▶ 초과입고(over)
|
||||
│ └─[잔량 종결]──▶ 종결(closed) ─[종결 풀기]─▶ 원래 상태
|
||||
└─[발주 취소](입고 기록 없을 때만)──▶ 취소(cancelled)
|
||||
```
|
||||
|
||||
- 상태는 **저장하지 않고** 품목별 누적 입고로 계산한다(`store.order_status`, `store.line_status`) — 어긋날 수 없다.
|
||||
- 품목 상태: 미입고 / 부분입고 / 입고완료 / 초과입고. 발주서는 하나라도 남으면 부분입고(초과가 섞여 있어도).
|
||||
- **미입고 현황**(`/inout/pending`)은 종결·취소가 아닌 발주의 남은 수량만 — 제품별 합계, 발주별(입고 예정일 순, 지난 것 빨강), 초과 입고 목록.
|
||||
- **초과 입고**: 입고 저장 때 발주를 넘는 품목이 있으면 저장하지 않고 확인 화면(409, 넣은 숫자 유지) → [초과 입고로 저장](`confirm_over=1`).
|
||||
판단은 DB 트랜잭션 안에서 발주서 행을 잠그고(`FOR UPDATE`) 누적 입고를 다시 읽어 한다 — 동시에 입고해도 확인을 건너뛰지 않음.
|
||||
Enter 키는 숨은 기본 버튼(일반 저장)으로 가게 해 확인 없이 초과가 저장되지 않게 했다.
|
||||
- 발주서 고치기: 입고된 품목은 **뺄 수 없다**(입고 기록이 사라지므로) — 수량은 바꿀 수 있다(입고보다 줄이면 초과로 보임).
|
||||
- 입고 기록 지우기(입고 담당): 잘못 넣은 1건을 지우면 그만큼 다시 미입고.
|
||||
- 발주번호: `PO-YYMMDD-NN`(발주일 기준 그날 순번, advisory lock 으로 동시 생성해도 겹치지 않음).
|
||||
|
||||
## 3. 권한·담당자
|
||||
|
||||
| 누구 | 할 수 있는 것 |
|
||||
|---|---|
|
||||
| 모듈 권한 `inout` | 발주 목록·발주서·미입고 현황 조회 |
|
||||
| **발주 담당**(옵션에서 지정) | 발주서 작성·고치기·잔량 종결/풀기·취소 |
|
||||
| **입고 담당**(옵션에서 지정) | 입고 수량 입력·입고 기록 지우기 |
|
||||
| ERP 관리자(`role=admin`) | 위 전부 + **옵션**(공장 목록·담당자) |
|
||||
|
||||
담당자 후보 = ERP 관리자 화면에서 `inout` 권한을 받은 사용자. 권한이 빠졌는데 담당으로 남은 사람도 옵션에 보여서 뺄 수 있다.
|
||||
담당은 `inout_roles(email, role)` — role `order`(발주)·`receive`(입고).
|
||||
|
||||
## 4. 제품 = 코드표 단품
|
||||
|
||||
발주 품목은 `itemcode_db.single_items`(단품)에서만 고른다(세트 아님) — `itemcode.py SingleItemReader`(읽기 전용, `ITEMCODE_DB_URL` 재사용,
|
||||
cupang·malaysia 와 같은 DSN). 화면에서 코드·이름으로 검색(`GET /inout/api/items?q=`, 코드 앞부분 일치 먼저 30개),
|
||||
저장할 때 서버가 다시 코드표에 있는지 확인(`lookup`) — 없으면 "코드표 단품에 없는 제품". 발주 줄에는 코드·**발주 당시 이름** 사본을 둔다.
|
||||
이미 발주서에 있던 코드는 나중에 코드표에서 빠져도 그대로 고칠 수 있다. 코드표 연결이 안 되면 새 제품을 넣는 저장만 막힌다(안내 문구).
|
||||
|
||||
## 5. 화면
|
||||
|
||||
| 주소 | 내용 |
|
||||
|---|---|
|
||||
| `/inout/` | 발주 목록 — 상태(진행 중·완료·종결·취소·전체)·공장·발주일 기간·검색(발주번호·제품 코드·이름), 진행률 막대, 지연 표시 |
|
||||
| `/inout/pending` | 미입고 현황 — 요약 숫자, 제품별 합계, 발주별, 초과 입고 |
|
||||
| `/inout/orders/new`, `/{id}/edit` | 발주서 폼 — 공장·발주일·입고 예정일·메모, 제품 줄(검색 드롭다운·수량·줄 메모), 합계 |
|
||||
| `/inout/orders/{id}` | 발주서 — 품목별 발주·입고·미입고·상태, **이번 입고** 칸(입고 담당) + [남은 수량 모두 채우기], 입고 기록, 종결·취소 |
|
||||
| `/inout/settings` | 옵션(관리자) — 담당자(발주·입고 체크), 공장(이름·연락처·메모·순서·사용, 발주 기록 없을 때만 지우기) |
|
||||
|
||||
화면은 서버 폼(POST → 303 + `?msg=` 안내). `static/inout.js` 는 입력 보조만(제품 검색 드롭다운 — `position: fixed` 로 body 에 붙여
|
||||
표 가로 스크롤에 잘리지 않음, 줄 추가·삭제·합계, 남은 수량 채우기, 버튼별 확인 `data-erp-confirm-btn`).
|
||||
공용 `.erp-page` 가 content-box 라 넓은 표에서 48px 넘치므로 이 화면만 `.erp-page:has(> .io) { box-sizing: border-box }`.
|
||||
|
||||
## 6. DB (`inout_db`, `scripts/sql/inout_db_init.sql`)
|
||||
|
||||
| 표 | 내용 |
|
||||
|---|---|
|
||||
| `inout_factories` | 공장 — 이름(대소문자 무시 유일)·연락처·메모·사용·순서 |
|
||||
| `inout_roles` | 담당자 — (email, role: order/receive) |
|
||||
| `inout_orders` | 발주서 — 번호·공장·발주일·입고 예정일·메모·종결(시각·사람·사유)·취소 |
|
||||
| `inout_order_lines` | 발주 품목 — 단품 코드·이름 사본·수량·줄 메모, 발주서 안에서 코드 유일 |
|
||||
| `inout_receipts` | 입고 1건(한 번 들어온 것) — 입고일·메모·입력자 |
|
||||
| `inout_receipt_lines` | 입고 품목별 수량 |
|
||||
|
||||
앱 계정 `inout_app` 은 SELECT/INSERT/UPDATE/DELETE + 시퀀스만. 초기화는 멱등(DROP·TRUNCATE 없음). 백업 권장: 매일 `pg_dump inout_db`.
|
||||
|
||||
## 7. 테스트
|
||||
|
||||
```bash
|
||||
python -m pytest tests/test_inout_store.py tests/test_inout_web.py # DB 없이(등록·미설정 화면·상태·검사)
|
||||
INOUT_TEST_DB_URL=postgresql://inout_app:<pw>@127.0.0.1:5432/inout_db \
|
||||
python -m pytest tests/test_inout_db.py tests/test_inout_web.py # 로컬 테스트 DB(초기화 SQL 적용, 앱 계정 — 권한도 확인)
|
||||
```
|
||||
|
||||
DB 테스트: 분할 입고·완료, 초과 확인, 미입고·종결·풀기·취소, 고치기(입고 품목 보호), 입고 지우기, 동시 발주번호, 담당자·공장.
|
||||
화면 흐름 테스트: 옵션 → 발주 담당 발주(코드표 아닌 제품 거부) → 입고 담당 분할·초과 확인 → 미입고 현황 → 종결, 권한별 403.
|
||||
@@ -21,6 +21,7 @@
|
||||
| 쿠팡 밀크런 | 쿠팡 출고 일정 관리 (`app/modules/cupang/`) — 월간 달력 / 출고 묶음(헤더+라인) / 상자 입수량 자동계산 / 로켓 매출 관리 / 엑셀 내보내기. 상품은 `itemcode_db` 읽기 전용 참조 |
|
||||
| 휴가 (준비중) | 연차/반차/특별휴가 신청·잔여일수 관리 |
|
||||
| 말레이시아 재고 | 말레이시아 창고 재고관리 (`app/modules/malaysia/`) — 낱개 입출고/조정, 세트 BOM, 일일 재고조사(세트 분해 자동 반영), 현재고 현황. 상품명은 `itemcode_db` 읽기 전용 참조 |
|
||||
| 입출고 관리 | 본사 → 공장 제품 제작 발주, 물류 입고(여러 번 나눠), 발주 대비 미입고·초과 입고 관리 (`app/modules/inout/`, `inout_db`) — 발주 담당·입고 담당·공장은 모듈 옵션에서 지정, 제품은 `itemcode_db` 단품 읽기 전용. `docs/INOUT_MODULE.md` |
|
||||
| 긴급 공지 | 수퍼관리자가 정한 시각에 전체/고른 사람의 ERP 화면 정가운데에 띄우는 공지(`app/modules/notice/`, project_db 024) — [확인] 전까지 다시 뜸, 확인 현황. `docs/NOTICE_MODULE.md` |
|
||||
| 실적 | 쇼핑몰 통합 매출 (`app/modules/performance/`) — 쇼핑몰별 어댑터로 수집 → `performance_db` 저장 → 일자×쇼핑몰 표·KPI·월/연 누적·그래프. 수수료율 이력, API 인증정보는 설정 화면 입력 + AES-256-GCM 암호화 저장. 1단계는 모의 데이터·구조까지(실제 API 는 쇼핑몰별로 순차 연동). `docs/PERFORMANCE_MODULE.md` |
|
||||
|
||||
@@ -36,6 +37,7 @@
|
||||
| `expense` / `vacation` / `cupang` / `malaysia` / `performance` | 접근 | 내부 모듈 진입 (`performance` 설정 화면·API 는 추가로 `admin` 필요) |
|
||||
| `expense_approver` | 결재 | 개인경비 승인/반려/정산 |
|
||||
| `asset` | 접근 | 자산관리 조회·등록·수정·배정·반납·보고서 |
|
||||
| `inout` | 접근 | 입출고 관리 조회. 발주·입고 입력은 모듈 옵션의 발주 담당·입고 담당(ERP 관리자는 둘 다 + 옵션) |
|
||||
| `vacation_approver` | 결재 | 휴가 승인/반려 (모듈 미개발) |
|
||||
|
||||
`admin` 역할은 모든 권한 자동 부여. 신규 사용자는 관리자 페이지(`/admin`)에서 이메일만으로 등록 가능.
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
-- =====================================================================
|
||||
-- inout_db 초기화 스크립트 (PostgreSQL) — 입출고 관리 모듈(2026-10-16)
|
||||
-- =====================================================================
|
||||
-- 본사 → 공장 제품 제작 발주, 공장 → 물류 입고(여러 번 나눠 입고) 기록, 발주 대비 미입고·초과 관리.
|
||||
-- 멱등(idempotent): 여러 번 실행해도 안전. 기존 데이터를 삭제하지 않는다. DROP/TRUNCATE 없음.
|
||||
--
|
||||
-- 실행 방법 (운영 PostgreSQL 컨테이너명: postgres-db, 백업 먼저):
|
||||
--
|
||||
-- 1) DB / 역할 / 테이블 생성 (superuser 로 1회)
|
||||
-- read -s -p "inout_app password: " APP_PWD; echo
|
||||
-- docker exec -i postgres-db psql -U postgres -v app_password="$APP_PWD" < scripts/sql/inout_db_init.sql
|
||||
--
|
||||
-- 2) main-app .env 에 연결 정보 등록
|
||||
-- INOUT_DB_URL=postgresql://inout_app:<APP_PWD>@postgres-db:5432/inout_db
|
||||
--
|
||||
-- 3) main-app 재기동
|
||||
-- cd /opt/www/main && docker compose up -d --build web
|
||||
--
|
||||
-- 제품(단품)은 itemcode_db.single_items 를 읽기 전용으로 고른다(ITEMCODE_DB_URL 재사용) — 여기엔 코드·이름 사본만 둔다.
|
||||
-- =====================================================================
|
||||
|
||||
\set ON_ERROR_STOP on
|
||||
|
||||
SELECT 'CREATE DATABASE inout_db ENCODING ''UTF8'' TEMPLATE template0'
|
||||
WHERE NOT EXISTS (SELECT 1 FROM pg_database WHERE datname = 'inout_db')
|
||||
\gexec
|
||||
|
||||
SELECT 'CREATE ROLE inout_app LOGIN PASSWORD ' || quote_literal(:'app_password')
|
||||
WHERE NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'inout_app')
|
||||
\gexec
|
||||
|
||||
SELECT 'ALTER ROLE inout_app WITH LOGIN PASSWORD ' || quote_literal(:'app_password')
|
||||
\gexec
|
||||
|
||||
GRANT CONNECT ON DATABASE inout_db TO inout_app;
|
||||
|
||||
\connect inout_db
|
||||
|
||||
CREATE OR REPLACE FUNCTION inout_set_updated_at() RETURNS trigger AS $$
|
||||
BEGIN
|
||||
NEW.updated_at := now();
|
||||
RETURN NEW;
|
||||
END;
|
||||
$$ LANGUAGE plpgsql;
|
||||
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
-- 1) 공장(발주처) — 옵션에서 추가·수정, 쓰지 않으면 숨김(발주 기록이 있으면 지우지 않는다)
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
CREATE TABLE IF NOT EXISTS inout_factories (
|
||||
id SERIAL PRIMARY KEY,
|
||||
name TEXT NOT NULL CHECK (char_length(name) BETWEEN 1 AND 100),
|
||||
contact TEXT NOT NULL DEFAULT '', -- 담당자·연락처(자유 글)
|
||||
memo TEXT NOT NULL DEFAULT '',
|
||||
is_active BOOLEAN NOT NULL DEFAULT TRUE,
|
||||
sort_order INTEGER NOT NULL DEFAULT 0,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE UNIQUE INDEX IF NOT EXISTS uq_inout_factories_name ON inout_factories (lower(name));
|
||||
DROP TRIGGER IF EXISTS trg_inout_factories_updated ON inout_factories;
|
||||
CREATE TRIGGER trg_inout_factories_updated BEFORE UPDATE ON inout_factories
|
||||
FOR EACH ROW EXECUTE FUNCTION inout_set_updated_at();
|
||||
COMMENT ON TABLE inout_factories IS '입출고 — 공장(발주처) 목록';
|
||||
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
-- 2) 담당자 — 옵션에서 지정. order = 발주 담당(발주서 작성·수정·종결), receive = 입고 담당(입고 수량 입력)
|
||||
-- ERP 관리자는 지정 없이도 둘 다 할 수 있다(앱에서 판단).
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
CREATE TABLE IF NOT EXISTS inout_roles (
|
||||
email TEXT NOT NULL,
|
||||
role TEXT NOT NULL CHECK (role IN ('order', 'receive')),
|
||||
created_by TEXT NOT NULL DEFAULT '',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (email, role)
|
||||
);
|
||||
COMMENT ON TABLE inout_roles IS '입출고 — 발주 담당(order)·입고 담당(receive)';
|
||||
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
-- 3) 발주서(헤더) — 상태는 줄의 입고 합계로 앱이 계산(closed_at = 잔량 종결, cancelled_at = 취소)
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
CREATE TABLE IF NOT EXISTS inout_orders (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
order_no TEXT NOT NULL UNIQUE, -- PO-YYMMDD-NN (발주일 기준 순번)
|
||||
factory_id INTEGER NOT NULL REFERENCES inout_factories(id),
|
||||
order_date DATE NOT NULL,
|
||||
due_date DATE NULL, -- 입고 예정일(납기)
|
||||
memo TEXT NOT NULL DEFAULT '',
|
||||
closed_at TIMESTAMPTZ NULL, -- 종결: 남은 미입고를 더 기다리지 않음
|
||||
closed_by TEXT NOT NULL DEFAULT '',
|
||||
close_reason TEXT NOT NULL DEFAULT '',
|
||||
cancelled_at TIMESTAMPTZ NULL, -- 취소(입고 기록이 없을 때만)
|
||||
cancelled_by TEXT NOT NULL DEFAULT '',
|
||||
created_by TEXT NOT NULL DEFAULT '',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
updated_by TEXT NOT NULL DEFAULT '',
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_inout_orders_date ON inout_orders (order_date DESC, id DESC);
|
||||
CREATE INDEX IF NOT EXISTS idx_inout_orders_factory ON inout_orders (factory_id);
|
||||
DROP TRIGGER IF EXISTS trg_inout_orders_updated ON inout_orders;
|
||||
CREATE TRIGGER trg_inout_orders_updated BEFORE UPDATE ON inout_orders
|
||||
FOR EACH ROW EXECUTE FUNCTION inout_set_updated_at();
|
||||
COMMENT ON TABLE inout_orders IS '입출고 — 공장 제품 제작 발주서';
|
||||
|
||||
-- 발주 품목 — 제품은 itemcode_db.single_items(단품)의 코드·이름 사본(발주 당시 이름)
|
||||
CREATE TABLE IF NOT EXISTS inout_order_lines (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
|
||||
line_no INTEGER NOT NULL,
|
||||
item_code TEXT NOT NULL CHECK (char_length(item_code) BETWEEN 1 AND 64),
|
||||
item_name TEXT NOT NULL DEFAULT '',
|
||||
qty INTEGER NOT NULL CHECK (qty > 0),
|
||||
memo TEXT NOT NULL DEFAULT '',
|
||||
UNIQUE (order_id, item_code)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_inout_order_lines_item ON inout_order_lines (item_code);
|
||||
COMMENT ON TABLE inout_order_lines IS '입출고 — 발주 품목(단품 코드·발주 수량)';
|
||||
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
-- 4) 입고 — 한 번 들어온 것(날짜) = 입고 1건, 그 안에 품목별 수량. 한 발주에 여러 번 나눠 입고 가능.
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
CREATE TABLE IF NOT EXISTS inout_receipts (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
order_id BIGINT NOT NULL REFERENCES inout_orders(id) ON DELETE CASCADE,
|
||||
receipt_date DATE NOT NULL,
|
||||
memo TEXT NOT NULL DEFAULT '',
|
||||
created_by TEXT NOT NULL DEFAULT '',
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_inout_receipts_order ON inout_receipts (order_id, receipt_date);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS inout_receipt_lines (
|
||||
id BIGSERIAL PRIMARY KEY,
|
||||
receipt_id BIGINT NOT NULL REFERENCES inout_receipts(id) ON DELETE CASCADE,
|
||||
order_line_id BIGINT NOT NULL REFERENCES inout_order_lines(id) ON DELETE CASCADE,
|
||||
qty INTEGER NOT NULL CHECK (qty > 0),
|
||||
UNIQUE (receipt_id, order_line_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_inout_receipt_lines_line ON inout_receipt_lines (order_line_id);
|
||||
COMMENT ON TABLE inout_receipts IS '입출고 — 물류 입고(한 번 들어온 것)';
|
||||
COMMENT ON TABLE inout_receipt_lines IS '입출고 — 입고 품목별 수량';
|
||||
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
-- 권한 — 앱 계정은 읽기·쓰기만(스키마 변경 없음)
|
||||
-- ════════════════════════════════════════════════════════════
|
||||
GRANT USAGE ON SCHEMA public TO inout_app;
|
||||
GRANT SELECT, INSERT, UPDATE, DELETE ON
|
||||
inout_factories, inout_roles, inout_orders, inout_order_lines, inout_receipts, inout_receipt_lines
|
||||
TO inout_app;
|
||||
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO inout_app;
|
||||
|
||||
SELECT 'inout_db ready' AS status;
|
||||
@@ -0,0 +1,166 @@
|
||||
"""입출고 저장소 — 실제 PostgreSQL(로컬 테스트 DB 전용, INOUT_TEST_DB_URL 이 localhost 일 때만).
|
||||
|
||||
INOUT_TEST_DB_URL=postgresql://inout_app:<pw>@127.0.0.1:5432/inout_db python -m pytest tests/test_inout_db.py
|
||||
scripts/sql/inout_db_init.sql 을 적용한 DB 에 앱 계정(inout_app)으로 붙는다 — 권한(GRANT)도 함께 확인된다.
|
||||
가상의 공장·발주만 만든다(이름에 무작위 꼬리표).
|
||||
"""
|
||||
import os
|
||||
import threading
|
||||
import unittest
|
||||
import uuid
|
||||
from datetime import date
|
||||
from urllib.parse import urlparse
|
||||
|
||||
DSN = os.getenv("INOUT_TEST_DB_URL", "")
|
||||
ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
|
||||
|
||||
|
||||
@unittest.skipUnless(ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
|
||||
class InoutDbTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
from app.modules.inout.db import InoutDBStore
|
||||
|
||||
cls.st = InoutDBStore(DSN)
|
||||
cls.tag = uuid.uuid4().hex[:6]
|
||||
cls.fid = cls.st.save_factory(factory_id=None, name=f"테스트공장-{cls.tag}", contact="김공장 010")
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.st.close()
|
||||
|
||||
def order(self, lines, **over):
|
||||
from app.modules.inout import store
|
||||
|
||||
data = store.validate_order(factory_id=over.get("factory_id", self.fid), order_date=over.get("order_date", "2026-10-16"),
|
||||
due_date=over.get("due_date", "2026-10-30"), memo="",
|
||||
codes=[c for c, _q in lines], quantities=[str(q) for _c, q in lines])
|
||||
names = {c: f"{c} 이름" for c, _q in lines}
|
||||
return self.st.create_order(data, names, by="Boss@Test.local")
|
||||
|
||||
def line_ids(self, oid):
|
||||
return {ln["item_code"]: ln["id"] for ln in self.st.get_order(oid)["lines"]}
|
||||
|
||||
def test_partial_receipts_until_done(self):
|
||||
o = self.order([("MT-A", 100), ("MT-B", 50)])
|
||||
self.assertRegex(o["order_no"], r"^PO-261016-\d{2}$")
|
||||
ids = self.line_ids(o["id"])
|
||||
self.assertEqual(self.st.get_order(o["id"])["status"], "open")
|
||||
self.st.add_receipt(o["id"], {ids["MT-A"]: "60"}, receipt_date="2026-10-20", memo="1차", confirm_over=False, by="w@x")
|
||||
got = self.st.get_order(o["id"])
|
||||
self.assertEqual((got["status"], got["summary"]["received"], got["summary"]["remaining"]), ("partial", 60, 90))
|
||||
a = next(x for x in got["lines"] if x["item_code"] == "MT-A")
|
||||
self.assertEqual((a["received"], a["remaining"], a["status"]), (60, 40, "partial"))
|
||||
self.st.add_receipt(o["id"], {ids["MT-A"]: "40", ids["MT-B"]: "50"}, receipt_date="2026-10-22", memo="",
|
||||
confirm_over=False, by="w@x")
|
||||
got = self.st.get_order(o["id"])
|
||||
self.assertEqual((got["status"], got["summary"]["remaining"], len(got["receipts"])), ("done", 0, 2))
|
||||
self.assertEqual([r["total"] for r in got["receipts"]], [60, 90])
|
||||
# 진행 중 목록에서 빠지고 완료 목록에
|
||||
self.assertNotIn(o["id"], [x["id"] for x in self.st.list_orders(status="active", factory_id=self.fid)])
|
||||
self.assertIn(o["id"], [x["id"] for x in self.st.list_orders(status="done", factory_id=self.fid)])
|
||||
|
||||
def test_over_receipt_needs_confirm(self):
|
||||
from app.modules.inout.db import OverReceipt
|
||||
|
||||
o = self.order([("MT-C", 10)])
|
||||
ids = self.line_ids(o["id"])
|
||||
with self.assertRaises(OverReceipt) as ctx:
|
||||
self.st.add_receipt(o["id"], {ids["MT-C"]: "12"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
||||
self.assertEqual(ctx.exception.over[0]["over"], 2)
|
||||
self.assertEqual(self.st.get_order(o["id"])["summary"]["received"], 0) # 확인 전엔 아무것도 저장 안 함
|
||||
self.st.add_receipt(o["id"], {ids["MT-C"]: "12"}, receipt_date="2026-10-20", memo="", confirm_over=True, by="w@x")
|
||||
got = self.st.get_order(o["id"])
|
||||
self.assertEqual((got["status"], got["lines"][0]["over"]), ("over", 2))
|
||||
self.assertEqual([r["item_code"] for r in self.st.outstanding(factory_id=self.fid)["over"]
|
||||
if r["order_id"] == o["id"]], ["MT-C"])
|
||||
|
||||
def test_outstanding_close_reopen_cancel(self):
|
||||
o = self.order([("MT-D", 30), ("MT-E", 5)])
|
||||
ids = self.line_ids(o["id"])
|
||||
self.st.add_receipt(o["id"], {ids["MT-D"]: "10"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
||||
pend = [r for r in self.st.outstanding(factory_id=self.fid)["pending"] if r["order_id"] == o["id"]]
|
||||
self.assertEqual({r["item_code"]: r["remaining"] for r in pend}, {"MT-D": 20, "MT-E": 5})
|
||||
self.assertTrue(self.st.outstanding(q="MT-E")["pending"])
|
||||
self.st.set_closed(o["id"], closed=True, reason="공장 단종", by="boss@x")
|
||||
self.assertEqual(self.st.get_order(o["id"])["status"], "closed")
|
||||
self.assertFalse([r for r in self.st.outstanding(factory_id=self.fid)["pending"] if r["order_id"] == o["id"]])
|
||||
with self.assertRaisesRegex(ValueError, "종결"):
|
||||
self.st.add_receipt(o["id"], {ids["MT-E"]: "1"}, receipt_date="2026-10-21", memo="", confirm_over=False, by="w@x")
|
||||
self.st.set_closed(o["id"], closed=False, by="boss@x")
|
||||
self.assertEqual(self.st.get_order(o["id"])["status"], "partial")
|
||||
with self.assertRaisesRegex(ValueError, "입고 기록이 있는"):
|
||||
self.st.cancel_order(o["id"], by="boss@x")
|
||||
o2 = self.order([("MT-F", 1)])
|
||||
self.st.cancel_order(o2["id"], by="boss@x")
|
||||
self.assertEqual(self.st.get_order(o2["id"])["status"], "cancelled")
|
||||
self.assertIn(o2["id"], [x["id"] for x in self.st.list_orders(status="closed", factory_id=self.fid)])
|
||||
|
||||
def test_update_order_keeps_received_lines(self):
|
||||
from app.modules.inout import store
|
||||
|
||||
o = self.order([("MT-G", 10), ("MT-H", 10)])
|
||||
ids = self.line_ids(o["id"])
|
||||
self.st.add_receipt(o["id"], {ids["MT-G"]: "4"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
||||
drop_g = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="", memo="",
|
||||
codes=["MT-H"], quantities=["10"])
|
||||
with self.assertRaisesRegex(ValueError, "MT-G"):
|
||||
self.st.update_order(o["id"], drop_g, {}, by="boss@x")
|
||||
change = store.validate_order(factory_id=self.fid, order_date="2026-10-16", due_date="2026-11-05", memo="수정",
|
||||
codes=["MT-G", "MT-I"], quantities=["3", "7"])
|
||||
self.st.update_order(o["id"], change, {"MT-I": "새 제품"}, by="boss@x")
|
||||
got = self.st.get_order(o["id"])
|
||||
self.assertEqual([(x["item_code"], x["qty"], x["received"]) for x in got["lines"]], [("MT-G", 3, 4), ("MT-I", 7, 0)])
|
||||
self.assertEqual(got["lines"][0]["status"], "over") # 수량을 입고보다 줄이면 초과로 보임
|
||||
self.assertEqual((got["memo"], str(got["due_date"])), ("수정", "2026-11-05"))
|
||||
|
||||
def test_delete_receipt_restores_remaining(self):
|
||||
o = self.order([("MT-J", 10)])
|
||||
ids = self.line_ids(o["id"])
|
||||
r = self.st.add_receipt(o["id"], {ids["MT-J"]: "10"}, receipt_date="2026-10-20", memo="", confirm_over=False, by="w@x")
|
||||
self.st.delete_receipt(o["id"], r["id"], by="w@x")
|
||||
got = self.st.get_order(o["id"])
|
||||
self.assertEqual((got["status"], got["summary"]["remaining"], got["receipts"]), ("open", 10, []))
|
||||
with self.assertRaises(ValueError):
|
||||
self.st.delete_receipt(o["id"], r["id"], by="w@x")
|
||||
|
||||
def test_order_numbers_per_day_and_concurrent(self):
|
||||
nos = []
|
||||
lock = threading.Lock()
|
||||
|
||||
def make():
|
||||
n = self.order([("MT-K", 1)], order_date="2026-03-03")["order_no"]
|
||||
with lock:
|
||||
nos.append(n)
|
||||
|
||||
threads = [threading.Thread(target=make) for _ in range(5)]
|
||||
for t in threads:
|
||||
t.start()
|
||||
for t in threads:
|
||||
t.join()
|
||||
self.assertEqual(len(set(nos)), 5) # 동시에 만들어도 번호 겹치지 않음
|
||||
self.assertTrue(all(n.startswith("PO-260303-") for n in nos))
|
||||
|
||||
def test_roles_and_factories(self):
|
||||
self.st.set_role_members("order", ["Boss@Test.local", " a@x "], by="admin@x")
|
||||
self.st.set_role_members("receive", ["w@x"], by="admin@x")
|
||||
self.assertEqual(self.st.list_roles()["order"], ["a@x", "boss@test.local"])
|
||||
self.assertEqual(self.st.roles_of("BOSS@test.local"), {"order"})
|
||||
self.st.set_role_members("order", ["a@x"], by="admin@x") # 통째로 바꿈
|
||||
self.assertEqual(self.st.list_roles()["order"], ["a@x"])
|
||||
with self.assertRaisesRegex(ValueError, "같은 이름"):
|
||||
self.st.save_factory(factory_id=None, name=f"테스트공장-{self.tag}".upper())
|
||||
with self.assertRaisesRegex(ValueError, "발주 기록"):
|
||||
self.order([("MT-L", 1)])
|
||||
self.st.delete_factory(self.fid)
|
||||
fid2 = self.st.save_factory(factory_id=None, name=f"빈공장-{self.tag}")
|
||||
self.st.delete_factory(fid2)
|
||||
self.assertNotIn(fid2, [f["id"] for f in self.st.list_factories(include_inactive=True)])
|
||||
off = self.st.save_factory(factory_id=None, name=f"숨김공장-{self.tag}", is_active=False)
|
||||
self.assertNotIn(off, [f["id"] for f in self.st.list_factories()])
|
||||
with self.assertRaisesRegex(ValueError, "사용하지 않는 공장"):
|
||||
self.order([("MT-M", 1)], factory_id=off)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,89 @@
|
||||
"""입출고 관리 — 상태 계산·입력 검사(순수 함수, DB 없음)."""
|
||||
import unittest
|
||||
from datetime import date
|
||||
|
||||
from app.modules.inout import store as s
|
||||
|
||||
|
||||
class StatusTests(unittest.TestCase):
|
||||
def test_line_status(self):
|
||||
self.assertEqual([s.line_status(10, r) for r in (0, 4, 10, 12)], ["none", "partial", "done", "over"])
|
||||
|
||||
def test_order_status(self):
|
||||
L = lambda *pairs: [{"qty": q, "received": r} for q, r in pairs] # noqa: E731
|
||||
self.assertEqual(s.order_status(L((10, 0), (5, 0))), "open")
|
||||
self.assertEqual(s.order_status(L((10, 10), (5, 0))), "partial") # 하나라도 남으면 부분입고
|
||||
self.assertEqual(s.order_status(L((10, 12), (5, 3))), "partial") # 초과가 있어도 남은 게 있으면 부분입고
|
||||
self.assertEqual(s.order_status(L((10, 10), (5, 5))), "done")
|
||||
self.assertEqual(s.order_status(L((10, 11), (5, 5))), "over")
|
||||
self.assertEqual(s.order_status(L((10, 3)), closed=True), "closed")
|
||||
self.assertEqual(s.order_status(L((10, 3)), closed=True, cancelled=True), "cancelled")
|
||||
self.assertEqual(s.order_status([]), "open")
|
||||
|
||||
def test_summarize_never_negative(self):
|
||||
out = s.summarize([{"qty": 10, "received": 12}, {"qty": 5, "received": 1}])
|
||||
self.assertEqual(out, {"ordered": 15, "received": 13, "remaining": 4, "over": 2, "pct": 87})
|
||||
self.assertEqual(s.summarize([{"qty": 1, "received": 5}])["pct"], 100) # 막대는 100% 에서 멈춤
|
||||
self.assertEqual(s.summarize([])["pct"], 0)
|
||||
|
||||
def test_order_no(self):
|
||||
self.assertEqual(s.order_no(date(2026, 10, 6), 3), "PO-261006-03")
|
||||
self.assertEqual(s.order_no(date(2026, 10, 6), 123), "PO-261006-123")
|
||||
|
||||
|
||||
class ValidateOrderTests(unittest.TestCase):
|
||||
def v(self, **over):
|
||||
args = dict(factory_id="1", order_date="2026-10-16", due_date="2026-10-30", memo=" 메모 ",
|
||||
codes=["mt-a ", "", "MT-B"], quantities=["1,200", "", "5"], line_memos=["a", "", ""])
|
||||
args.update(over)
|
||||
return s.validate_order(**args)
|
||||
|
||||
def test_ok_normalizes(self):
|
||||
d = self.v()
|
||||
self.assertEqual(d["factory_id"], 1)
|
||||
self.assertEqual(d["memo"], "메모")
|
||||
self.assertEqual([(x["item_code"], x["qty"], x["memo"]) for x in d["lines"]], [("MT-A", 1200, "a"), ("MT-B", 5, "")])
|
||||
|
||||
def test_errors_listed_together(self):
|
||||
with self.assertRaises(ValueError) as ctx:
|
||||
self.v(factory_id="", due_date="2026-10-01", codes=["MT-A", "mt-a", ""], quantities=["0", "3", "7"])
|
||||
msg = str(ctx.exception)
|
||||
for part in ("공장을 고르세요", "입고 예정일이 발주일보다 빠릅니다", "1 이상", "같은 제품이 두 줄", "3번째 줄: 제품을 고르세요"):
|
||||
self.assertIn(part, msg)
|
||||
|
||||
def test_empty_and_bad_values(self):
|
||||
with self.assertRaisesRegex(ValueError, "한 줄 이상"):
|
||||
self.v(codes=["", ""], quantities=["", ""])
|
||||
with self.assertRaisesRegex(ValueError, "정수"):
|
||||
self.v(codes=["MT-A"], quantities=["1.5"])
|
||||
with self.assertRaisesRegex(ValueError, "너무 큽니다"):
|
||||
self.v(codes=["MT-A"], quantities=[str(s.MAX_QTY + 1)])
|
||||
with self.assertRaisesRegex(ValueError, "발주일 형식"):
|
||||
self.v(order_date="16/10/2026")
|
||||
self.assertIsNone(self.v(due_date="")["due_date"])
|
||||
|
||||
|
||||
class ValidateReceiptTests(unittest.TestCase):
|
||||
LINES = [{"id": 1, "item_code": "MT-A", "item_name": "가", "qty": 10, "received": 8},
|
||||
{"id": 2, "item_code": "MT-B", "item_name": "나", "qty": 5, "received": 0}]
|
||||
|
||||
def test_partial_zero_and_over(self):
|
||||
d = s.validate_receipt(self.LINES, {1: "3", 2: "0"}, receipt_date="2026-10-20", memo="")
|
||||
self.assertEqual(d["items"], [{"order_line_id": 1, "qty": 3}]) # 0·빈칸은 이번에 안 들어온 것
|
||||
self.assertEqual(d["over"], [{"item_code": "MT-A", "item_name": "가", "ordered": 10, "after": 11, "over": 1}])
|
||||
d = s.validate_receipt(self.LINES, {1: "2", 2: ""}, receipt_date="2026-10-20", memo="")
|
||||
self.assertEqual(d["over"], []) # 딱 맞으면 초과 아님
|
||||
|
||||
def test_errors(self):
|
||||
with self.assertRaisesRegex(ValueError, "한 품목 이상"):
|
||||
s.validate_receipt(self.LINES, {1: "", 2: "0"}, receipt_date="2026-10-20", memo="")
|
||||
with self.assertRaisesRegex(ValueError, "없는 품목"):
|
||||
s.validate_receipt(self.LINES, {99: "1"}, receipt_date="2026-10-20", memo="")
|
||||
with self.assertRaisesRegex(ValueError, "입고일"):
|
||||
s.validate_receipt(self.LINES, {1: "1"}, receipt_date="", memo="")
|
||||
with self.assertRaisesRegex(ValueError, "0 이상"): # 입고는 0(이번에 안 옴)까지 허용
|
||||
s.validate_receipt(self.LINES, {1: "-1"}, receipt_date="2026-10-20", memo="")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,185 @@
|
||||
"""입출고 관리 — 실제 앱(메뉴·권한·화면·폼)을 격리된 하위 프로세스에서 확인.
|
||||
|
||||
1) 등록·미설정: 메뉴·관리자 권한 칩·"설정 필요" 화면(DB 없이 늘 실행)
|
||||
2) 전체 흐름(INOUT_TEST_DB_URL 이 localhost 일 때만): 옵션(공장·담당자) → 발주 담당 발주서 작성(코드표 단품만)
|
||||
→ 입고 담당 분할 입고 → 초과 입고 확인 → 미입고 현황 → 잔량 종결, 그리고 권한(조회만·담당 아님 403).
|
||||
코드표(itemcode_db)는 가짜 리더로 바꾼다. 운영 DSN·데이터는 쓰지 않는다.
|
||||
"""
|
||||
import os
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
from urllib.parse import urlparse
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
DSN = os.getenv("INOUT_TEST_DB_URL", "")
|
||||
DB_ENABLED = bool(DSN) and urlparse(DSN).hostname in ("localhost", "127.0.0.1")
|
||||
|
||||
PRELUDE = '''
|
||||
from unittest.mock import patch
|
||||
from fastapi.testclient import TestClient
|
||||
import app.main as main
|
||||
|
||||
def U(email, role="user", inout=True):
|
||||
return {"email": email, "name": email.split("@")[0], "role": role, "is_super_admin": False,
|
||||
"modules": {"inout": inout}}
|
||||
|
||||
who = {"u": None}
|
||||
users = []
|
||||
|
||||
class Items:
|
||||
enabled = True
|
||||
reason = ""
|
||||
NAMES = {"MT-A": "가 단품", "MT-B": "나 단품", "MT-C": "다 단품"}
|
||||
def search(self, q, limit=30):
|
||||
return [{"code": c, "name": n} for c, n in self.NAMES.items() if q.upper() in c or q in n]
|
||||
def lookup(self, codes):
|
||||
return {c: self.NAMES[c] for c in codes if c in self.NAMES}
|
||||
|
||||
def run(body):
|
||||
with patch.object(main, "get_current_user_record", side_effect=lambda r: who["u"]), \\
|
||||
patch.object(main, "get_session_user", side_effect=lambda r: who["u"]), \\
|
||||
patch.object(main.user_store, "get", side_effect=lambda e: who["u"]), \\
|
||||
patch.object(main.user_store, "list_all", side_effect=lambda: users):
|
||||
client = TestClient(main.app)
|
||||
body(client)
|
||||
'''
|
||||
|
||||
|
||||
def _run(code: str, extra_env: dict[str, str] | None = None) -> subprocess.CompletedProcess:
|
||||
env = dict(os.environ)
|
||||
for key in ("ASSET", "CAFE24", "CUPANG", "VACATION", "PROJECT", "DISPATCH", "PERFORMANCE", "MALAYSIA_STOCK",
|
||||
"ITEMCODE", "EXPENSE", "INOUT"):
|
||||
env[key + "_DB_URL"] = ""
|
||||
env.update(SESSION_SECRET_KEY="local-inout-test-only", SESSION_COOKIE_SECURE="false", PERFORMANCE_AUTO_SYNC="false")
|
||||
env.update(extra_env or {})
|
||||
with tempfile.TemporaryDirectory(prefix="inout-web-") as directory:
|
||||
env["DATA_DIR"] = directory
|
||||
return subprocess.run([sys.executable, "-c", PRELUDE + code], cwd=ROOT, env=env, capture_output=True,
|
||||
text=True, encoding="utf-8", timeout=90)
|
||||
|
||||
|
||||
class InoutWebTests(unittest.TestCase):
|
||||
def test_registered_and_unconfigured(self):
|
||||
res = _run('''
|
||||
from app.store import MODULE_KEYS
|
||||
admin = U("admin@test.local", role="admin")
|
||||
users.append(admin)
|
||||
who["u"] = admin
|
||||
def body(c):
|
||||
assert "inout" in MODULE_KEYS
|
||||
assert main.MODULE_LABELS["inout"] == "입출고 관리"
|
||||
assert any(x["key"] == "inout" and x["active"] for x in main.build_erp_nav(admin, active="inout"))
|
||||
assert "입출고 관리" in c.get("/admin").text # 관리자 화면 권한 칩
|
||||
r = c.get("/inout/")
|
||||
assert r.status_code == 503 and "INOUT_DB_URL" in r.text, r.status_code # DB 미설정 = 설정 필요 안내
|
||||
assert c.get("/inout/health").json() == {"status": "not_configured"}
|
||||
who["u"] = U("nobody@test.local", inout=False)
|
||||
assert c.get("/inout/").status_code == 403 # 모듈 권한 없음
|
||||
print("OK")
|
||||
run(body)
|
||||
''')
|
||||
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
|
||||
self.assertIn("OK", res.stdout)
|
||||
|
||||
@unittest.skipUnless(DB_ENABLED, "INOUT_TEST_DB_URL(localhost) not set")
|
||||
def test_full_flow(self):
|
||||
res = _run('''
|
||||
import re, uuid
|
||||
from app.modules.inout.db import InoutDBStore
|
||||
main.app.state.inout_store = InoutDBStore(__import__("os").environ["INOUT_TEST_DB_URL"])
|
||||
main.app.state.inout_items = Items()
|
||||
tag = uuid.uuid4().hex[:6]
|
||||
admin, buyer, wh, viewer = (U("admin-%s@t.local" % tag, role="admin"), U("buyer-%s@t.local" % tag),
|
||||
U("wh-%s@t.local" % tag), U("viewer-%s@t.local" % tag))
|
||||
users.extend([admin, buyer, wh, viewer])
|
||||
|
||||
def body(c):
|
||||
# ── 옵션: 공장·담당자(관리자만) ──
|
||||
who["u"] = buyer
|
||||
assert c.get("/inout/settings").status_code == 403
|
||||
who["u"] = admin
|
||||
page = c.get("/inout/settings")
|
||||
assert page.status_code == 200 and buyer["email"] in page.text and "발주 담당" in page.text
|
||||
r = c.post("/inout/settings/factories", data={"name": "공장-" + tag, "contact": "김 010", "is_active": "1"},
|
||||
follow_redirects=False)
|
||||
assert r.status_code == 303 and "msg=" in r.headers["location"]
|
||||
fid = re.search(r'name="id" value="(\\d+)" />\\s*<input class="erp-input" type="text" name="name" value="공장-%s"' % tag,
|
||||
c.get("/inout/settings").text).group(1)
|
||||
c.post("/inout/settings/roles", data={"order_email": [buyer["email"]], "receive_email": [wh["email"]]})
|
||||
st = main.app.state.inout_store
|
||||
assert st.roles_of(buyer["email"]) == {"order"} and st.roles_of(wh["email"]) == {"receive"}
|
||||
|
||||
# ── 조회만 하는 사람 ──
|
||||
who["u"] = viewer
|
||||
assert c.get("/inout/").status_code == 200
|
||||
assert c.get("/inout/orders/new").status_code == 403
|
||||
assert "조회만 가능" in c.get("/inout/").text
|
||||
|
||||
# ── 발주 담당: 발주서(코드표 단품만) ──
|
||||
who["u"] = buyer
|
||||
form = c.get("/inout/orders/new").text
|
||||
assert "공장-" + tag in form and "새 발주서" in form
|
||||
bad = c.post("/inout/orders/new", data={"factory_id": fid, "order_date": "2026-10-16", "due_date": "2026-10-20",
|
||||
"item_code": ["MT-A", "ZZ-9"], "item_name": ["", ""], "qty": ["100", "5"], "line_memo": ["", ""]})
|
||||
assert bad.status_code == 400 and "코드표 단품에 없는 제품입니다: ZZ-9" in bad.text and 'value="ZZ-9"' in bad.text
|
||||
r = c.post("/inout/orders/new", data={"factory_id": fid, "order_date": "2026-10-16", "due_date": "2026-10-20",
|
||||
"memo": "1차", "item_code": ["mt-a", "MT-B", ""], "item_name": ["", "", ""], "qty": ["1,00", "50", ""],
|
||||
"line_memo": ["", "포장 주의", ""]}, follow_redirects=False)
|
||||
assert r.status_code == 303, r.text[:300]
|
||||
oid = int(re.search(r"/inout/orders/(\\d+)", r.headers["location"]).group(1))
|
||||
detail = c.get(r.headers["location"]).text
|
||||
assert "가 단품" in detail and "포장 주의" in detail and "PO-261016-" in detail and "발주서 PO-261016-" in detail
|
||||
assert "이번 입고" not in detail # 발주 담당은 입고 칸이 없다
|
||||
assert c.post("/inout/orders/%d/receipts" % oid, data={"receipt_date": "2026-10-17"}).status_code == 403
|
||||
|
||||
# ── 입고 담당: 분할 입고 → 초과 확인 ──
|
||||
who["u"] = wh
|
||||
detail = c.get("/inout/orders/%d" % oid).text
|
||||
ids = dict(zip(re.findall(r'aria-label="(MT-[AB]) 이번 입고', detail), re.findall(r'name="qty_(\\d+)"', detail)))
|
||||
r = c.post("/inout/orders/%d/receipts" % oid, data={"receipt_date": "2026-10-17", "memo": "1차 트럭",
|
||||
"qty_" + ids["MT-A"]: "60"}, follow_redirects=False)
|
||||
assert r.status_code == 303
|
||||
page = c.get("/inout/orders/%d" % oid).text
|
||||
assert "부분입고" in page and "1차 트럭" in page
|
||||
over = c.post("/inout/orders/%d/receipts" % oid, data={"receipt_date": "2026-10-18", "qty_" + ids["MT-A"]: "45",
|
||||
"qty_" + ids["MT-B"]: "50"})
|
||||
assert over.status_code == 409 and "초과 입고로 저장" in over.text and "+5" in over.text
|
||||
assert 'value="45"' in over.text # 넣은 숫자는 그대로
|
||||
assert st.get_order(oid)["summary"]["received"] == 60 # 확인 전엔 저장 안 됨
|
||||
r = c.post("/inout/orders/%d/receipts" % oid, data={"receipt_date": "2026-10-18", "qty_" + ids["MT-A"]: "45",
|
||||
"qty_" + ids["MT-B"]: "50", "confirm_over": "1"}, follow_redirects=False)
|
||||
assert r.status_code == 303 and "%EC%B4%88%EA%B3%BC" in r.headers["location"] # "초과 입고 포함" 안내
|
||||
got = st.get_order(oid)
|
||||
assert (got["status"], got["summary"]["over"]) == ("over", 5)
|
||||
pend = c.get("/inout/pending").text
|
||||
assert "초과 입고" in pend and got["order_no"] in pend
|
||||
|
||||
# ── 두 번째 발주: 미입고 현황 → 잔량 종결 ──
|
||||
who["u"] = buyer
|
||||
r = c.post("/inout/orders/new", data={"factory_id": fid, "order_date": "2026-10-16", "item_code": ["MT-C"],
|
||||
"item_name": [""], "qty": ["30"], "line_memo": [""]}, follow_redirects=False)
|
||||
oid2 = int(re.search(r"/inout/orders/(\\d+)", r.headers["location"]).group(1))
|
||||
pend = c.get("/inout/pending?q=MT-C").text
|
||||
assert "다 단품" in pend and "30" in pend
|
||||
assert "제품별 미입고 합계" in pend
|
||||
lst = c.get("/inout/?status=active&q=MT-C").text
|
||||
assert st.get_order(oid2)["order_no"] in lst
|
||||
c.post("/inout/orders/%d/close" % oid2, data={"reason": "단종"})
|
||||
assert st.get_order(oid2)["status"] == "closed"
|
||||
assert st.get_order(oid2)["order_no"] not in c.get("/inout/pending?q=MT-C").text
|
||||
assert st.get_order(oid2)["order_no"] in c.get("/inout/?status=closed&q=MT-C").text
|
||||
|
||||
# ── 단품 검색 API ──
|
||||
assert c.get("/inout/api/items?q=MT-").json()["items"][0]["code"] == "MT-A"
|
||||
print("OK")
|
||||
run(body)
|
||||
''', {"INOUT_TEST_DB_URL": DSN})
|
||||
self.assertEqual(res.returncode, 0, res.stdout + res.stderr)
|
||||
self.assertIn("OK", res.stdout)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user