From 207be5bd71d61275f504be8d414548f761905333 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Sun, 15 Nov 2026 16:40:08 +0900 Subject: [PATCH] =?UTF-8?q?feat(840-4):=20=EB=82=B4=20=EC=9E=AC=EB=A3=8C?= =?UTF-8?q?=20=3D=20=EC=9E=AC=EB=A3=8C=20DB(M01)=EC=97=90=20=EC=97=86?= =?UTF-8?q?=EB=8A=94=20=EC=9E=90=EC=9E=AC=EB=A5=BC=20=EB=93=B1=EB=A1=9D?= =?UTF-8?q?=ED=95=98=EB=8A=94=20=EC=9E=90=EB=A6=AC=20=E2=80=94=20=EA=B0=9C?= =?UTF-8?q?=EC=9D=B8=EA=B4=80=EB=A6=AC=20=E2=80=BA=20=EC=9E=90=EC=9E=AC=20?= =?UTF-8?q?=EB=93=B1=EB=A1=9D=20=EC=B9=B8(=EB=A7=8C=EB=93=A4=EA=B8=B0=20?= =?UTF-8?q?=C2=B7=20=EA=B3=A0=EC=B9=98=EA=B8=B0=20=C2=B7=20=EC=A7=80?= =?UTF-8?q?=EC=9A=B0=EA=B8=B0)=20=C2=B7=20M01=20=EA=B3=BC=20=EA=B0=99?= =?UTF-8?q?=EC=9D=80=20=EC=9D=B4=EB=A6=84=20=C2=B7=20=EA=B7=9C=EA=B2=A9=20?= =?UTF-8?q?=C2=B7=20=EB=8B=A8=EC=9C=84=20=EB=A7=89=EC=9D=8C=20=C2=B7=20?= =?UTF-8?q?=EB=8B=A8=EA=B0=80=EC=82=B0=EC=B6=9C=20=EC=9E=AC=EB=A3=8C=20?= =?UTF-8?q?=EA=B3=A0=EB=A5=B4=EA=B8=B0=20=E3=80=8C=EB=82=B4=20=EC=9E=AC?= =?UTF-8?q?=EB=A3=8C=E3=80=8D=20=C2=B7=20=EA=B0=92=20=EB=B0=94=EA=BE=B8?= =?UTF-8?q?=EB=A9=B4=20=EC=9E=90=EB=8F=99=20=EB=94=B0=EB=9D=BC=EC=98=B4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 서버 `M02_Material_Own`: M01 자재품목과 이름 · 규격 · 단위 같음 = 409(빈칸 · 대소문자 · ㎏ = kg 무시) · 고치기 · 지우기(쓰는 곳 있으면 409 · 밑줄 폴더 보관본 뺌) · 목록 줄마다 쓰는 곳 - 셈 색인: 단가산출 사본 색인 · 사본 모으기 · 빈틈 채우기에 내 재료 줄을 내 기계처럼 얹음 → 개인 층 단가산출은 값 바뀌면 836-2 길로 따라옴 · 프로젝트 층 = 사본 값 - 화면: 개인관리 › 자재 위 「내 재료」 표 + 고침 칸(`M02_MyMaterial_View` · `M02_MyMaterial_Api`) · 아래 「값을 바로 적은 재료」 모아 보기는 읽기 그대로 · 찾아 넣기 재료 탭 M01 위 「내 재료」 묶음(줄 쌓기 개인 층) - M01 재료를 본떠 값만 바꾼 내 재료를 만드는 길 = 없었음(걷을 것 없음) 낡은 시험 고침: test_m02_material_own 목록 줄에 「쓰는곳」 칸 Co-Authored-By: Claude Opus 5.5 --- A00_Common/line_stack_pick.ts | 2 + M02_MasterTemplete/M02_Doc_Gap.py | 7 +- M02_MasterTemplete/M02_Item_Prices.py | 8 +- M02_MasterTemplete/M02_Labor_Router.py | 37 +++- .../M02_MasterTemplete_Find_Pick.ts | 22 +++ M02_MasterTemplete/M02_Material_Own.py | 146 +++++++++++++- M02_MasterTemplete/M02_MyItems_View.ts | 3 + M02_MasterTemplete/M02_MyMachine_Text.ts | 2 +- M02_MasterTemplete/M02_MyMaterial_Api.ts | 45 +++++ M02_MasterTemplete/M02_MyMaterial_View.ts | 185 ++++++++++++++++++ M02_MasterTemplete/M02_Sangeun_Copy.py | 5 +- resources/tester/test_840_4_my_material.py | 78 ++++++++ resources/tester/test_m02_material_own.py | 2 +- ui_template/ui_template_locale_m2.ts | 1 + 14 files changed, 527 insertions(+), 16 deletions(-) create mode 100644 M02_MasterTemplete/M02_MyMaterial_Api.ts create mode 100644 M02_MasterTemplete/M02_MyMaterial_View.ts create mode 100644 resources/tester/test_840_4_my_material.py diff --git a/A00_Common/line_stack_pick.ts b/A00_Common/line_stack_pick.ts index 4dbc376b0..c9db700a0 100644 --- a/A00_Common/line_stack_pick.ts +++ b/A00_Common/line_stack_pick.ts @@ -4,6 +4,7 @@ * 찾아 넣기 = M02 [항목 추가] 창 그대로(`openFindPicker` · 탭 M01 전체 · 찾기 칸 · 표) — 줄 갈래마다 그 종류만 * 인력(노임 LB) · 재료(자재 MT) · 기계(EQ → 시간당 경비 로직 + 기계='원문번호') · 다른 단가산출(M01 단가산출 로직) * 기계 + M02 개인 층(821-3) = 품셈 기계 위 「내 기계」 묶음 · 머리 [새 기계 만들기] — 고름 = 로직 + 기계='개인 EQP…' + * 재료 + M02 개인 층(840-4) = M01 재료 위 「내 재료」 묶음 — 고름 = 요소 PM 키(M01 재료와 같은 꼴) * M01 단가산출 기초 줄 쌓기 = 「M01 전체」 탭만 — M01 은 원천 기준값이라 M02 단가산출 · 일위대가를 부르지 않음(요구 680-1) * M02 단가산출 줄 쌓기(`take` 있음) · 다른 단가산출 = 탭 [M01 전체 | M02 단가산출 | 일위대가](위 층 · 자기 SK 뺌) — * 고름 = 복사해 펼침(`take(src)` · src = M01 키 | `참조|층|주인|키`) · 참조 줄 없음(요구 681) @@ -58,6 +59,7 @@ export function openStackPick( title: `${lt("Find_Title")} — ${lt(copy ? "K_복사" : (`K_${kind}` as never))}`, kinds: copy ? ["logic", "sk", "pre"] : [want], // M01 = M01 전체만(680-1) mine: kind === "기계" && m02?.layer === "personal" ? { owner: m02.owner } : undefined, + mineMat: kind === "재료" && m02?.layer === "personal" ? { owner: m02.owner } : undefined, // 840-4 내 재료 query: query.trim() || undefined, ref: copy ? (r) => diff --git a/M02_MasterTemplete/M02_Doc_Gap.py b/M02_MasterTemplete/M02_Doc_Gap.py index af21c0afc..1e20667d3 100644 --- a/M02_MasterTemplete/M02_Doc_Gap.py +++ b/M02_MasterTemplete/M02_Doc_Gap.py @@ -12,6 +12,7 @@ from __future__ import annotations from typing import Any from M02_MasterTemplete import M02_Doc_Copy as dc +from M02_MasterTemplete import M02_Material_Own as own from M02_MasterTemplete import M02_MyMachine as mym from M02_MasterTemplete import M02_Sangeun_Copy as skc @@ -46,7 +47,7 @@ def _have(copy: dict) -> set[str]: def gaps(copy: dict) -> list[str]: - """값 사본에 없는데 문서 셈이 읽은 M01 줄 키 + 문서의 내 기계 키(셈 틀림 = 읽은 데까지).""" + """값 사본에 없는데 문서 셈이 읽은 M01 줄 키 + 문서의 내 기계 · 내 재료(840-4) 키(셈 틀림 = 읽은 데까지).""" if "로직" not in copy or not isinstance(copy.get("문서"), dict): return [] seen = _Seen(dc.over(copy)) @@ -55,7 +56,7 @@ def gaps(copy: dict) -> list[str]: except dc._ERR: pass have = _have(copy) - return sorted({*seen.keys, *mym.keys_in(copy["문서"])} - have) + return sorted({*seen.keys, *mym.keys_in(copy["문서"]), *own.keys_in(copy["문서"])} - have) def fill(copy: dict) -> dict: @@ -76,7 +77,7 @@ def fill_imported(sk: dict, doc: Any) -> dict: return sk seen = _Seen(dim._index(sk, None, doc)) dim.run(doc, sk, index=seen) # 셈 틀림 = 읽은 데까지(run 이 받음) - keys = sorted({*seen.keys, *mym.keys_in(doc)} - _have(sk[skc.KEY])) + keys = sorted({*seen.keys, *mym.keys_in(doc), *own.keys_in(doc)} - _have(sk[skc.KEY])) if not keys: return sk return {**sk, skc.KEY: skc.grow(sk[skc.KEY], skc.snap([], keys))} diff --git a/M02_MasterTemplete/M02_Item_Prices.py b/M02_MasterTemplete/M02_Item_Prices.py index 1c3c33176..4a53c9aa9 100644 --- a/M02_MasterTemplete/M02_Item_Prices.py +++ b/M02_MasterTemplete/M02_Item_Prices.py @@ -241,8 +241,12 @@ def collect( `extra` = 마스터 밖 로직 줄(굳힌 단가산출 719-1) — 그 줄이 닿는 것만 모음(줄은 안 담음) · `over` = M02 로직 사본 줄(795-4) — 같은 키는 M01 줄 대신 · M01 에 없는 키 = `COPY_FILE`.""" files, whole = master() - whole = mym.whole(whole) # 지금 층 내 기계 줄(821-1) — 없으면 M01 그대로 - own = {str(r.get("키")): r for r in mym.added(whole)} + from M02_MasterTemplete import M02_Material_Own as mat + + whole = mat.whole( + mym.whole(whole) + ) # 지금 층 내 기계(821-1) · 내 재료(840-4) — 없으면 M01 그대로 + own = {str(r.get("키")): r for r in (*mym.added(whole), *mat.added(whole))} mine = {str(r.get("키")): r for r in over or []} if mine: from M02_MasterTemplete import M02_Sangeun_Copy as skc diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py index 5db9ebb66..bcf92e6da 100644 --- a/M02_MasterTemplete/M02_Labor_Router.py +++ b/M02_MasterTemplete/M02_Labor_Router.py @@ -196,10 +196,13 @@ def own_materials( owner: str | None = None, session: Session = Depends(verify_session), ) -> dict: - """개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록.""" + """개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록 · 줄마다 쓰는 곳(840-4).""" if layer != "personal": return {"줄": []} - return {"줄": own.rows(_root(session, layer, owner))} + folder = _root(session, layer, owner) + rows = own.rows(folder) + used = own.usage(folder, [str(r.get("키")) for r in rows]) + return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]} @router.post("/layers/{layer}/materials") @@ -215,3 +218,33 @@ def new_material( raise HTTPException(status_code=400, detail="신규 자재는 개인 층에서만") folder = _root(session, layer, owner, write=True) return _call(folder, own.add, folder, body) + + +@router.put("/layers/{layer}/materials/{key}") +def edit_material( + layer: Layer, + key: str, + body: dict[str, Any], + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """내 재료 고침(840-4) — `{이름, 규격, 단위, 값}` · 키 그대로 · 개인 층만.""" + if layer != "personal": + raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") + folder = _root(session, layer, owner, write=True) + return _call(folder, own.update, folder, key, body) + + +@router.delete("/layers/{layer}/materials/{key}") +def drop_material( + layer: Layer, + key: str, + owner: str | None = None, + session: Session = Depends(verify_session), +) -> dict: + """내 재료 지움(840-4) — 쓰는 곳 있으면 409 · 개인 층만.""" + if layer != "personal": + raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만") + folder = _root(session, layer, owner, write=True) + _call(folder, own.remove, folder, key) + return {"ok": True} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts index c6e0e57dd..45ebc0f92 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Find_Pick.ts @@ -28,6 +28,7 @@ import { t as L } from "@ui/ui_template_locale"; import { aliasNote, matchLogic } from "@ui/ui_template_logic_find"; import { openNewMaterial } from "./M02_Material_Pick"; import { listMyMachines, mineElement, type MyMachineRow } from "./M02_MyMachine_Api"; +import { listMyMaterials, type MyMaterial } from "./M02_MyMaterial_Api"; import { mt } from "./M02_MyMachine_Text"; import { openModal } from "@ui/ui_template_modal"; import { createTabs } from "@ui/ui_template_tabs"; @@ -91,6 +92,8 @@ export interface FindPickOptions { oil?: (e: M01Element) => void; /** 821-3 개인 층 내 기계 묶음(`machine` 과 함께) — 주인(null = 자기 층) */ mine?: { owner: string | null }; + /** 840-4 개인 층 내 재료(PM) 묶음 — 재료 고름 위 · 주인(null = 자기 층) */ + mineMat?: { owner: string | null }; } /** 727-1 기초마다 한 줄(옛 창 `Labor_Pick` 도 씀) — 규격 칸 = 「옵션 N」 */ @@ -194,6 +197,7 @@ export function openFindPicker(opt: FindPickOptions): void { let machines: PickItem[] = []; let oils: PickItem[] = []; // 785-3 유가전력 MO let mines: MyMachineRow[] = []; // 821-3 내 기계 + let mats: MyMaterial[] = []; // 840-4 내 재료 const lists: Record<"sk" | "pre", SangeunRow[] | null> = { sk: null, pre: null }; let shown: Line[] = []; let seq = 0; @@ -312,6 +316,16 @@ export function openFindPicker(opt: FindPickOptions): void { }; }); }; + /** 840-4 내 재료 줄 — M01 재료처럼 고름(코드 = PM 키 · 값 = 내 목록 값) */ + const matLines = (q: string): Line[] => { + const words = q.toLowerCase().split(/\s+/).filter(Boolean); + return elementLines( + "재료", + mats + .filter((r) => words.every((w) => `${r.이름} ${r.규격} ${r.키}`.toLowerCase().includes(w))) + .map((r) => ({ ref: r.키, 구분: L("M02_FindMyMaterial"), ...r })), + ).map((x) => ({ ...x, 출처: x.출처.replace(/^M01 /, "") })); + }; const docLines = (rows: SangeunRow[], kind: string): Line[] => rows.map((x) => ({ 품명: x.제목 || x.이름, @@ -329,6 +343,7 @@ export function openFindPicker(opt: FindPickOptions): void { shown = [ ...(ok("logic") ? logicLines(q) : []), ...(ok("labor") ? elementLines("인력", people) : []), + ...(opt.mineMat && ok("material") ? matLines(q) : []), ...(ok("material") ? elementLines("재료", goods) : []), ...(opt.oil && ok("oil") ? elementLines("유가", oils) : []), ...(opt.machine && opt.mine && ok("machine") ? mineLines(q) : []), @@ -456,6 +471,13 @@ export function openFindPicker(opt: FindPickOptions): void { draw(); }) .catch(fail); + if (opt.mineMat && ok("material")) + void listMyMaterials(opt.mineMat.owner) + .then((rows) => { + mats = rows; + draw(); + }) + .catch(fail); void upper(opt.layer, opt.owner) .then((scopes) => Promise.all( diff --git a/M02_MasterTemplete/M02_Material_Own.py b/M02_MasterTemplete/M02_Material_Own.py index 3eb6bab69..b5885a4cb 100644 --- a/M02_MasterTemplete/M02_Material_Own.py +++ b/M02_MasterTemplete/M02_Material_Own.py @@ -6,12 +6,16 @@ `master_material.element`). 품번 = `PM` + 6자리 — 모든 사람 통틀어 한 줄 번호(모든 개인 층 파일 가장 큰 번호 + 1 · `store._LOCK` 안 · 화면이 보낸 키는 안 받음). 신규 자재는 개인 층에서만 (회사 · 마스터 층 = 마스터 자재만). +840-4 내 재료 = M01 재료 DB 에 없는 자재를 등록하는 자리 — M01 과 이름 · 규격 · 단위가 같으면 막음(409) · +고치기 · 지우기(쓰는 곳 있으면 막음) · 단가산출 셈 색인에 M01 재료처럼 얹음(`whole` · `M02_Sangeun_Copy.whole_`) +→ 프로젝트 층 밖 SK 는 값이 바뀌면 자동 따라옴(836-2 `M02_Sk_AutoRenew`) · 프로젝트 층 = 사본 값. """ from __future__ import annotations import json import re +import unicodedata from pathlib import Path from typing import Any @@ -22,6 +26,7 @@ from M02_MasterTemplete import M02_Template_Layers as layers FILE = "개인자재.json" PREFIX = "PM" KEY = re.compile(rf"^{PREFIX}(\d{{6}})$") +FIND = re.compile(rf"(? float | int | None: return int(got) if got.is_integer() else got -def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]: - """새 개인 자재 한 줄 → 그 줄(키는 서버) · 품명 · 단위 빈 = 400 · - 같은 품명 + 규격 + 단위 = 409.""" +def _norm(v: Any) -> str: + """빈칸 · 대소문자 · 겹낱자(㎏ = kg · ㎥ = m3) 무시.""" + return unicodedata.normalize("NFKC", " ".join(_text(v).split())).lower() + + +def m01_same(row: dict[str, Any]) -> dict[str, Any] | None: + """M01 재료 DB(자재품목 MT)에서 이름 · 규격 · 단위가 같은 줄(빈칸 · 대소문자 무시).""" + from M01_MasterData import M01_MasterData_Store as m01 + + want = tuple(_norm(row.get(k)) for k in COLS) + for r in (m01.loaded()[1].index.get("MT") or {}).values(): + if tuple(_norm(r.get(k)) for k in COLS) == want: + return r + return None + + +def _checked(body: dict[str, Any], others: list[dict[str, Any]]) -> dict[str, Any]: + """품명 · 단위 빈 = 400 · 내 목록 같은 줄 · M01 재료 DB 같은 줄 = 409.""" row = {k: _text(body.get(k)) for k in COLS} if not row["이름"] or not row["단위"]: raise store.StoreError(400, "품명 · 단위는 꼭 적음") row["값"] = _value(body.get("값")) + if any(all(_norm(x.get(k)) == _norm(row[k]) for k in COLS) for x in others): + raise store.StoreError(409, f"이미 있는 자재 「{row['이름']} {row['규격']}」") + if m01_same(row): + raise store.StoreError( + 409, + f"재료 DB 에 있는 자재 「{row['이름']} {row['규격']}」 — 재료 DB 자재를 고르고 " + "값은 단가산출 안 재료 줄에서 바꿈", + ) + return row + + +def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]: + """새 개인 자재 한 줄 → 그 줄(키는 서버) · 품명 · 단위 빈 = 400 · + 같은 품명 + 규격 + 단위(내 목록 · M01 재료 DB) = 409.""" with store._LOCK: doc = read(folder) - if any(all(_text(x.get(k)) == row[k] for k in COLS) for x in doc["줄"]): - raise store.StoreError(409, f"이미 있는 자재 「{row['이름']} {row['규격']}」") + row = _checked(body, doc["줄"]) got = {"키": f"{PREFIX}{_last() + 1:06d}", **row} doc["줄"].append(got) atomic_write_json(Path(folder) / FILE, doc) return got +def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]: + """내 재료 한 줄 고침(키 그대로) — 없는 키 = 404 · 검사는 새로 만들기와 같음.""" + with store._LOCK: + doc = read(folder) + at = next((i for i, r in enumerate(doc["줄"]) if r.get("키") == key), None) + if at is None: + raise store.StoreError(404, f"없는 내 재료 「{key}」") + row = _checked(body, [r for i, r in enumerate(doc["줄"]) if i != at]) + doc["줄"][at] = got = {"키": key, **row} + atomic_write_json(Path(folder) / FILE, doc) + return got + + +def _aside(path: Path, folder: str | Path) -> bool: + """밑줄 · 점 폴더(「_합친것」 등 파생 · 보관) — 쓰는 곳 아님.""" + return any(x.startswith(("_", ".")) for x in path.relative_to(folder).parts[:-1]) + + +def usage(folder: str | Path, keys: list[str]) -> dict[str, list[dict[str, Any]]]: + """그 층에서 키마다 쓰는 문서(단가산출 · 일위대가 …) {키: [{종류, 키, 이름}]} — 파일은 한 번씩 읽음.""" + out: dict[str, list[dict[str, Any]]] = {k: [] for k in keys} + for path in sorted(Path(folder).rglob("*.json")): # 종류 폴더 · 그 밑 폴더 — 내 목록 파일 뺌 + if path.name == FILE or _aside(path, folder): + continue + try: + text = path.read_text(encoding="utf-8") + except OSError: + continue + hit = [k for k in keys if k in text] + if not hit: + continue + try: + doc = json.loads(text) + except ValueError: + continue + name = (doc.get("이름") if isinstance(doc, dict) else None) or path.stem + for k in hit: + out[k].append({"종류": path.parent.name, "키": path.stem, "이름": name}) + return out + + +def uses(folder: str | Path, key: str) -> list[dict[str, Any]]: + return usage(folder, [key])[key] + + +def remove(folder: str | Path, key: str) -> None: + """내 재료 지움 — 쓰는 문서가 있으면 409(그 줄을 먼저 바꿈).""" + with store._LOCK: + doc = read(folder) + if not any(r.get("키") == key for r in doc["줄"]): + raise store.StoreError(404, f"없는 내 재료 「{key}」") + if used := uses(folder, key): + names = " · ".join(str(u["이름"]) for u in used[:3]) + raise store.StoreError(409, f"쓰는 곳 {len(used)} — {names} · 그 줄을 먼저 바꿈") + doc["줄"] = [r for r in doc["줄"] if r.get("키") != key] + atomic_write_json(Path(folder) / FILE, doc) + + +# ── 840-4 셈 색인(단가산출이 M01 재료처럼 읽음) ───────────────────────── +_MEMO: dict[str, tuple] = {} + + +def whole(base: Any) -> Any: + """셈 색인 + 지금 층(개인) 내 재료 줄 — 파일 · 바탕이 그대로면 같은 객체 · 개인 층 아님 = 바탕 그대로.""" + from decimal import Decimal + + from M02_MasterTemplete import M02_Sangeun_Copy as skc + + folder = store.root() + path = folder / FILE + try: + st = path.stat() + except OSError: + return base + if not _personal(folder): + return base + sig = (st.st_mtime_ns, st.st_size) + got = _MEMO.get(str(path)) + if got and got[0] == sig and got[1] is base: + return got[2] + raw = json.dumps(rows(folder), ensure_ascii=False) + mine = [ + r + for r in json.loads(raw, parse_float=Decimal, parse_int=Decimal) + if is_own(str(r.get("키"))) + ] + out = skc.Copy(base, mine, ("내재료", sig)) if mine else base + if len(_MEMO) > 16: # ponytail: 통째 비움 · 층이 많아지면 LRU 로 + _MEMO.clear() + _MEMO[str(path)] = (sig, base, out) + return out + + +def keys_in(doc: Any) -> list[str]: + """문서 안 내 재료 키(요소 이음 「PM…」 · 사본 빈틈 찍기).""" + return sorted(set(FIND.findall(json.dumps(doc, ensure_ascii=False, default=str)))) + + +def added(index: Any) -> list[dict]: + """`whole` 이 얹은 내 재료 줄(사본 모으기 `collect` 가 마스터 밖 줄로 담음).""" + return list((getattr(index, "index", {}).get(PREFIX) or {}).values()) + + # ── 148-3 — 저장 검사 · 셈 · 사본 · 층 사이 ───────────────────────────── BUNDLE = "재료_개인자재.json" # 사본 `단가.json` 안 이름 diff --git a/M02_MasterTemplete/M02_MyItems_View.ts b/M02_MasterTemplete/M02_MyItems_View.ts index 3cf894d95..0fe43446f 100644 --- a/M02_MasterTemplete/M02_MyItems_View.ts +++ b/M02_MasterTemplete/M02_MyItems_View.ts @@ -4,6 +4,7 @@ * 줄 = 그 층 단가산출 줄에 값을 바로 적은 재료(우리 자재에 안 이어진 것 · 서버 `M02_MyMachine_Look.items`) * 칸 = 이름 · 규격 · 단위 · 값 · 쓰는 단가산출 수 · 같은 이름 수(같은 이름 묶음 = 이름 차례로 붙어 보임) * 줄 누름 = 아래 쓰는 단가산출 목록 → 누르면 그 단가산출로(고치기는 거기서 · 여기선 저장 없음) + * 위 = 「내 재료」 등록 칸(840-4 · `M02_MyMaterial_View` — 재료 DB 에 없는 자재 등록) · 이 모아 보기는 그 아래 읽기 * ========================================================================== */ import { createDataTable } from "@ui/ui_template_data_table"; @@ -11,6 +12,7 @@ import { createInputField, el } from "@ui/ui_template_elements"; import { createFindList } from "@ui/ui_template_find_list"; import { createText } from "@ui/ui_template_text"; import { listMyItems, type MyItem, type Use } from "./M02_MyMachine_Api"; +import { buildMyMaterialBlock } from "./M02_MyMaterial_View"; import { mt } from "./M02_MyMachine_Text"; export interface MyItemsViewOptions { @@ -85,6 +87,7 @@ export function buildMyItemsView(opt: MyItemsViewOptions): HTMLElement { className: "m02-mymach-view", attrs: { "data-my-items": "" }, children: [ + buildMyMaterialBlock({ owner: opt.owner }), el("div", { className: "ui-toolbar", children: [search.root, hint] }), createText(mt("Items_Note"), "muted"), fail, diff --git a/M02_MasterTemplete/M02_MyMachine_Text.ts b/M02_MasterTemplete/M02_MyMachine_Text.ts index b4f313ab9..b447bcec5 100644 --- a/M02_MasterTemplete/M02_MyMachine_Text.ts +++ b/M02_MasterTemplete/M02_MyMachine_Text.ts @@ -74,7 +74,7 @@ const TEXT = { Why_Company: "개인용으로 복사해서 씀", // 내 품목 Items_Note: - "단가산출 줄에 값을 바로 적은 재료(우리 자재에 안 이어진 것) — 고치기는 그 단가산출에서 · 줄 누르면 쓰는 단가산출", + "단가산출 줄에 값을 바로 적은 재료(재료 DB · 내 재료에 안 이어진 것 · 읽기만) — 고치기는 그 단가산출에서 · 줄 누르면 쓰는 단가산출", Items_None: "내 품목 없음", Value: "값(원)", Unit: "단위", diff --git a/M02_MasterTemplete/M02_MyMaterial_Api.ts b/M02_MasterTemplete/M02_MyMaterial_Api.ts new file mode 100644 index 000000000..477530f6d --- /dev/null +++ b/M02_MasterTemplete/M02_MyMaterial_Api.ts @@ -0,0 +1,45 @@ +/* ============================================================================= + * M02_MyMaterial_Api.ts + * M02 내 재료(개인 자재 PM · PLAN 840-4) 서버 호출 — 개인 층만 · 서버 `M02_Labor_Router` 의 /layers/personal/materials + * 목록(줄마다 쓰는 곳) · 만들기 · 고치기 · 지우기(쓰는 곳 있으면 409) · M01 재료 DB 와 같은 이름 · 규격 · 단위 = 409 + * ========================================================================== */ + +import { call } from "./M02_MasterTemplete_Api_Fetch"; + +export interface MyMaterialUse { + 종류: string; + 키: string; + 이름: string; +} + +export interface MyMaterial { + 키: string; + 이름: string; + 규격: string; + 단위: string; + 값: number | null; + 쓰는곳?: MyMaterialUse[]; +} + +export type MyMaterialBody = Pick; + +const path = (owner: string | null, key = ""): string => + `/layers/personal/materials${key ? `/${encodeURIComponent(key)}` : ""}${ + owner ? `?owner=${encodeURIComponent(owner)}` : "" + }`; + +export const listMyMaterials = (owner: string | null): Promise => + call<{ 줄: MyMaterial[] }>(path(owner)).then((d) => d.줄); + +export const addMyMaterial = (owner: string | null, body: MyMaterialBody): Promise => + call(path(owner), { method: "POST", body: JSON.stringify(body) }); + +export const editMyMaterial = ( + owner: string | null, + key: string, + body: MyMaterialBody, +): Promise => + call(path(owner, key), { method: "PUT", body: JSON.stringify(body) }); + +export const dropMyMaterial = (owner: string | null, key: string): Promise => + call(path(owner, key), { method: "DELETE" }); diff --git a/M02_MasterTemplete/M02_MyMaterial_View.ts b/M02_MasterTemplete/M02_MyMaterial_View.ts new file mode 100644 index 000000000..165178c89 --- /dev/null +++ b/M02_MasterTemplete/M02_MyMaterial_View.ts @@ -0,0 +1,185 @@ +/* ============================================================================= + * M02_MyMaterial_View.ts + * M02 개인관리 › 자재 위 「내 재료」 등록 칸(PLAN 840-4 · 요구 854 · 862) — 개인 층 + * 내 재료 = 재료 DB(M01)에 없는 자재를 등록하는 곳 · M01 재료 값 바꿈은 단가산출 안 재료 줄에서 + * 표 = 이름 · 규격 · 단위 · 값 · 쓰는 곳 · 키 · 줄 누름 = 아래 칸에서 고치기 · [새 자재] = 빈 칸 + * [저장] = 서버(M01 과 이름 · 규격 · 단위 같으면 서버가 막음 — 까닭 그대로 알림) · [지우기] = 쓰는 곳 있으면 서버가 막음 + * 값을 고치면 그 재료를 쓰는 개인 층 단가산출이 따라옴(836-2 자동 따라옴 · 프로젝트 층 = 사본 값) + * 남의 층(owner 있음) = 읽기만 + * ========================================================================== */ + +import { createButton } from "@ui/ui_template_button"; +import { createDataTable } from "@ui/ui_template_data_table"; +import { createInputField, el, showConfirmDialog, showToast } from "@ui/ui_template_elements"; +import { createText } from "@ui/ui_template_text"; +import { createUnitPick, NO_UNIT } from "./DataFlow/M02_DF_UnitPick"; +import { + addMyMaterial, + dropMyMaterial, + editMyMaterial, + listMyMaterials, + type MyMaterial, +} from "./M02_MyMaterial_Api"; + +const TEXT = { + title: "내 재료", + note: "재료 DB(M01)에 없는 자재를 등록하는 곳 — 단가산출 재료 고르기 「내 재료」 로 씀 · M01 재료 값 바꿈은 단가산출 안 재료 줄에서", + none: "내 재료 없음", + add: "새 자재", + name: "품명", + spec: "규격", + unit: "단위", + value: "값(원)", + uses: "쓰는 곳", + key: "키", + save: "저장", + drop: "지우기", + cancel: "취소", + need: "품명 · 단위는 꼭 적음", + saved: "저장함 — 쓰는 단가산출이 새 값으로 셈", + dropped: "지움", + dropAsk: "「{name}」 을 지움", + readOnly: "남의 층 — 읽기만", +} as const; + +export interface MyMaterialBlockOptions { + owner: string | null; +} + +export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement { + const canWrite = opt.owner === null; + let rows: MyMaterial[] = []; + let editing: MyMaterial | null = null; + let unit = ""; + const table = createDataTable({ + caption: TEXT.title, + columns: [ + { key: "이름", label: TEXT.name, width: 200 }, + { key: "규격", label: TEXT.spec, width: 140 }, + { key: "단위", label: TEXT.unit, width: 60 }, + { key: "값", label: TEXT.value, kind: "number", decimals: 2, trim: true, width: 100 }, + { key: "쓰는곳", label: TEXT.uses, kind: "number", decimals: 0, width: 70 }, + { key: "키", label: TEXT.key, width: 90 }, + ], + rows: [], + empty: TEXT.none, + onRowClick: (i) => canWrite && open(rows[i]), + }); + const name = createInputField({ label: TEXT.name, required: true }); + const spec = createInputField({ label: TEXT.spec }); + const price = createInputField({ label: TEXT.value, type: "number", min: 0 }); + const unitHost = el("span"); + const drawUnit = (): void => + unitHost.replaceChildren( + createUnitPick({ + value: unit || NO_UNIT, + ariaLabel: TEXT.unit, + onPick: (u) => { + unit = u === NO_UNIT ? "" : u; + drawUnit(); + }, + }), + ); + const head = createText(""); + const saveBtn = createButton({ label: TEXT.save, variant: "filled", onClick: () => void save() }); + const dropBtn = createButton({ + label: TEXT.drop, + variant: "danger-ghost", + onClick: () => void drop(), + }); + const form = el("div", { + className: "m02-pick__new", + attrs: { "data-my-material-form": "" }, + children: [ + head, + name.root, + spec.root, + el("div", { + className: "ui-field", + children: [el("label", { className: "ui-field__label", text: TEXT.unit }), unitHost], + }), + price.root, + el("div", { + className: "ui-btn-group", + children: [ + createButton({ label: TEXT.cancel, variant: "ghost", onClick: () => close() }), + dropBtn, + saveBtn, + ], + }), + ], + }); + form.hidden = true; + + function open(row: MyMaterial | null): void { + editing = row; + name.input.value = row?.이름 ?? ""; + spec.input.value = row?.규격 ?? ""; + price.input.value = row?.값 === null || row?.값 === undefined ? "" : String(row.값); + unit = row?.단위 ?? ""; + drawUnit(); + head.textContent = row ? `${row.키} ${row.이름}` : TEXT.add; + dropBtn.hidden = !row; + form.hidden = false; + name.input.focus(); + } + function close(): void { + editing = null; + form.hidden = true; + } + async function load(): Promise { + rows = await listMyMaterials(opt.owner).catch((e) => { + showToast(e instanceof Error ? e.message : String(e), "error"); + return []; + }); + table.setRows(rows.map((r) => ({ ...r, 쓰는곳: r.쓰는곳?.length ?? 0 }))); + } + async function save(): Promise { + const 이름 = name.input.value.trim(); + if (!이름 || !unit) return showToast(TEXT.need, "error"); + const raw = price.input.value.trim(); + const body = { + 이름, + 규격: spec.input.value.trim(), + 단위: unit, + 값: raw === "" ? null : Number(raw), + }; + saveBtn.disabled = true; + try { + if (editing) await editMyMaterial(opt.owner, editing.키, body); + else await addMyMaterial(opt.owner, body); + showToast(TEXT.saved, "success"); + close(); + await load(); + } catch (e) { + showToast(e instanceof Error ? e.message : String(e), "error"); + } finally { + saveBtn.disabled = false; + } + } + async function drop(): Promise { + if (!editing) return; + if (!(await showConfirmDialog(TEXT.dropAsk.replace("{name}", editing.이름), TEXT.drop))) return; + try { + await dropMyMaterial(opt.owner, editing.키); + showToast(TEXT.dropped, "success"); + close(); + await load(); + } catch (e) { + showToast(e instanceof Error ? e.message : String(e), "error"); + } + } + + const addBtn = createButton({ label: TEXT.add, variant: "filled", onClick: () => open(null) }); + addBtn.hidden = !canWrite; + void load(); + return el("div", { + attrs: { "data-my-materials": "" }, + children: [ + el("div", { className: "ui-toolbar", children: [addBtn] }), + createText(canWrite ? TEXT.note : TEXT.readOnly, "muted"), + table.root, + form, + ], + }); +} diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index 26e4c9d91..61434f8b6 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -45,10 +45,11 @@ READS: ContextVar[dict | None] = ContextVar("읽은줄", default=None) def whole_() -> Any: - """M01 색인 + 지금 층 내 기계 줄(821-1 · `M02_MyMachine.whole`).""" + """M01 색인 + 지금 층 내 기계 줄(821-1 · `M02_MyMachine.whole`) + 내 재료 줄(840-4 · `M02_Material_Own.whole`).""" + from M02_MasterTemplete import M02_Material_Own as own from M02_MasterTemplete import M02_MyMachine as mym - return mym.whole() + return own.whole(mym.whole()) def _fp(rows: Any) -> str: diff --git a/resources/tester/test_840_4_my_material.py b/resources/tester/test_840_4_my_material.py new file mode 100644 index 000000000..f81acc4e6 --- /dev/null +++ b/resources/tester/test_840_4_my_material.py @@ -0,0 +1,78 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""840-4 내 재료(개인 자재 PM) = M01 재료 DB 에 없는 자재 등록 자리 — 임시 storage. + +① M01 재료 DB 와 이름 · 규격 · 단위가 같으면 만들기 · 고치기 막음(409) · 품명 · 단위 빈 = 400 +② 단가산출 재료 줄이 내 재료를 M01 재료처럼 읽음(미리 셈 · 저장) +③ 내 재료 값을 고치면 개인 층 단가산출 금액이 따라옴(836-2 자동 따라옴 길) +④ 쓰는 곳 있으면 지움 막음(409) · 쓰는 곳 없으면 지움 · 없는 키 = 404. +""" + +from __future__ import annotations + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Material_Own as own +from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 + +NAME = "sub4임시자재" + + +def _at(folder, fn, *args): + with store.at(folder): + return fn(*args) + + +def _code(fn, *args) -> int: + with pytest.raises(store.StoreError) as e: + fn(*args) + return e.value.status + + +def _doc(key: str, code: str) -> dict: + """줄 쌓기 재료 줄 하나(화면이 저장하는 꼴) — 단가 = 요소 이음(내 재료).""" + var = {"기호": "P", "아래": "재", "위": "", "이름": NAME, "단위": "", + "연결": {"갈래": "요소", "키": code, "단위": "kg"}} # fmt: skip + line = {"이름": NAME, "단위": "kg", "비목": "재료비", "수량": "2", "단가": "P_재"} + return {"꼴": "수식문서", "판": 1, "키": key, "이름": NAME, "결과단위": "원", + "변수": [var], "식": [], "금액": [line]} # fmt: skip + + +def test_m01_same_blocked(world): + me = world["personal"] + mt = next(r for r in m01.loaded()[1].index["MT"].values() if r.get("이름") and r.get("단위")) + same = {"이름": f" {mt['이름']} ", "규격": mt.get("규격") or "", "단위": mt["단위"], "값": 1} + assert _at(me, _code, own.add, me, same) == 409 + assert _at(me, _code, own.add, me, {"이름": NAME, "단위": ""}) == 400 + row = _at(me, own.add, me, {"이름": NAME, "규격": "x", "단위": "kg", "값": 1000}) + assert own.is_own(row["키"]) and own.m01_same(row) is None + assert _at(me, _code, own.update, me, row["키"], same) == 409 + assert _at(me, _code, own.update, me, "PM999999", {"이름": NAME, "단위": "kg"}) == 404 + assert ( + _at(me, _code, own.add, me, {"이름": NAME, "규격": "X", "단위": "㎏"}) == 409 + ) # 내 목록 같음 + + +def test_sk_reads_and_follows(world): + from M02_MasterTemplete import M02_Doc_Sk_Path as path + from M02_MasterTemplete import M02_Labor_Ref as refs + + me = world["personal"] + code = _at(me, own.add, me, {"이름": NAME, "규격": "y", "단위": "kg", "값": 1000})["키"] + sk = _at(me, lambda: refs.create("sangeun", {"이름": NAME, "단위": "식", "더한줄": []})["이름"]) + doc = _doc(sk, code) + assert _at(me, path.preview, sk, {"문서": doc})["셈"]["계"] == 2000 # 저장 전 미리 셈 + _at(me, path.save, sk, {"문서": doc, "판": _at(me, path.read, sk)["판"]}) + assert _at(me, path.read, sk)["셈"]["계"] == 2000 + _at(me, own.update, me, code, {"이름": NAME, "규격": "y", "단위": "kg", "값": 1500}) + assert _at(me, path.read, sk)["셈"]["계"] == 3000 # 값 바꿈 → 따라옴 + assert [u["키"] for u in _at(me, own.uses, me, code)] == [sk] + assert _at(me, _code, own.remove, me, code) == 409 # 쓰는 곳 있음 + _at(me, store.delete, "sangeun", sk) + aside = me / "_합친것" / f"{sk}.json" # 파생 · 보관 폴더 = 쓰는 곳 아님 + aside.parent.mkdir(parents=True, exist_ok=True) + aside.write_text(f'{{"이름": "x", "키": "{code}"}}', encoding="utf-8") + _at(me, own.remove, me, code) + assert all(r["키"] != code for r in own.rows(me)) + assert _at(me, _code, own.remove, me, code) == 404 diff --git a/resources/tester/test_m02_material_own.py b/resources/tester/test_m02_material_own.py index 82581f67f..a20d6b2a6 100644 --- a/resources/tester/test_m02_material_own.py +++ b/resources/tester/test_m02_material_own.py @@ -55,7 +55,7 @@ def test_추가하면_PM_6자리_키_목록에_보임_화면_키_무시(world): assert got.status_code == 200, got.text row = got.json() assert row == {"키": "PM000001", "이름": "앵커볼트", "규격": "M16", "단위": "EA", "값": 1200} - assert c.get(URL.format("personal")).json()["줄"] == [row] + assert c.get(URL.format("personal")).json()["줄"] == [{**row, "쓰는곳": []}] # 840-4 쓰는 곳 path = layers.personal_dir(7, 42) / own.FILE assert path.is_file() assert own.read(path.parent)["그룹"] == "재료" diff --git a/ui_template/ui_template_locale_m2.ts b/ui_template/ui_template_locale_m2.ts index 05a6bfbc9..53d2d2ee4 100644 --- a/ui_template/ui_template_locale_m2.ts +++ b/ui_template/ui_template_locale_m2.ts @@ -236,6 +236,7 @@ export const ui_locales_m2 = { M02_FindClass: ["구분", "Class"], M02_FindLogic: ["단가산출 기초", "Unit-cost logic"], M02_FindNewMaterial: ["신규 자재", "New material"], + M02_FindMyMaterial: ["내 재료", "My material"], M02_FindElementLater: ["일위대가 표 개편 뒤", "After the unit-cost table rework"], M02_FindOptions: ["옵션 {n}", "{n} options"], // 729-3 불러오기 — 안 이은 줄 · 일위대가표 띠