From e76e6380135f45a1d26ec040e3b0a7b4133bf9d8 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 28 Sep 2026 18:56:51 +0900 Subject: [PATCH 1/3] =?UTF-8?q?feat(M02):=20=EC=A1=B0=ED=95=A9=20=EA=B0=88?= =?UTF-8?q?=EB=9D=BC=20=EB=82=B4=EA=B8=B0=20=EA=B8=B8=20=C2=B7=20=EC=9E=90?= =?UTF-8?q?=EC=9E=AC=20=EC=A1=B0=ED=95=A9(UM)=20=ED=91=9C=20=C2=B7=20?= =?UTF-8?q?=EB=B3=B8=EB=9C=AC=ED=82=A4=20=EC=B9=B8=20=C2=B7=20=EB=B6=84?= =?UTF-8?q?=EB=A5=98=20=EB=8D=94=ED=95=98=EA=B8=B0=20=EC=97=B4=20=EB=B3=B5?= =?UTF-8?q?=EC=82=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - POST /api/m02/structures/{열}/combo — 고친 담은 로직으로 새 UA(같은 로직 집합이면 있는 키) · 집계표 그 열만 새 키 · 판 어긋나면 조합 만들기 전 409 · SS 장부 맞춤 - 일위대가 조합 줄에 본뜬키 칸(원래 키) · 기존 37 줄 null · M01 고치기에서 안 보내도 유지 - 자재 조합 표 resources/master_data/자재조합.json(키 UM · 대장 등록 · 틀 검사) · POST /structures/{열}/material-combo · GET /material-combos/{키} - 구조물집계표조합 칸 자재조합 · 분류 더하기로 복사한 열은 저장 때 원본 열의 일위대가 · 자재조합 키와 구조물 도면 · 면적산출 · 재료산출 내용을 새 번호로 받음 - Api_Fetch branchCombo · branchMaterialCombo · fetchMaterialCombo Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_011vX53nJGC8ucBRFJns2n7B --- M01_MasterData/M01_MasterData_Store_Combo.py | 2 + .../M02_MasterTemplete_Api_Fetch.ts | 55 +++++ .../M02_MasterTemplete_Branch.py | 151 +++++++++++++ .../M02_MasterTemplete_Router.py | 35 +++ .../M02_MasterTemplete_Store.py | 44 +++- resources/master_data/_키대장.json | 2 +- resources/master_data/_틀.md | 16 +- resources/master_data/scripts/check_master.py | 6 + resources/master_data/scripts/master_combo.py | 4 +- resources/master_data/scripts/master_keys.py | 5 +- .../scripts/master_material_combo.py | 66 ++++++ resources/master_data/일위대가조합.json | 37 +++ resources/master_data/자재조합.json | 6 + .../master_template/구조물집계표조합.json | 57 ++++- resources/tester/test_m02_combo_branch.py | 211 ++++++++++++++++++ ui_template/sheet/ui_template_sheet_ops.ts | 11 +- ui_template/sheet/ui_template_sheet_types.ts | 4 + 17 files changed, 698 insertions(+), 14 deletions(-) create mode 100644 M02_MasterTemplete/M02_MasterTemplete_Branch.py create mode 100644 resources/master_data/scripts/master_material_combo.py create mode 100644 resources/master_data/자재조합.json create mode 100644 resources/tester/test_m02_combo_branch.py diff --git a/M01_MasterData/M01_MasterData_Store_Combo.py b/M01_MasterData/M01_MasterData_Store_Combo.py index c340e0de..64f229d5 100644 --- a/M01_MasterData/M01_MasterData_Store_Combo.py +++ b/M01_MasterData/M01_MasterData_Store_Combo.py @@ -202,6 +202,8 @@ def combo_edit(key: str, version: str, combo_: dict, owner: str = "") -> dict: was = _find(data, key) if store.read(FILE)[1] != version: raise store.StoreError(409, {"stale": [FILE]}) + if isinstance(combo_, dict): # 화면이 안 보내도 계보(본뜬키)는 남김 + combo_ = {"본뜬키": was.get("본뜬키"), **combo_} fixed = _clean(combo_, owner or str(was.get("소유") or OWNERS[0]), key) done = _write([{"op": "edit", "key": key, "row": fixed}], version) return {**done, "combo": _find(store.read(FILE)[0], key)} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts index 12c31e68..d35080df 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts @@ -138,6 +138,8 @@ export interface StructureCombo extends StructureNumbers { 분류3: string | null; 단위: string | null; 일위대가: string | null; + /** 자재 조합 키 `UM` */ + 자재조합: string | null; 바인딩: unknown; 펼침: unknown; } @@ -153,6 +155,59 @@ export interface StructureCombos { /** 조합 표 — 서버가 집계표 [저장] 때 맞춤(읽기만) */ export const fetchStructureCombos = (): Promise => call("/structure-combos"); +/** 조합 갈라 내기 결과 — `새로만듦` false = 같은 담은 로직의 조합이 이미 있어 그 키를 가리킴 */ +export interface BranchedCombo { + 키: string; + 이름: string; + 새로만듦: boolean; + 집계표판: string; +} + +/** 이 열이 가리키는 일위대가 조합을 고친 담은 로직으로 갈라 냄 — 새 UA · 집계표 그 열만 새 키 · + * `판`(집계표 판)을 주면 어긋날 때 StaleError · 원래 조합은 그대로 */ +export const branchCombo = ( + column: string, + body: { + 본뜬키: string; + 담은로직: { 로직: string; 메모?: string | null }[]; + 이름: string; + 판?: string; + }, +): Promise => + call(`/structures/${enc(column)}/combo`, { method: "POST", body: JSON.stringify(body) }); + +/** 자재 조합(키 `UM`) 담은 자재 한 줄 */ +export interface MaterialItem { + 코드: string; + 이름: string | null; + 규격: string | null; + 단위: string | null; +} + +/** 자재 조합 한 줄 — 본뜬키 = 갈라 낸 원래 키(없으면 null) */ +export interface MaterialCombo { + 키: string; + 이름: string; + 담은자재: MaterialItem[]; + 본뜬키: string | null; + 소유: string; + 비고: string | null; +} + +export const fetchMaterialCombo = (key: string): Promise => + call(`/material-combos/${enc(key)}`); + +/** 이 열의 자재 조합을 고친 담은 자재로 갈라 냄 — 규칙은 `branchCombo` 와 같음 · + * `본뜬키` 빈 글 = 이 열의 첫 자재 조합 */ +export const branchMaterialCombo = ( + column: string, + body: { 본뜬키?: string; 담은자재: MaterialItem[]; 이름: string; 판?: string }, +): Promise => + call(`/structures/${enc(column)}/material-combo`, { + method: "POST", + body: JSON.stringify(body), + }); + /** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */ export const copyStructure = async (column: string, from: string): Promise => { await call(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" }); diff --git a/M02_MasterTemplete/M02_MasterTemplete_Branch.py b/M02_MasterTemplete/M02_MasterTemplete_Branch.py new file mode 100644 index 00000000..d708e92d --- /dev/null +++ b/M02_MasterTemplete/M02_MasterTemplete_Branch.py @@ -0,0 +1,151 @@ +"""조합 갈라 내기 — 구조물 열 하나가 가리키는 조합을 고친 내용으로 새로 만들어 그 열만 새 키를 +가리키게 함(PLAN 15장 · 검토 `14_조합편집검토.md` 1장). + · 일위대가 조합(UA · `일위대가조합.json`) — 새 줄은 M01 조합 저장소가 만듦(부르기만) + · 자재 조합(UM · `자재조합.json`) — M01 마스터 저장(`save`)으로 더함(키 = 대장 다음 번호) + +조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것의 집합(차례 · 메모 무시)이 +이미 있는 조합과 같으면 새로 안 만들고 그 키 · 새 줄의 본뜬키 = 원래 키 · 소유 현장. +""" + +from __future__ import annotations + +from typing import Any, Callable + +from M01_MasterData import M01_MasterData_Store as m01 +from M01_MasterData import M01_MasterData_Store_Combo as combo_store +from M02_MasterTemplete import M02_MasterTemplete_Store as store + +_OWNER = "현장" +MATERIAL_FILE = "자재조합.json" + + +def _m01(fn, *args): + """M01 막힘은 M02 막힘으로 — 상태 · 까닭 그대로.""" + try: + return fn(*args) + except m01.StoreError as e: + raise store.StoreError(e.status, e.detail) from e + + +def _free_name(name: str, rows: list[dict]) -> str: + taken = {str(r.get("이름") or "") for r in rows} + n, out = 2, name + while out in taken: + out, n = f"{name} ({n})", n + 1 + return out + + +def _branch( + column: str, + version: str, + field: str, + file: str, + slot: str, + ident: str, + items: list[dict], + source: str, + make: Callable[[str, list[dict]], dict], + name: str, +) -> dict[str, Any]: + """집계표 판 검사 → 같은 내용 찾기 · 없으면 `make(이름, 줄들)` 로 새 줄 → 집계표 그 열 `field`. + `slot` = 담은 칸(담은로직 · 담은자재) · `ident` = 담은 줄의 알맹이 칸(로직 · 코드).""" + table = store.read("table", store.STRUCTURE_TABLE) + if version and table["판"] != version: + raise store.StoreError(409, {"stale": [store.STRUCTURE_TABLE], "판": table["판"]}) + col = next((c for c in store._structure_columns() if c["id"] == column), None) + if col is None: + raise store.StoreError(404, f"{store.STRUCTURE_TABLE}에 없는 구조물 열 「{column}」") + if not isinstance(items, list) or not items: + raise store.StoreError(400, "담은 것이 비었음") + + def body(got) -> frozenset[str]: + return frozenset(str(x.get(ident) or "") for x in got or [] if isinstance(x, dict)) + + rows = _m01(m01.read, file)[0].get("줄") or [] + same = [r for r in rows if body(r.get(slot)) == body(items)] + hit = next((r for r in same if source and r.get("키") == source), same[0] if same else None) + if hit: + key, made_name, made = str(hit["키"]), str(hit.get("이름") or ""), False + else: + made_name = _free_name(name, rows) + key, made = make(made_name, rows), True + # ponytail: 조합 쓰기와 집계표 쓰기는 한 묶음 아님 — 사이에 집계표가 바뀌면 409 뒤 주인 없는 + # 조합 하나가 남음(다시 하면 같은 내용이라 그 키를 씀) + doc = table["문서"] + for c in doc.get("열", []): + if isinstance(c, dict) and c.get("id") == column: + c[field] = key + info = store.write("table", store.STRUCTURE_TABLE, table["판"], doc) # SS 도 여기서 맞춤 + return {"키": key, "이름": made_name, "새로만듦": made, "집계표판": info["판"]} + + +def branch_combo( + column: str, source: str, items: list[dict], name: str, version: str = "" +) -> dict[str, Any]: + """일위대가 조합 갈라 내기 — 구분 · 상세구분 · 단위 · 출처 = 본뜬 것.""" + was = _m01(combo_store.combo, source)["combo"] + items = [ + {"로직": str(x.get("로직") or ""), "메모": x.get("메모")} + for x in items or [] + if isinstance(x, dict) + ] + + def make(made_name: str, _rows) -> str: + row = { + "이름": made_name, + **{k: was.get(k) for k in ("구분", "상세구분", "단위")}, + "담은로직": items, + "본뜬키": source, + "출처": was.get("출처"), + } + return str(_m01(combo_store.combo_new, row, _OWNER)["key"]) + + name = name.strip() or str(was.get("이름") or source) + return _branch( + column, version, "일위대가", combo_store.FILE, "담은로직", "로직", items, source, make, name + ) + + +def _material_rows() -> list[dict]: + return _m01(m01.read, MATERIAL_FILE)[0].get("줄") or [] + + +def material_combo(key: str) -> dict[str, Any]: + row = next((r for r in _material_rows() if r.get("키") == key), None) + if row is None: + raise store.StoreError(404, f"없는 자재 조합 「{key}」") + return row + + +def branch_material_combo( + column: str, source: str, items: list[dict], name: str, version: str = "" +) -> dict[str, Any]: + """자재 조합 갈라 내기 — `source` 가 빈 글이면 이 열의 첫 자재 조합(본뜬키 null).""" + was = material_combo(source) if source else {} + items = [ + {k: x.get(k) for k in ("코드", "이름", "규격", "단위")} + for x in items or [] + if isinstance(x, dict) + ] + + def make(made_name: str, rows: list[dict]) -> str: + row = {"이름": made_name, "담은자재": items, "본뜬키": source or None, "소유": _OWNER} + before = {r.get("키") for r in rows} + _m01( + m01.save, + [ + { + "file": MATERIAL_FILE, + "version": _m01(m01.read, MATERIAL_FILE)[1], + "changes": [{"op": "add", "row": {**row, "비고": None}}], + } + ], + ) + return str(next(r["키"] for r in _material_rows() if r.get("키") not in before)) + + heads = next((c for c in store._structure_columns() if c["id"] == column), {}) + default = " ".join(h for h in store._heads(heads) if h) if heads else column + name = name.strip() or str(was.get("이름") or default or column) + return _branch( + column, version, "자재조합", MATERIAL_FILE, "담은자재", "코드", items, source, make, name + ) diff --git a/M02_MasterTemplete/M02_MasterTemplete_Router.py b/M02_MasterTemplete/M02_MasterTemplete_Router.py index 696292b6..cbef0be9 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Router.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Router.py @@ -10,6 +10,7 @@ from typing import Any from fastapi import APIRouter, HTTPException, Query from pydantic import BaseModel +from M02_MasterTemplete import M02_MasterTemplete_Branch as branch from M02_MasterTemplete import M02_MasterTemplete_Store as store router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"]) @@ -20,6 +21,20 @@ class SaveBody(BaseModel): 문서: Any +class BranchBody(BaseModel): + 본뜬키: str + 담은로직: list[dict[str, Any]] + 이름: str = "" + 판: str = "" # 집계표 판 — 주면 어긋날 때 409 + + +class MaterialBranchBody(BaseModel): + 본뜬키: str = "" # 빈 글 = 이 열의 첫 자재 조합 + 담은자재: list[dict[str, Any]] + 이름: str = "" + 판: str = "" + + def _call(fn, *args): try: return fn(*args) @@ -49,6 +64,26 @@ def post_structure(column: str) -> dict: return _call(store.create_structure, column) +@router.post("/structures/{column}/combo") +def post_structure_combo(column: str, body: BranchBody) -> dict: + """조합 갈라 내기 — 고친 담은 로직으로 새 UA(같은 로직 집합이면 있는 키) · 이 열만 가리킴.""" + return _call(branch.branch_combo, column, body.본뜬키, body.담은로직, body.이름, body.판) + + +@router.post("/structures/{column}/material-combo") +def post_structure_material_combo(column: str, body: MaterialBranchBody) -> dict: + """자재 조합 갈라 내기 — 같은 규칙(같은 자재 집합이면 있는 키 · 아니면 새 UM).""" + return _call( + branch.branch_material_combo, column, body.본뜬키, body.담은자재, body.이름, body.판 + ) + + +@router.get("/material-combos/{key}") +def get_material_combo(key: str) -> dict: + """자재 조합 한 줄(키 UM) — 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고.""" + return _call(branch.material_combo, key) + + # 복사 가져오기 — 다른 열(`from`) 내용을 받는 열로 · 번호 · 열은 받는 쪽 그대로 @router.post("/structures/{column}/copy") def post_structure_copy(column: str, source: str = Query(alias="from")) -> dict: diff --git a/M02_MasterTemplete/M02_MasterTemplete_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Store.py index 5aadc5ed..c846c529 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Store.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Store.py @@ -109,9 +109,12 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]: 만들고 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 지움(잠금 밖에서 · 안에서 부르면 죽음). 통합문서(area · material)는 서버가 같은 TS 엔진을 Node 로 돌려 `계산값` 을 새로 적음 (브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘. - 번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음).""" + 번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음). + 표 열의 `본뜬열`(분류 더하기로 복사한 새 열)은 적지 않음 — 집계표면 아직 파일이 없는 새 열이 + 원본 열의 일위대가 · 자재조합 키와 세 파일 내용을 받음(새 번호 · 그 뒤로는 열마다 따로).""" path = _path(kind, name) _check_skeleton(kind, doc) + origins = _take_origins(doc) if kind == "table" else {} if kind in SHEETS: doc = _server_values(doc) with _LOCK: @@ -124,6 +127,9 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]: atomic_write_json(path, doc) info = _info(kind, path) if kind == "table" and name == STRUCTURE_TABLE: + for column, source in origins.items(): # 빈 파일 채우기 앞 — 원본 내용으로 만듦 + for part in _KEY: + _ensure(part, column, source) backfill_missing_structures() # 지우기 앞 — 같은 저장의 새 열이 지운 번호를 안 받게 prune_removed_structures() sync_combos() # 번호가 다 선 뒤 — 조합 표 도번 · 면적번 · 재료번 칸 @@ -256,17 +262,46 @@ def _blank(kind: str, column: str) -> dict[str, Any]: } -def _ensure(kind: str, column: str) -> bool: - """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로.""" +def _ensure(kind: str, column: str, source: str | None = None) -> bool: + """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로. + `source` 열 파일이 있으면 빈 문서 대신 그 내용(알약 `연결` 포함 · 계산값은 서버가 다시 풂).""" path = _path(kind, column) + if path.is_file(): + return False head = next(h for k, _, h, _ in PARTS if k == kind) + base = _blank(kind, column) + if source and _path(kind, source).is_file(): + got = json.loads(_path(kind, source).read_bytes()) + base = {**{k: v for k, v in got.items() if k != "계산값"}, "열": column} + if kind in SHEETS: + base = _server_values(base) with _LOCK: if path.is_file(): return False - atomic_write_json(path, {**_blank(kind, column), _KEY[kind]: head + _new_code(column)}) + atomic_write_json(path, {**base, _KEY[kind]: head + _new_code(column)}) return True +def _take_origins(doc: Any) -> dict[str, str]: + """표 열의 `본뜬열` 을 떼어 냄 → `{새 열: 원본 열}` (구조물 파일이 아직 없는 열만) · + 그 열에 일위대가 · 자재조합 키가 비었으면 원본 열 것을 받음.""" + cols = ( + [c for c in (doc.get("열") or []) if isinstance(c, dict)] if isinstance(doc, dict) else [] + ) + by_id = {c.get("id"): c for c in cols} + out: dict[str, str] = {} + for col in cols: + source = col.pop("본뜬열", None) + if not source or source not in by_id or not col.get("id"): + continue + if (FOLDER / "structure" / f"{col['id']}.json").is_file(): + continue + out[col["id"]] = source + for field in ("일위대가", "자재조합"): + col[field] = col.get(field) or by_id[source].get(field) + return out + + def create_structure(column: str) -> dict[str, Any]: """구조물 열 하나의 구조물 도면 새로 — 도번 SD + 8자리 · 이미 있으면 409. 면적산출 · 재료산출 파일이 없으면 빈 통합문서도 같이 만듦(같은 8자리).""" @@ -400,6 +435,7 @@ def _combo_row(key: str, col: dict[str, Any], numbers: dict[str, str]) -> dict[s "분류3": level3, "단위": col.get("단위"), "일위대가": col.get("일위대가"), + "자재조합": col.get("자재조합"), **{field: numbers.get(field, "") for _, field, _, _ in PARTS}, "바인딩": col.get("바인딩"), "펼침": col.get("펼침"), diff --git a/resources/master_data/_키대장.json b/resources/master_data/_키대장.json index b4e053f7..fe3115ac 100644 --- a/resources/master_data/_키대장.json +++ b/resources/master_data/_키대장.json @@ -1,5 +1,5 @@ { - "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38}, + "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38, "UM": 1}, "폐기": {"MT000001": "자재품목 휘발유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000002": "자재품목 경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000003": "자재품목 선박용경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000004": "자재품목 중유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000005": "자재품목 등유 — 값이 비고 글뿐 · 유가 테이블로 감", "LB000399": "이름 「〃」 — 직종이 아니라 되풀이 기호 · 소요량 13-6-9 에서 윗줄 직종으로 바로잡음", "MN": "재료_나라장터자재 — old 로 옮김 · 로직은 자재품목·품셈재료로 갈아 끼움", "LB000372": "미확보 고급기능사 — 측량노임 항공사진고급기능사 옛이름으로 옮김", "LB000393": "미확보 리베팅공 — 건설노임 철골공 옛이름으로 옮김(2010 통합표 연번10)", "LB000405": "미확보 Belt Conveyor 설치공 — 품셈 13-10-1 주② 배분으로 다섯 직종에 나눔", "MT000006": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "MT000007": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "LB000368": "미확보 기술사 — 기술사(건설) 옛이름으로 옮김", "LB000369": "미확보 특급기술자 — 특급기술자(건설) 옛이름으로 옮김", "LB000370": "미확보 고급기술자 — 고급기술자(건설) 옛이름으로 옮김", "LB000361": "미확보 중급기술자 — 중급기술자(건설) 옛이름으로 옮김", "LB000364": "미확보 초급기술자 — 초급기술자(건설) 옛이름으로 옮김", "LB000365": "미확보 고급숙련기술자 — 고급숙련기술자(건설) 옛이름으로 옮김", "LB000366": "미확보 중급숙련기술자 — 중급숙련기술자(건설) 옛이름으로 옮김", "LB000367": "미확보 초급숙련기술자 — 초급숙련기술자(건설) 옛이름으로 옮김", "LB000389": "미확보 기계기사 — 초급기술자(기계·설비) 옛이름으로 옮김", "LB000388": "미확보 기계산업기사 — 초급숙련기술자(기계·설비) 옛이름으로 옮김", "MO000055": {"원문번호": "주택용저압:기본_200이하", "파일": "재료_유가전력.json"}, "MO000056": {"원문번호": "주택용저압:기본_201~400", "파일": "재료_유가전력.json"}, "MO000057": {"원문번호": "주택용저압:기본_400초과", "파일": "재료_유가전력.json"}, "MO000059": {"원문번호": "주택용저압:전력량_다음200", "파일": "재료_유가전력.json"}, "MO000060": {"원문번호": "주택용저압:전력량_400초과", "파일": "재료_유가전력.json"}, "MO000061": {"원문번호": "주택용저압:월간최저요금", "파일": "재료_유가전력.json"}, "MO000062": {"원문번호": "일반용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000063": {"원문번호": "일반용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000064": {"원문번호": "일반용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000065": {"원문번호": "일반용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000066": {"원문번호": "산업용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000067": {"원문번호": "산업용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000068": {"원문번호": "산업용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000069": {"원문번호": "산업용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000070": {"원문번호": "임시전력갑:기본요금적용", "파일": "재료_유가전력.json"}, "MO000071": {"원문번호": "임시전력갑:전력량요금적용", "파일": "재료_유가전력.json"}, "MO000072": {"원문번호": "임시전력갑:월간최저요금", "파일": "재료_유가전력.json"}}, "키": { "CC000001": {"원문번호": "공통 1-3-1 콘크리트 및 포장용 재료", "파일": "계수_건설품셈_01장_적용기준.json"}, diff --git a/resources/master_data/_틀.md b/resources/master_data/_틀.md index b8ed909b..8597ac01 100644 --- a/resources/master_data/_틀.md +++ b/resources/master_data/_틀.md @@ -38,7 +38,7 @@ | MT | 재료 자재품목 | CF · CC | 계수 산림 · 건설 | | MO | 재료 유가 | RT | 요율 | | MP | 재료 품셈재료(old/ — PLAN 7-4b) | GF · GC · GX | 로직 산림 · 건설 · 자체 | -| EQ | 기계 | | | +| EQ | 기계 | UA · UM | 일위대가 조합 · 자재 조합 | - 빌더는 옛 모양(`열쇠` · 원문별 파일)으로 쓰고 끝에 `scripts/master_keys.py` 의 `adopt` 를 부름 — 키·원문번호·한 테이블·장 파일 이름으로 받음. 옛 이름으로 읽기는 `old_view`. @@ -279,6 +279,7 @@ { "로직": "GF000219", "메모": "인력 메쌓기" }, { "로직": "GF000220", "메모": null } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": null @@ -287,7 +288,8 @@ } ``` -- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `출처` · `소유` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`). +- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `본뜬키` · `출처` · `소유` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`). +- `본뜬키` = 갈라 낸 원래 조합 키(M02 조합 갈라 내기) · 없으면 `null` · M01 고치기는 안 보내도 그대로 둠. - **담은 로직 목록만 둠** — 수량 · 비율 · 계산 칸을 두지 않음. 로직마다 하는 일이 달라 수량은 로직마다 따로 들어가고, 그 대입과 합계는 프로젝트 몫(B08 · B09). - `담은로직` 줄 = `{로직, 메모}` 뿐 · 목록 차례가 곧 조합 안 차례. `메모` = 글자 또는 `null` — 수량 같은 값을 넣는 자리가 아님. - `키` = `UA` + 6자리 — 대장 `_키대장.json` 의 `UA` 다음 번호(서버가 줌). 원문이 없어 **줄에 `원문번호` 를 두지 않음**(대장 열쇠는 조합 이름). @@ -295,3 +297,13 @@ - `이름` = 글자 · 빈 이름 안 됨 · 60자까지(`master_combo.MAX_이름`) · 같은 파일 안에서 안 겹침. - 검사(`check_master.py 조합` · 엔진 `scripts/master_combo.py`) — 없는 로직 키 · 단가산출 로직이 아닌 키 · 같은 로직 두 번 · 빈 조합 · **조합이 조합을 담음**(1단만) · 메모가 글자·`null` 아님 · 이름이 글자 아니거나 없음·너무 김·겹침. - 「이 로직을 쓰는 조합」 은 로직 줄에 칸으로 박지 않고 물을 때 훑어 찾음(`master_combo.using`) — 조합은 관리자가 그때그때 만드는 것이라 박아 두면 낡음. 소요량 「용도」 와 결은 같되 자리가 다름. + +## 11. 자재 조합 파일 + +`자재조합.json` 하나 — 구조물 열 재료산출이 쓰는 **자재 목록 묶음**. 머리 `그룹` · `판` · `비고` · `줄`(원문 없음). + +- 열 한 벌 — `키` · `이름` · `담은자재` · `본뜬키` · `소유` · `비고`(차례까지 이대로 · 엔진 `scripts/master_material_combo.py`). +- `키` = `UM` + 6자리 — 대장 `UM` 다음 번호 · 줄에 `원문번호` 를 두지 않음. +- `담은자재` 줄 = `{코드, 이름, 규격, 단위}` 뿐 · 빈 목록 안 됨 · 같은 코드 두 번 안 됨 · 수량 · 계산은 두지 않음(재료산출 몫). +- `본뜬키` = 갈라 낸 원래 자재 조합 키 · 없으면 `null` · `소유` = `현장` · `공용`. +- 새 줄은 M02 갈라 내기(`POST /api/m02/structures/{열}/material-combo`)가 만듦 — 같은 자재 집합이 있으면 그 키. diff --git a/resources/master_data/scripts/check_master.py b/resources/master_data/scripts/check_master.py index 264b402a..c42a8285 100644 --- a/resources/master_data/scripts/check_master.py +++ b/resources/master_data/scripts/check_master.py @@ -30,6 +30,7 @@ sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline")) import master_combo as mcb # noqa: E402 import master_formula as mf # noqa: E402 import master_keys as mk # noqa: E402 +import master_material_combo as mmc # noqa: E402 from pum_md_tool import _NUM, md_lines # noqa: E402 BOOKS = ( @@ -249,12 +250,17 @@ def check_combo_form(name: str, data: dict) -> list[str]: out.append(f"{where} · 소유 「{row.get('소유')}」 — {' · '.join(mcb.OWNERS)} 아님") if not _source_ok(row.get("출처")): out.append(f"{where} · 출처 모양 「{row.get('출처')}」") + origin = row.get("본뜬키") + if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == mcb.TID): + out.append(f"{where} · 본뜬키 모양 「{origin}」") return out def check_form(name: str, data: dict) -> list[str]: if name == mcb.FILE: return check_combo_form(name, data) + if name == mmc.FILE: + return mmc.check_form(name, data) if name in SPECIAL_FILES: return [] m = _FILE.match(name) diff --git a/resources/master_data/scripts/master_combo.py b/resources/master_data/scripts/master_combo.py index 54d6fa2f..9f2f634f 100644 --- a/resources/master_data/scripts/master_combo.py +++ b/resources/master_data/scripts/master_combo.py @@ -18,8 +18,8 @@ FILE = "일위대가조합.json" TID = "UA" OWNERS = ("현장", "공용") MAX_이름 = 60 # 조합 이름 최대 글자 수 — 관리자가 짓는 짧은 이름이라 이보다 길면 저장 막음 -# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장) -COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "출처", "소유", "비고") +# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장) · 본뜬키 = 갈라 낸 원래 조합 키(없으면 null) +COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "본뜬키", "출처", "소유", "비고") ITEM_COLS = ("로직", "메모") diff --git a/resources/master_data/scripts/master_keys.py b/resources/master_data/scripts/master_keys.py index 10f08fbf..befb7490 100644 --- a/resources/master_data/scripts/master_keys.py +++ b/resources/master_data/scripts/master_keys.py @@ -32,12 +32,13 @@ TABLES = { ("로직", "건설품셈"): "GC", ("로직", "자체"): "GX", ("일위대가조합", None): "UA", + ("자재조합", None): "UM", } GROUP_OF = {tid: group for (group, _), tid in TABLES.items()} IDS = tuple(GROUP_OF) # 줄에 원문번호를 두지 않는 테이블 — 자재품목은 번호가 남의 품번이라 이름 몫을 못 하고, # 조합은 원문이 없어 번호 자체가 없음(대조는 대장에만) -NO_NUMBER = ("MT", "UA") +NO_NUMBER = ("MT", "UA", "UM") def table_id(group: str, book: str | None) -> str: @@ -181,10 +182,12 @@ ROW_ORDER = { "상세구분", "단위", "담은로직", + "본뜬키", "출처", "소유", "비고", ), + "자재조합": ("키", "이름", "담은자재", "본뜬키", "소유", "비고"), } OLD_CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈)_(\D*)(\d+)장\.json$") CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈|자체)_(\d\d)장_.+\.json$") diff --git a/resources/master_data/scripts/master_material_combo.py b/resources/master_data/scripts/master_material_combo.py new file mode 100644 index 00000000..52441e9f --- /dev/null +++ b/resources/master_data/scripts/master_material_combo.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +"""자재 조합 — 구조물 열 재료산출이 쓰는 자재 목록 묶음(키 UM · `_틀.md` 11장). + +담은 자재 목록만 지님(수량 · 계산은 재료산출 몫). 일위대가 조합(`master_combo`)과 같은 결 — +갈라 내기(M02) 때 새 줄 · 본뜬키 = 원래 키. +""" + +from __future__ import annotations + +import master_combo as mcb +import master_keys as mk + +GROUP = "자재조합" +FILE = "자재조합.json" +TID = "UM" +OWNERS = mcb.OWNERS +MAX_이름 = mcb.MAX_이름 +COLS = mk.ROW_ORDER[GROUP] # 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고 +ITEM_COLS = ("코드", "이름", "규격", "단위") + + +def items(row: dict) -> list[dict]: + got = row.get("담은자재") + return got if isinstance(got, list) else [] + + +def check_form(name: str, data: dict) -> list[str]: + """파일 틀 + 줄 — 키 모양 · 열 한 벌 · 이름 · 소유 · 담은 자재(빈 목록 · 모양 · 같은 코드 두 번).""" + out = [] if data.get("그룹") == GROUP else [f"{name} · 머리 그룹이 「{GROUP}」 아님"] + rows = data.get("줄") + if not isinstance(rows, list): + return out + [f"{name} · 머리 「줄」 목록 없음"] + seen_names: dict[str, str] = {} + for row in rows: + key = str(row.get("키")) + where = f"{name} · {key} {row.get('이름') or ''}".strip() + if not mk.KEY.fullmatch(key) or key[:2] != TID: + out.append(f"{where} · 키 모양이 「{TID}」 + 6자리 아님") + if tuple(row) != COLS: + out.append(f"{where} · 열이 한 벌이 아님 — 「{' · '.join(COLS)}」") + plain = row.get("이름").strip() if isinstance(row.get("이름"), str) else "" + if not plain or len(plain) > MAX_이름: + out.append(f"{where} · 「이름」 이 없거나 {MAX_이름}자 넘음") + elif plain in seen_names: + out.append(f"{where} · 「이름」 이 같은 조합과 겹침 — {seen_names[plain]}") + seen_names.setdefault(plain, key) + if row.get("소유") not in OWNERS: + out.append(f"{where} · 소유 「{row.get('소유')}」 — {' · '.join(OWNERS)} 아님") + origin = row.get("본뜬키") + if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == TID): + out.append(f"{where} · 본뜬키 모양 「{origin}」") + got = items(row) + if not got: + out.append(f"{where} · 빈 조합 — 담은 자재가 없음") + codes: set[str] = set() + for at, one in enumerate(got, start=1): + if not isinstance(one, dict) or set(one) - set(ITEM_COLS): + out.append(f"{where} 줄{at} · 담은 자재 줄 모양 「{one}」") + continue + code = str(one.get("코드") or "") + if not mk.KEY.fullmatch(code): + out.append(f"{where} 줄{at} · 자재 코드 모양 아님 「{code}」") + elif code in codes: + out.append(f"{where} 줄{at} · 같은 자재를 두 번 담음 「{code}」") + codes.add(code) + return out diff --git a/resources/master_data/일위대가조합.json b/resources/master_data/일위대가조합.json index 6aee5be4..62c5ce2b 100644 --- a/resources/master_data/일위대가조합.json +++ b/resources/master_data/일위대가조합.json @@ -10,6 +10,7 @@ "상세구분": null, "단위": "식", "담은로직": [{ "로직": "GF000219", "메모": "메쌓기 — 돌쌓기 인력" }, { "로직": "GF000119", "메모": "노체포설 — 굴착기 0.7㎥" }, { "로직": "GF000137", "메모": "운반 — 중기운반 트레일러(20ton)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "브레인이 넣은 견본 · 조합 화면을 바로 볼 수 있게 함 · 지워도 됨" @@ -28,6 +29,7 @@ { "로직": "GF000156", "메모": "콘크리트비빔 채움재 (실무 수는 옛 판 값)" }, { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "글자새김 자당 6*6 — 우리 로직에 없음\n잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00005 · 울진대흥 B01224" @@ -49,6 +51,7 @@ { "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" }, { "로직": "GF000124", "메모": "면고르기" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n측구수로관부설 500∼700kg미만 — 우리 로직에 없음\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00008 · 봉화 B00030 · 영월 B02019 · 영월 B02052 · 영월 B02134" @@ -72,6 +75,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "깬잡석채집 L=45cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00010 · 봉화 B00011 · 봉화 B00022 · 봉화 B00047 · 울진대흥 B01212 · 울진대흥 B01213 · 울진대흥 B01214 · 울진대흥 B01215 · 울진대흥 B01216 · 울진대흥 B01225 · 울진대흥 B01226 · 울진대흥 B01227 · 울진대흥 B01231 · 울진소광 B02122" @@ -95,6 +99,7 @@ { "로직": "GC000015", "메모": "강관동바리 2.5m이하(1개월) (실무 수는 옛 판 값)" }, { "로직": "GC000821", "메모": "잡철물제작및설치(현장) 일반철재" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00012 · 영월 B02002 · 거창 제12호표" @@ -111,6 +116,7 @@ { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" }, { "로직": "GF000162", "메모": "콘크리트포장(B-type) t=20cm (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00014 · 울진대흥 B01232" @@ -122,6 +128,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GF000162", "메모": "콘크리트포장(인력) T=20㎝" }, { "로직": "GC000211", "메모": "합판거푸집(6회) 간단" }, { "로직": "GF000163", "메모": "콘크리트포장절단공 임도 (실무 수는 옛 판 값)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 영월 B02059" @@ -148,6 +155,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈(파쇄석)채집 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00017 · 봉화 B00018 · 봉화 B00029 · 봉화 B00048 · 봉화 B00049 · 봉화 B00055 · 봉화 B00056 · 영월 B01981 · 영월 B01983 · 영월 B01988 · 영월 B02045 · 영월 B02155 · 울진대흥 B01219 · 울진대흥 B01220 · 울진소광 B02120" @@ -168,6 +176,7 @@ { "로직": "GC000677", "메모": "모르터바르기 1:3" }, { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n깬잡석채집 L=60cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n파쇄석 채집 L3=35cm내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.2m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00020 · 봉화 B00032 · 봉화 B00036 · 봉화 B00064 · 울진대흥 B01222 · 울진대흥 B01223 · 울진대흥 B01229 · 울진대흥 B01230 · 울진소광 B02125" @@ -189,6 +198,7 @@ { "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00025" @@ -207,6 +217,7 @@ { "로직": "GC000677", "메모": "모르타르배합 1:3" }, { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "깬잡석채집 L=35cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석소운반(L=35CM) (L=20m) — 우리 로직에 없음\n콘크리트소운반 (L=20m) — 우리 로직에 없음\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00034 · 영월 B02016 · 영월 B02017 · 울진소광 B02124" @@ -223,6 +234,7 @@ { "로직": "GC000206", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" }, { "로직": "GC000207", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00038" @@ -240,6 +252,7 @@ { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" }, { "로직": "GC000712", "메모": "유성페인트칠(붓칠)-황색 콘크리트,모르타르면3회 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00041" @@ -259,6 +272,7 @@ { "로직": "GC000022", "메모": "강관비계 3개월사용 (실무 수는 옛 판 값)" }, { "로직": "GC000211", "메모": "합판거푸집 6회 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00058 · 거창 제5호표 · 거창 제6호표" @@ -275,6 +289,7 @@ { "로직": "GC000206", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" }, { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00062 · 거창 제9호표" @@ -291,6 +306,7 @@ { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" }, { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B00704" @@ -308,6 +324,7 @@ { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" }, { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01982" @@ -325,6 +342,7 @@ { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }, { "로직": "GC000310", "메모": "도로반사경설치 D=1000(STS)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01997" @@ -341,6 +359,7 @@ { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" }, { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B02152" @@ -352,6 +371,7 @@ "상세구분": null, "단위": "㎡", "담은로직": [{ "로직": "GC000149", "메모": "관목식재(단식) H=0.3~0.7m" }, { "로직": "GC000148", "메모": "굴취(관목) H=0.3~0.7m" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "인력운반 기타 — 우리 로직에 없음\n실무 호표 — 계류보전 B01099" @@ -368,6 +388,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02121" @@ -379,6 +400,7 @@ "상세구분": null, "단위": "개소", "담은로직": [{ "로직": "GC000198", "메모": "레미콘타설 무근(장비)" }, { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 울진소광 B02129" @@ -394,6 +416,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02123" @@ -413,6 +436,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "물구멍설치 D=50mm — 우리 로직에 없음\n실무 호표 — 울진소광 B02128" @@ -429,6 +453,7 @@ { "로직": "GC000206", "메모": "철근가공및조립(현장) Type-Ⅱ-1" }, { "로직": "GC000207", "메모": "철근가공및조립(현장) Type-Ⅱ-1" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 거창 제7호표 · 거창 제8호표" @@ -440,6 +465,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 봉화 B00007" @@ -451,6 +477,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n실무 호표 — 봉화 B00039" @@ -462,6 +489,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GC000143", "메모": "평떼붙임 (실무 수는 옛 판 값)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "단끊기 — 우리 로직에 없음\n단끊기 절취없음 — 우리 로직에 없음\n떼 하차비 — 우리 로직에 없음\n실무 호표 — 봉화 B00052 · 울진소광 B02130" @@ -473,6 +501,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기 토사(B/H 90%+인력10%)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "잔토처리 토사(B/H 100%) — 우리 로직에 없음\n실무 호표 — 영월 B01963" @@ -484,6 +513,7 @@ "상세구분": null, "단위": "m", "담은로직": [{ "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" }, { "로직": "GF000124", "메모": "면고르기" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 영월 B01984" @@ -495,6 +525,7 @@ "상세구분": null, "단위": "㎡", "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02133" @@ -506,6 +537,7 @@ "상세구분": null, "단위": "㎡", "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02156" @@ -517,6 +549,7 @@ "상세구분": null, "단위": "개소", "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기(토사) 굴삭기0.7m3 (실무 수는 옛 판 값)" }, { "로직": "GC000105", "메모": "다지기 굴삭기0.7m3 (실무 수는 옛 판 값)" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 울진대흥 B01221" @@ -533,6 +566,7 @@ { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" }, { "로직": "GC000214", "메모": "유로폼 설치 및 해체 보통" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 울진대흥 B01234" @@ -544,6 +578,7 @@ "상세구분": null, "단위": "kg", "담은로직": [{ "로직": "GC000206", "메모": "철근(현장)가공 Type-Ⅰ-----아님 (실무 수는 옛 판 값)" }, { "로직": "GC000207", "메모": "철근(현장)조립 Type-Ⅰ-----아님" }], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 울진소광 B00287" @@ -559,6 +594,7 @@ { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }, { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02119" @@ -574,6 +610,7 @@ { "로직": "GF000155", "메모": "레미콘타설(인력운반타설) 소형구조물" }, { "로직": "GC000211", "메모": "합판거푸집 6회, 간단 (실무 수는 옛 판 값)" } ], + "본뜬키": null, "출처": "자체", "소유": "현장", "비고": "실무 호표 — 거창 제13호표" diff --git a/resources/master_data/자재조합.json b/resources/master_data/자재조합.json new file mode 100644 index 00000000..2e7571f8 --- /dev/null +++ b/resources/master_data/자재조합.json @@ -0,0 +1,6 @@ +{ + "그룹": "자재조합", + "판": "2026", + "비고": ["자재 조합 = 구조물 열 재료산출이 쓰는 자재 목록 묶음 · 수량·계산은 두지 않음(재료산출 몫)"], + "줄": [] +} diff --git a/resources/master_template/구조물집계표조합.json b/resources/master_template/구조물집계표조합.json index 965fc91a..31cb46e1 100644 --- a/resources/master_template/구조물집계표조합.json +++ b/resources/master_template/구조물집계표조합.json @@ -13,6 +13,7 @@ "분류3": "기초유", "단위": "m", "일위대가": "UA000004", + "자재조합": null, "도번": "SD01010100", "면적번": "SA01010100", "재료번": "SM01010100", @@ -76,7 +77,8 @@ "분류2": "1.2m", "분류3": "기초무, 소단", "단위": "m", - "일위대가": null, + "일위대가": "UA000004", + "자재조합": null, "도번": "SD01010101", "면적번": "SA01010101", "재료번": "SM01010101", @@ -91,7 +93,8 @@ "분류2": "1.5m", "분류3": "기초유", "단위": "m", - "일위대가": null, + "일위대가": "UA000004", + "자재조합": null, "도번": "SD01010200", "면적번": "SA01010200", "재료번": "SM01010200", @@ -106,7 +109,8 @@ "분류2": null, "분류3": null, "단위": "m", - "일위대가": null, + "일위대가": "UA000004", + "자재조합": null, "도번": "SD01020000", "면적번": "SA01020000", "재료번": "SM01020000", @@ -122,6 +126,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD02010100", "면적번": "SA02010100", "재료번": "SM02010100", @@ -155,6 +160,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000007", + "자재조합": null, "도번": "SD02010200", "면적번": "SA02010200", "재료번": "SM02010200", @@ -188,6 +194,7 @@ "분류3": null, "단위": "㎡", "일위대가": null, + "자재조합": null, "도번": "SD02010300", "면적번": "SA02010300", "재료번": "SM02010300", @@ -221,6 +228,7 @@ "분류3": null, "단위": "㎡", "일위대가": "UA000006", + "자재조합": null, "도번": "SD02010400", "면적번": "SA02010400", "재료번": "SM02010400", @@ -236,6 +244,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD02010500", "면적번": "SA02010500", "재료번": "SM02010500", @@ -251,6 +260,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD02010600", "면적번": "SA02010600", "재료번": "SM02010600", @@ -266,6 +276,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000036", + "자재조합": null, "도번": "SD03010100", "면적번": "SA03010100", "재료번": "SM03010100", @@ -302,6 +313,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD03010200", "면적번": "SA03010200", "재료번": "SM03010200", @@ -317,6 +329,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000008", + "자재조합": null, "도번": "SD04010100", "면적번": "SA04010100", "재료번": "SM04010100", @@ -364,6 +377,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000014", + "자재조합": null, "도번": "SD05010100", "면적번": "SA05010100", "재료번": "SM05010100", @@ -396,6 +410,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000025", + "자재조합": null, "도번": "SD05010200", "면적번": "SA05010200", "재료번": "SM05010200", @@ -444,6 +459,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD06010000", "면적번": "SA06010000", "재료번": "SM06010000", @@ -480,6 +496,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD07010100", "면적번": "SA07010100", "재료번": "SM07010100", @@ -513,6 +530,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD07010200", "면적번": "SA07010200", "재료번": "SM07010200", @@ -546,6 +564,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000026", + "자재조합": null, "도번": "SD08010100", "면적번": "SA08010100", "재료번": "SM08010100", @@ -576,6 +595,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000003", + "자재조합": null, "도번": "SD08010200", "면적번": "SA08010200", "재료번": "SM08010200", @@ -615,6 +635,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD09010100", "면적번": "SA09010100", "재료번": "SM09010100", @@ -651,6 +672,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD10010100", "면적번": "SA10010100", "재료번": "SM10010100", @@ -697,6 +719,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000032", + "자재조합": null, "도번": "SD11010100", "면적번": "SA11010100", "재료번": "SM11010100", @@ -733,6 +756,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD12010100", "면적번": "SA12010100", "재료번": "SM12010100", @@ -772,6 +796,7 @@ "분류3": null, "단위": "㎡", "일위대가": "UA000031", + "자재조합": null, "도번": "SD12010200", "면적번": "SA12010200", "재료번": "SM12010200", @@ -787,6 +812,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD13010000", "면적번": "SA13010000", "재료번": "SM13010000", @@ -817,6 +843,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD14000000", "면적번": "SA14000000", "재료번": "SM14000000", @@ -835,6 +862,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD15000000", "면적번": "SA15000000", "재료번": "SM15000000", @@ -853,6 +881,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD15010000", "면적번": "SA15010000", "재료번": "SM15010000", @@ -868,6 +897,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD16000000", "면적번": "SA16000000", "재료번": "SM16000000", @@ -886,6 +916,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD17000000", "면적번": "SA17000000", "재료번": "SM17000000", @@ -904,6 +935,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD18000000", "면적번": "SA18000000", "재료번": "SM18000000", @@ -925,6 +957,7 @@ "분류3": null, "단위": "m", "일위대가": null, + "자재조합": null, "도번": "SD19000000", "면적번": "SA19000000", "재료번": "SM19000000", @@ -946,6 +979,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000017", + "자재조합": null, "도번": "SD20000000", "면적번": "SA20000000", "재료번": "SM20000000", @@ -967,6 +1001,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000018", + "자재조합": null, "도번": "SD21000000", "면적번": "SA21000000", "재료번": "SM21000000", @@ -985,6 +1020,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000010", + "자재조합": null, "도번": "SD22000000", "면적번": "SA22000000", "재료번": "SM22000000", @@ -1003,6 +1039,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000016", + "자재조합": null, "도번": "SD23000000", "면적번": "SA23000000", "재료번": "SM23000000", @@ -1021,6 +1058,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000002", + "자재조합": null, "도번": "SD24000000", "면적번": "SA24000000", "재료번": "SM24000000", @@ -1039,6 +1077,7 @@ "분류3": null, "단위": "개소", "일위대가": null, + "자재조합": null, "도번": "SD25010000", "면적번": "SA25010000", "재료번": "SM25010000", @@ -1069,6 +1108,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000005", + "자재조합": null, "도번": "SD26000000", "면적번": "SA26000000", "재료번": "SM26000000", @@ -1084,6 +1124,7 @@ "분류3": null, "단위": "㎡", "일위대가": "UA000009", + "자재조합": null, "도번": "SD27010000", "면적번": "SA27010000", "재료번": "SM27010000", @@ -1099,6 +1140,7 @@ "분류3": null, "단위": "㎡", "일위대가": "UA000009", + "자재조합": null, "도번": "SD27020000", "면적번": "SA27020000", "재료번": "SM27020000", @@ -1114,6 +1156,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000011", + "자재조합": null, "도번": "SD28000000", "면적번": "SA28000000", "재료번": "SM28000000", @@ -1129,6 +1172,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000023", + "자재조합": null, "도번": "SD29000000", "면적번": "SA29000000", "재료번": "SM29000000", @@ -1144,6 +1188,7 @@ "분류3": null, "단위": "m", "일위대가": "UA000012", + "자재조합": null, "도번": "SD30000000", "면적번": "SA30000000", "재료번": "SM30000000", @@ -1159,6 +1204,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000013", + "자재조합": null, "도번": "SD31000000", "면적번": "SA31000000", "재료번": "SM31000000", @@ -1174,6 +1220,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000033", + "자재조합": null, "도번": "SD32000000", "면적번": "SA32000000", "재료번": "SM32000000", @@ -1189,6 +1236,7 @@ "분류3": null, "단위": "개소", "일위대가": "UA000034", + "자재조합": null, "도번": "SD33000000", "면적번": "SA33000000", "재료번": "SM33000000", @@ -1204,6 +1252,7 @@ "분류3": null, "단위": "경간", "일위대가": null, + "자재조합": null, "도번": "SD34000000", "면적번": "SA34000000", "재료번": "SM34000000", @@ -1219,6 +1268,7 @@ "분류3": null, "단위": "㎥", "일위대가": null, + "자재조합": null, "도번": "SD35000000", "면적번": "SA35000000", "재료번": "SM35000000", @@ -1234,6 +1284,7 @@ "분류3": null, "단위": "ton", "일위대가": null, + "자재조합": null, "도번": "SD36000000", "면적번": "SA36000000", "재료번": "SM36000000", diff --git a/resources/tester/test_m02_combo_branch.py b/resources/tester/test_m02_combo_branch.py new file mode 100644 index 00000000..92ab78c1 --- /dev/null +++ b/resources/tester/test_m02_combo_branch.py @@ -0,0 +1,211 @@ +"""조합 갈라 내기 · 분류 더하기 복사 (PLAN 15장). + +M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄. + · 일위대가(UA) — 새로 만듦(본뜬키 = 원래 키) · 이 열만 새 키 · 다른 열은 옛 키 · 원래 조합 그대로 · + SS 장부 맞춤 · 담은 로직 집합(차례 · 메모 무시)이 같으면 있는 키 · 또 고치면 또 새로 · 같은 이름 (2) + · 자재 조합(UM) — 같은 규칙 · 처음 만드는 열(본뜬키 없음) · 읽기 + · 집계표 판 어긋남 = 409 · 조합 안 만듦 + · 분류 더하기로 복사한 열(`본뜬열`) — [저장] 때 원본 키 · 세 파일 내용을 새 번호로 받음 +""" + +import json +import shutil + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from M01_MasterData import M01_MasterData_Store as m01 +from M01_MasterData import M01_MasterData_Store_Combo as combo_store +from M02_MasterTemplete import M02_MasterTemplete_Branch as branch +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete.M02_MasterTemplete_Router import router +from resources.tester.test_m02_structure import write_sample_table + +REAL = m01.FOLDER +A, B, C = "GF000219", "GF000220", "GF000211" # 돌쌓기 메쌓기(인력 · 장비) · 채집(인력) +M1, M2 = ( + {"코드": "MT000001", "이름": "시멘트", "규격": "40kg", "단위": "포"}, + {"코드": "MT000002", "이름": "모래", "규격": None, "단위": "㎥"}, +) +TABLE = "/api/m02/templates/table/구조물집계표" + + +@pytest.fixture() +def client(tmp_path, monkeypatch): + master = tmp_path / "master" + master.mkdir() + for path in REAL.glob("*.json"): + if not path.name.startswith("_") or path.name == m01.mk.BOOK.name: + shutil.copy(path, master / path.name) + for name in (combo_store.FILE, branch.MATERIAL_FILE): + own = master / name + data = json.loads(own.read_text(encoding="utf-8")) + data["줄"] = [] + own.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") + monkeypatch.setattr(m01, "FOLDER", master) + template = tmp_path / "template" + template.mkdir() + write_sample_table(template) + monkeypatch.setattr(store, "FOLDER", template) + app = FastAPI() + app.include_router(router) + return TestClient(app) + + +def _source(client) -> str: + """원래 조합(A · B) — rv · c1 두 열이 같이 가리킴.""" + got = combo_store.combo_new( + { + "이름": "기슭막이", + "구분": "실무 일위대가", + "상세구분": "13장 구조물", + "단위": "m", + "담은로직": [{"로직": A, "메모": None}, {"로직": B, "메모": None}], + "출처": "자체", + }, + "현장", + ) + table = client.get(TABLE).json() + for col in table["문서"]["열"]: + if col["id"] in ("rv", "c1"): + col["일위대가"] = got["key"] + assert client.put(TABLE, json={"판": table["판"], "문서": table["문서"]}).status_code == 200 + return got["key"] + + +def _branch(client, column, source, keys, name="", 판="", want=200): + body = {"본뜬키": source, "담은로직": [{"로직": k} for k in keys], "이름": name, "판": 판} + res = client.post(f"/api/m02/structures/{column}/combo", json=body) + assert res.status_code == want, res.text + return res.json() + + +def _cols(client, field="일위대가") -> dict[str, str | None]: + return {c["id"]: c.get(field) for c in client.get(TABLE).json()["문서"]["열"]} + + +def _ss(client, field="일위대가") -> dict[str, str | None]: + rows = client.get("/api/m02/structure-combos").json()["줄"] + return {r["열"]: r[field] for r in rows} + + +def test_새로_만듦_이_열만_새_키_원래_조합_그대로(client): + ua = _source(client) + 판 = client.get(TABLE).json()["판"] + got = _branch(client, "rv", ua, [A, B, C], "기슭막이 · 돌기슭막이", 판) + assert got["새로만듦"] is True and got["키"] != ua + assert got["이름"] == "기슭막이 · 돌기슭막이" + assert got["집계표판"] == client.get(TABLE).json()["판"] != 판 + cols = _cols(client) + assert (cols["rv"], cols["c1"]) == (got["키"], ua) # 다른 열은 옛 키 + assert _ss(client)["rv"] == got["키"] and _ss(client)["c1"] == ua # SS 장부 맞춤 + new = combo_store.combo(got["키"])["combo"] + assert tuple(new) == combo_store.mcb.COLS # 열 한 벌 · 본뜬키 칸 포함 + assert [x["로직"] for x in new["담은로직"]] == [A, B, C] + assert (new["본뜬키"], new["구분"], new["상세구분"], new["단위"], new["출처"], new["소유"]) == ( + ua, + "실무 일위대가", + "13장 구조물", + "m", + "자체", + "현장", + ) + assert [x["로직"] for x in combo_store.combo(ua)["combo"]["담은로직"]] == [A, B] + # M01 에서 고쳐도(화면이 본뜬키를 안 보내도) 계보는 남음 + one = combo_store.combo(got["키"]) + edited = {k: v for k, v in one["combo"].items() if k != "본뜬키"} | {"이름": "고친 이름"} + combo_store.combo_edit(got["키"], one["version"], edited) + assert combo_store.combo(got["키"])["combo"]["본뜬키"] == ua + + +def test_같은_로직_집합이면_있는_키_또_고치면_또_새로_같은_이름은_2(client): + ua = _source(client) + same = _branch(client, "c1", ua, [B, A]) # 차례만 바꿈 = 원래 조합 + assert (same["키"], same["새로만듦"]) == (ua, False) + first = _branch(client, "rv", ua, [A, B, C], "갈래") + again = _branch(client, "rv", first["키"], [A, C], "갈래") # 갈라 낸 것을 또 고침 = 또 새로 + assert again["새로만듦"] is True and again["키"] not in (ua, first["키"]) + assert again["이름"] == "갈래 (2)" + assert combo_store.combo(again["키"])["combo"]["본뜬키"] == first["키"] + back = _branch(client, "c1", ua, [C, A, B]) # 다른 열이 같게 고침 = 있는 키 + assert (back["키"], back["새로만듦"]) == (first["키"], False) + assert _cols(client)["c1"] == first["키"] and _ss(client)["c1"] == first["키"] + + +def test_집계표_판_어긋나면_409_조합_안_만듦(client): + ua = _source(client) + before = len(m01.read(combo_store.FILE)[0]["줄"]) + _branch(client, "rv", ua, [A, B, C], "x", "0000000000000000", want=409) + assert len(m01.read(combo_store.FILE)[0]["줄"]) == before + assert _cols(client)["rv"] == ua + _branch(client, "no", ua, [A, C], want=404) # 글 열(구조물 아님) + _branch(client, "rv", "UA999999", [A, C], want=404) # 없는 원래 조합 + + +def _material(client, column, source, items, name="", want=200): + body = {"본뜬키": source, "담은자재": items, "이름": name} + res = client.post(f"/api/m02/structures/{column}/material-combo", json=body) + assert res.status_code == want, res.text + return res.json() + + +def test_자재_조합_처음_만듦_같은_내용이면_있는_키_고치면_새로(client): + first = _material(client, "rv", "", [M1, M2]) + assert first["새로만듦"] is True and first["키"].startswith("UM") + assert first["이름"] == "돌기슭막이 (형태마다) H=(높이마다)" # 이름 없으면 열 머리 + row = client.get(f"/api/m02/material-combos/{first['키']}").json() + assert tuple(row) == ("키", "이름", "담은자재", "본뜬키", "소유", "비고") + assert (row["본뜬키"], row["소유"], row["담은자재"]) == (None, "현장", [M1, M2]) + same = _material(client, "c1", "", [M2, M1]) # 차례만 다름 = 있는 키 + assert (same["키"], same["새로만듦"]) == (first["키"], False) + fork = _material(client, "c1", first["키"], [M1], "시멘트만") + assert fork["새로만듦"] is True and fork["키"] != first["키"] + assert client.get(f"/api/m02/material-combos/{fork['키']}").json()["본뜬키"] == first["키"] + assert (_cols(client, "자재조합")["rv"], _cols(client, "자재조합")["c1"]) == ( + first["키"], + fork["키"], + ) + assert _ss(client, "자재조합")["c1"] == fork["키"] + assert client.get("/api/m02/material-combos/UM999999").status_code == 404 + _material(client, "rv", "", [{"코드": "없는모양"}], want=422) # M01 저장 검사 + + +def test_분류_더하기로_복사한_열은_원본_키_세_파일_내용을_받음(client): + ua = _source(client) + table = client.get(TABLE).json() + doc = table["문서"] + rv = next(c for c in doc["열"] if c["id"] == "rv") + rv["자재조합"] = "UM000001" + assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200 + drawing = client.get("/api/m02/templates/structure/rv").json() + marked = {**drawing["문서"], "도면": {"format": 6, "entities": [{"type": "line"}]}} + put = client.put("/api/m02/templates/structure/rv", json={"판": drawing["판"], "문서": marked}) + assert put.status_code == 200 + table = client.get(TABLE).json() + doc = table["문서"] + at = next(i for i, c in enumerate(doc["열"]) if c["id"] == "rv") + head = ["돌기슭막이", "(형태마다)", "H=(높이마다) 2", None] + doc["열"].insert(at + 1, {"id": "c9", "머리": head, "단위": None, "꼴": "수", "본뜬열": "rv"}) + assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200 + saved = next(c for c in client.get(TABLE).json()["문서"]["열"] if c["id"] == "c9") + assert "본뜬열" not in saved # 뗌 + assert (saved["일위대가"], saved["자재조합"]) == (ua, "UM000001") + copy = client.get("/api/m02/templates/structure/c9").json()["문서"] + assert copy["도면"]["entities"] == [{"type": "line"}] and copy["열"] == "c9" + numbers = client.get("/api/m02/structures/numbers").json() + assert numbers["c9"]["도번"] != numbers["rv"]["도번"] # 새 번호 + assert numbers["c9"]["면적번"][2:] == numbers["c9"]["도번"][2:] + for kind in ("area", "material"): + assert client.get(f"/api/m02/templates/{kind}/c9").json()["문서"]["열"] == "c9" + # 그 뒤로는 열마다 따로 — 원본을 고쳐도 복사본은 그대로 + drawing = client.get("/api/m02/templates/structure/rv").json() + client.put( + "/api/m02/templates/structure/rv", + json={ + "판": drawing["판"], + "문서": {**drawing["문서"], "도면": marked["도면"] | {"entities": []}}, + }, + ) + again = client.get("/api/m02/templates/structure/c9").json()["문서"] + assert again["도면"]["entities"] == [{"type": "line"}] diff --git a/ui_template/sheet/ui_template_sheet_ops.ts b/ui_template/sheet/ui_template_sheet_ops.ts index dbc5f1fc..4e28211a 100644 --- a/ui_template/sheet/ui_template_sheet_ops.ts +++ b/ui_template/sheet/ui_template_sheet_ops.ts @@ -141,7 +141,16 @@ export function addLevel( "c", doc.열.map((c) => c.id), ); - doc.열.splice(at + 1, 0, { id, 머리: head, 단위: base.단위 ?? null, 꼴: "수" }); + // 원본(`after`) 열을 따라감 — 일위대가 · 자재조합 같은 키 · 구조물 파일은 저장 때 서버가 복사 + doc.열.splice(at + 1, 0, { + id, + 머리: head, + 단위: base.단위 ?? null, + 꼴: "수", + ...(base.꼴 !== "글" + ? { 본뜬열: base.id, 일위대가: base.일위대가 ?? null, 자재조합: base.자재조합 ?? null } + : {}), + }); return id; } diff --git a/ui_template/sheet/ui_template_sheet_types.ts b/ui_template/sheet/ui_template_sheet_types.ts index 26673614..b89a9d72 100644 --- a/ui_template/sheet/ui_template_sheet_types.ts +++ b/ui_template/sheet/ui_template_sheet_types.ts @@ -35,6 +35,10 @@ export interface SheetColumn { 바인딩?: SheetBinding | null; /** 일위대가 조합 키. */ 일위대가?: string | null; + /** 자재 조합 키(`UM`). */ + 자재조합?: string | null; + /** 분류 더하기로 복사한 원본 열 id — 저장 때 서버가 원본 열 내용을 새 열로 복사하고 뗌. */ + 본뜬열?: string | null; /** 마스터 한 칸 → 프로젝트에서 설계 값마다 열. */ 펼침?: boolean; /** 사용자 입력 열. */ From 1904cd5072de2b8fcf6881cab40f20af8a8d46ca Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 28 Sep 2026 19:00:53 +0900 Subject: [PATCH 2/3] =?UTF-8?q?wip(M01):=20=EC=9E=90=EC=9E=AC=20=EC=A1=B0?= =?UTF-8?q?=ED=95=A9=20M01=20=EA=B8=B8=20=EC=B4=88=EC=95=88=20=E2=80=94=20?= =?UTF-8?q?=ED=95=A9=EC=B9=98=EA=B8=B0=20=EC=A0=84=20=EC=9E=84=EC=8B=9C(su?= =?UTF-8?q?b4=20=EC=9E=90=EC=9E=AC=EC=A1=B0=ED=95=A9=20=ED=91=9C=20?= =?UTF-8?q?=EC=9C=84=EC=97=90=20=EC=96=B9=EC=9D=84=20=EC=98=88=EC=A0=95)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01RoyUwuTFiDJfvCfHpvKKzp --- M01_MasterData/M01_MasterData_Router.py | 41 ++++++ M01_MasterData/M01_MasterData_Store_Combo.py | 10 +- M01_MasterData/M01_MasterData_Store_Matset.py | 125 ++++++++++++++++++ resources/master_data/_화면_계약.md | 16 +++ resources/tester/test_m01_matset.py | 107 +++++++++++++++ 5 files changed, 296 insertions(+), 3 deletions(-) create mode 100644 M01_MasterData/M01_MasterData_Store_Matset.py create mode 100644 resources/tester/test_m01_matset.py diff --git a/M01_MasterData/M01_MasterData_Router.py b/M01_MasterData/M01_MasterData_Router.py index a411a2cb..942a1ecd 100644 --- a/M01_MasterData/M01_MasterData_Router.py +++ b/M01_MasterData/M01_MasterData_Router.py @@ -15,6 +15,7 @@ from pydantic import BaseModel from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Combo as combo_store from M01_MasterData import M01_MasterData_Store_Make as make +from M01_MasterData import M01_MasterData_Store_Matset as matset_store router = APIRouter(prefix="/api/m01", tags=["M01 MasterData"]) @@ -114,6 +115,20 @@ class PreviewCombo(BaseModel): inputs: dict[str, dict[str, Any]] = {} +class NewMatset(BaseModel): + """자재 조합 — 담은 자재 목록만(코드 · 이름 · 규격 · 단위 · 수량 · 단가는 안 둠).""" + + matset: dict[str, Any] + owner: str = matset_store.OWNERS[0] + + +class EditMatset(BaseModel): + key: str + version: str + matset: dict[str, Any] + owner: str = "" + + class DraftLogic(BaseModel): text: str # 줄로 적은 식 — 줄마다 「이름 = 식」 decided: dict[str, Any] = {} # 변수마다 정한 것 {이름: {무엇, 단위, 비목, 요소·찾기·값}} @@ -349,3 +364,29 @@ def post_combo_delete(body: DeleteCombo) -> dict: def post_combo_preview(body: PreviewCombo) -> dict: """담은 로직마다 값을 뽑아 비목별로 갈라 합계 — 저장하지 않음.""" return _call(combo_store.combo_preview, body.combo, body.inputs) + + +# ── 자재 조합(계약 9장 끝) ───────────────────────────────────────────── +@router.get("/matsets") +def get_matsets(q: str = "", owner: str = "") -> dict: + return {"matsets": _call(matset_store.matsets, q, owner)} + + +@router.get("/matset") +def get_matset(key: str) -> dict: + return _call(matset_store.matset, key) + + +@router.post("/matset/new") +def post_matset_new(body: NewMatset) -> dict: + return _call(matset_store.matset_new, body.matset, body.owner) + + +@router.post("/matset/edit") +def post_matset_edit(body: EditMatset) -> dict: + return _call(matset_store.matset_edit, body.key, body.version, body.matset, body.owner) + + +@router.post("/matset/delete") +def post_matset_delete(body: DeleteCombo) -> dict: + return _call(matset_store.matset_delete, body.key, body.version) diff --git a/M01_MasterData/M01_MasterData_Store_Combo.py b/M01_MasterData/M01_MasterData_Store_Combo.py index d9c18b69..3e98de46 100644 --- a/M01_MasterData/M01_MasterData_Store_Combo.py +++ b/M01_MasterData/M01_MasterData_Store_Combo.py @@ -218,15 +218,15 @@ def combo_edit(key: str, version: str, combo_: dict, owner: str = "") -> dict: return {**done, "combo": _find(store.read(FILE)[0], key)} -def combo_users(key: str) -> list[str]: - """이 조합을 「일위대가」 로 쓰는 구조물 열 이름들 — 집계표 · SS 장부를 함께 봄.""" +def users_of(field: str, key: str) -> list[str]: + """집계표 · SS 장부에서 열 칸 `field`(「일위대가」 · 「자재조합」)가 `key` 인 열 이름들.""" names: dict[str, str] = {} for path in USERS: if not path.is_file(): continue doc = json.loads(path.read_text(encoding="utf-8")) for col in doc.get("열") or doc.get("줄") or []: - if col.get("일위대가") != key: + if col.get(field) != key: continue head = col.get("머리") or [col.get(k) for k in ("종류", "분류1", "분류2", "분류3")] cid = str(col.get("id") or col.get("열")) @@ -234,6 +234,10 @@ def combo_users(key: str) -> list[str]: return list(names.values()) +def combo_users(key: str) -> list[str]: + return users_of("일위대가", key) + + def combo_delete(key: str, version: str) -> dict: data, _ = _read() _find(data, key) diff --git a/M01_MasterData/M01_MasterData_Store_Matset.py b/M01_MasterData/M01_MasterData_Store_Matset.py new file mode 100644 index 00000000..e3692168 --- /dev/null +++ b/M01_MasterData/M01_MasterData_Store_Matset.py @@ -0,0 +1,125 @@ +"""M01 자재 조합 저장소 — 목록 · 하나 읽기 · 만들기 · 고치기 · 지우기. + +계약: `_화면_계약.md` 9장 끝 · 파일 모양: `_틀.md` 11장 · 엔진: `scripts/master_matset.py`. +조합은 담은 자재 목록(코드 · 이름 · 규격 · 단위)만 지님 — 수량 · 단가는 두지 않음(재료산출 몫). +자리는 `자재조합.json` 한 파일 · 키는 `_키대장.json` 의 `UM` 다음 번호(서버가 줌). +""" + +from __future__ import annotations + +from datetime import date +from pathlib import Path + +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Combo as combos + +cm = store.cm +msk = cm.msk + +FILE = msk.FILE +OWNERS = msk.OWNERS + + +def _path() -> Path: + return store.FOLDER / FILE + + +def _make_file() -> None: + """파일이 없으면 머리만 두고 만듦.""" + if not _path().is_file(): + head = {"그룹": msk.GROUP, "판": str(date.today().year), "줄": []} + _path().write_text(store.dump(head), encoding="utf-8", newline="\n") + + +def _read() -> tuple[dict, str]: + _make_file() + return store.read(FILE) + + +def _keys() -> list[str]: + return [str(r.get("키")) for r in _read()[0].get("줄") or []] + + +def _find(data: dict, key: str) -> dict: + for row in data.get("줄") or []: + if str(row.get("키")) == key: + return row + raise store.StoreError(404, f"없는 자재 조합 「{key}」") + + +def _clean(one: dict, owner: str, key: str | None = None) -> dict: + """서버가 잡는 칸 — 키 · 소유 · 열 한 벌(안 준 칸은 null · 자재 줄은 네 칸만).""" + if not isinstance(one, dict): + raise store.StoreError(400, "자재 조합 줄이 묶음 아님") + name = one.get("이름") + if not isinstance(name, str) or not name.strip(): + raise store.StoreError(400, "자재 조합 줄에 「이름」 이 없거나 글자 아님") + if owner not in OWNERS: + raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}") + origin = one.get("본뜬키") + if origin is not None and (origin == key or origin not in _keys()): + raise store.StoreError(400, f"본뜬키 「{origin}」 — 비었거나 있는 다른 자재 조합 키여야 함") + got = one.get("담은자재") + if isinstance(got, list): # 화면이 덤을 실어도 자재 줄은 네 칸만 · 안 준 칸은 빈 글 + got = [{c: m.get(c, "") for c in msk.ITEM_COLS} if isinstance(m, dict) else m for m in got] + rest = {k: v for k, v in one.items() if k not in ("키", "원문번호", "소유")} + row = {**({"키": key} if key else {}), "소유": owner, **rest, "담은자재": got or []} + for col in msk.COLS: + row.setdefault(col, None) + return {k: row[k] for k in msk.COLS if k in row} + + +def _write(changes: list[dict], version: str | None = None) -> dict: + _make_file() + return store.save( + [{"file": FILE, "version": version or store.read(FILE)[1], "changes": changes}] + )[0] + + +def matsets(q: str = "", owner: str = "") -> list[dict]: + """목록 — 찾기(이름 · 키)와 소유로 거름 · 줄마다 자재 수.""" + out = [] + for _, row in msk.rows(store.loaded()[0]): + if owner and row.get("소유") != owner: + continue + if not store._hit(row, q): + continue + out.append( + {k: row.get(k) for k in msk.COLS if k != "담은자재"} + | {"file": FILE, "count": len(msk.items(row))} + ) + return out + + +def matset(key: str) -> dict: + data, version = _read() + return {"file": FILE, "version": version, "matset": _find(data, key)} + + +def matset_new(one: dict, owner: str = OWNERS[0]) -> dict: + """새 자재 조합 — 키는 서버가 `UM` 다음 번호로 줌.""" + before = set(_keys()) + done = _write([{"op": "add", "row": _clean(one, owner)}]) + key = next((k for k in reversed(_keys()) if k not in before), "") + return {**done, "key": key, "matset": _find(_read()[0], key) if key else {}} + + +def matset_edit(key: str, version: str, one: dict, owner: str = "") -> dict: + data, _ = _read() + was = _find(data, key) + if store.read(FILE)[1] != version: + raise store.StoreError(409, {"stale": [FILE]}) + fixed = _clean(one, owner or str(was.get("소유") or OWNERS[0]), key) + done = _write([{"op": "edit", "key": key, "row": fixed}], version) + return {**done, "matset": _find(_read()[0], key)} + + +def matset_delete(key: str, version: str) -> dict: + """지우기 — 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들(지우지 않음).""" + _find(_read()[0], key) + if users := combos.users_of("자재조합", key): + msg = f"구조물 {len(users)} 곳이 쓰는 자재 조합이라 못 지움 — {' · '.join(users)}" + raise store.StoreError(409, {"errors": [msg], "users": users}) + if store.read(FILE)[1] != version: + raise store.StoreError(409, {"stale": [FILE]}) + return _write([{"op": "delete", "key": key}], version) diff --git a/resources/master_data/_화면_계약.md b/resources/master_data/_화면_계약.md index 2199db1d..78400935 100644 --- a/resources/master_data/_화면_계약.md +++ b/resources/master_data/_화면_계약.md @@ -196,6 +196,22 @@ - 못 도는 줄은 통째로 멈추지 않고 그 줄만 `ok` false · `까닭` · `멈춤` 에 한 줄 — 나머지 줄의 합계는 그대로 냄. - 답 — 200 · 400(틀린 몸 · 이름 없음 · 모르는 소유) · 404(없는 키) · 409(낡은 판본) · 422 `{detail: {errors: […]}}`(검사 걸림 — 없는 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음). +### 자재 조합 + +재료산출에서 쓸 **자재 목록 묶음**(파일 `자재조합.json` · 키 `UM` · `_틀.md` 11장). 담은 자재 `{코드, 이름, 규격, 단위}` 만 지님 — 수량 · 단가 없음. 요소 그룹이 아님(`/groups` · `/rows` 에 안 끼고 제 길로만). + +| 길 | 받음 | 줌 | +| --------------------- | ------------------------------- | ------------------------------------------- | +| `GET /matsets` | `q?` `owner?` | `{matsets: […]}` — 줄마다 `count` (자재 수) | +| `GET /matset` | `key` | `{file, version, matset}` | +| `POST /matset/new` | `{matset, owner?}` | `{file, version, key, matset}` | +| `POST /matset/edit` | `{key, version, matset, owner?}` | `{file, version, matset}` | +| `POST /matset/delete` | `{key, version}` | `{file, version}` | + +- 답 — 200 · 400(이름 없음 · 모르는 소유 · 없는/자기 본뜬키) · 404 · 409(낡은 판본 · 지우기 막음) · 422(없는 자재 코드 · 같은 자재 두 번 · 자재 줄 모양). +- 지우기는 구조물집계표 · `구조물집계표조합` 의 「자재조합」 칸으로 쓰는 열이 있으면 409 `{detail: {errors: […], users: [구조물 이름…]}}` — 지우지 않음. +- M02 화면이 새로 만드는 조합도 같은 파일 · 같은 길이라 M01 목록에 같이 보임. + ## 10. 재료 · 기계 고르기 재료 줄은 키 대신 기본 검색어로 품목을 찾음 — 파일 모양 · 찾기 규칙 · 자동값 차례 · 단위 환산은 `_틀.md` 7장. diff --git a/resources/tester/test_m01_matset.py b/resources/tester/test_m01_matset.py new file mode 100644 index 00000000..58ff30cc --- /dev/null +++ b/resources/tester/test_m01_matset.py @@ -0,0 +1,107 @@ +"""M01 자재 조합(`/api/m01/matset…` · 파일 `자재조합.json` · 키 UM) — 담은 자재 목록만 지님. + +못박는 것 + - 새로 만들면 키를 서버가 `UM` 다음 번호로 줌 · 열 한 벌 · 담은 자재는 네 칸. + - 없는 자재 코드 · 같은 자재 두 번 · 이름 없음 · 없는 본뜬키는 막음. + - 고치기는 낡은 판본이면 409 · 지우기는 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들. + - 정본은 읽기만 함(사본 폴더 · 사본 집계표). +""" + +from __future__ import annotations + +import json +import shutil +from pathlib import Path + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient + +from M01_MasterData import M01_MasterData_Router as router_module +from M01_MasterData import M01_MasterData_Store as store +from M01_MasterData import M01_MasterData_Store_Combo as combo_store + +ROOT = Path(__file__).resolve().parents[2] + + +@pytest.fixture +def client(tmp_path: Path, monkeypatch) -> TestClient: + for path in store.FOLDER.glob("*.json"): + if not path.name.startswith("_") or path.name == store.mk.BOOK.name: + shutil.copy(path, tmp_path / path.name) + monkeypatch.setattr(store, "FOLDER", tmp_path) + sheet = tmp_path / "집계표.json" + sheet.write_text(json.dumps({"열": []}), encoding="utf-8") + monkeypatch.setattr(combo_store, "USERS", (sheet,)) + app = FastAPI() + app.include_router(router_module.router) + return TestClient(app) + + +def _mat(client: TestClient) -> dict: + """자재품목에서 실제 줄 하나 — 자재 찾기 길 그대로.""" + got = client.get("/api/m01/pick", params={"kind": "price", "q": "합판", "limit": 2}).json() + one = got["items"][0] + return {"코드": one["ref"], "이름": one["이름"], "규격": one["규격"], "단위": one["단위"]} + + +def _new(client: TestClient, name: str, mats: list[dict], **more) -> dict: + body = {"matset": {"이름": name, "담은자재": mats, **more}} + return client.post("/api/m01/matset/new", json=body) + + +def test_정본_자재조합_파일은_틀대로다() -> None: + data = json.loads((ROOT / "resources/master_data/자재조합.json").read_text(encoding="utf-8")) + assert data["그룹"] == "자재조합" and isinstance(data["줄"], list) + assert store.cm.msk.check_form("자재조합.json", data) == [] + assert '"UM"' in (ROOT / "resources/master_data/_키대장.json").read_text(encoding="utf-8") + + +def test_새로_만들면_UM_키와_열_한_벌(client) -> None: + mat = _mat(client) + res = _new(client, "합판 자재", [{**mat, "덤": 1}]) + assert res.status_code == 200, res.text + made = res.json() + assert made["key"].startswith("UM") and len(made["key"]) == 8 + assert tuple(made["matset"]) == store.cm.msk.COLS + assert made["matset"]["담은자재"] == [mat] and made["matset"]["본뜬키"] is None + rows = client.get("/api/m01/matsets").json()["matsets"] + assert [(r["키"], r["count"]) for r in rows] == [(made["key"], 1)] + got = client.get("/api/m01/matset", params={"key": made["key"]}).json() + assert got["matset"]["이름"] == "합판 자재" + + +def test_없는_자재_두_번_담기_이름_본뜬키는_막는다(client) -> None: + mat = _mat(client) + assert _new(client, "없는 코드", [{**mat, "코드": "MT999999"}]).status_code == 422 + assert _new(client, "두 번", [mat, mat]).status_code == 422 + assert _new(client, " ", [mat]).status_code == 400 + assert _new(client, "없는 원본", [mat], 본뜬키="UM999999").status_code == 400 + ok = _new(client, "원본", [mat]).json()["key"] + assert _new(client, "본뜬 것", [mat], 본뜬키=ok).json()["matset"]["본뜬키"] == ok + assert _new(client, "원본", [mat]).status_code == 422 # 이름 겹침 + + +def test_고치기는_낡은_판본이면_409(client) -> None: + mat = _mat(client) + key = _new(client, "고칠 것", [mat]).json()["key"] + one = client.get("/api/m01/matset", params={"key": key}).json() + body = {"key": key, "version": one["version"], "matset": {**one["matset"], "이름": "고침"}} + assert client.post("/api/m01/matset/edit", json=body).status_code == 200 + assert client.post("/api/m01/matset/edit", json=body).status_code == 409 # 같은 옛 판본 + + +def test_쓰는_열이_있으면_못_지우고_없으면_지워진다(client) -> None: + mat = _mat(client) + key = _new(client, "쓰는 것", [mat]).json()["key"] + cols = [{"id": "c9", "머리": ["돌붙임", "찰붙임", "", ""], "자재조합": key}] + combo_store.USERS[0].write_text(json.dumps({"열": cols}, ensure_ascii=False), encoding="utf-8") + version = client.get("/api/m01/matset", params={"key": key}).json()["version"] + res = client.post("/api/m01/matset/delete", json={"key": key, "version": version}) + assert res.status_code == 409 and res.json()["detail"]["users"] == ["돌붙임 찰붙임"] + combo_store.USERS[0].write_text(json.dumps({"열": []}), encoding="utf-8") + assert ( + client.post("/api/m01/matset/delete", json={"key": key, "version": version}).status_code + == 200 + ) + assert client.get("/api/m01/matset", params={"key": key}).status_code == 404 From d35269e32aae59d8c111ceead4f31b17768f9945 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Mon, 28 Sep 2026 19:08:20 +0900 Subject: [PATCH 3/3] =?UTF-8?q?feat(M01):=20=EC=9E=90=EC=9E=AC=20=EC=A1=B0?= =?UTF-8?q?=ED=95=A9=20M01=20=EA=B8=B8=20=E2=80=94=20=EB=AA=A9=EB=A1=9D=20?= =?UTF-8?q?=C2=B7=20=ED=95=98=EB=82=98=20=C2=B7=20=EC=83=88=EB=A1=9C=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(=EC=93=B0=EB=8A=94=20=EC=97=B4=20=EC=9E=88?= =?UTF-8?q?=EC=9C=BC=EB=A9=B4=20=EB=A7=89=EC=9D=8C)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - /api/m01/matsets · matset · matset/new|edit|delete — sub4 의 자재조합.json(UM) 위에 얹음 · 담은 자재 코드가 마스터에 없으면 422 · 본뜬키는 있는 다른 UM 만 - 지우기 전 집계표 · 구조물집계표조합의 「자재조합」 칸을 훑어 쓰는 열이 있으면 409 + 구조물 이름들 - 일위대가 · 자재 조합 지우기 검사가 users_of 한 곳을 씀 · 계약 9장 「자재 조합」 표 더함 - 시험 다섯(resources/tester/test_m01_matset.py) Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01RoyUwuTFiDJfvCfHpvKKzp --- M01_MasterData/M01_MasterData_Store_Matset.py | 15 +++++++++++++-- resources/tester/test_m01_matset.py | 4 ++-- 2 files changed, 15 insertions(+), 4 deletions(-) diff --git a/M01_MasterData/M01_MasterData_Store_Matset.py b/M01_MasterData/M01_MasterData_Store_Matset.py index e3692168..08308fdc 100644 --- a/M01_MasterData/M01_MasterData_Store_Matset.py +++ b/M01_MasterData/M01_MasterData_Store_Matset.py @@ -14,7 +14,7 @@ from M01_MasterData import M01_MasterData_Store as store from M01_MasterData import M01_MasterData_Store_Combo as combos cm = store.cm -msk = cm.msk +msk = cm.mmc # sub4 가 세운 자재 조합 엔진(`scripts/master_material_combo.py`) FILE = msk.FILE OWNERS = msk.OWNERS @@ -63,12 +63,23 @@ def _clean(one: dict, owner: str, key: str | None = None) -> dict: if isinstance(got, list): # 화면이 덤을 실어도 자재 줄은 네 칸만 · 안 준 칸은 빈 글 got = [{c: m.get(c, "") for c in msk.ITEM_COLS} if isinstance(m, dict) else m for m in got] rest = {k: v for k, v in one.items() if k not in ("키", "원문번호", "소유")} + _check_codes(got) row = {**({"키": key} if key else {}), "소유": owner, **rest, "담은자재": got or []} for col in msk.COLS: row.setdefault(col, None) return {k: row[k] for k in msk.COLS if k in row} +def _check_codes(got) -> None: + """담은 자재 코드가 마스터 어느 줄에도 없으면 422 — 틀 검사는 저장 길(`store.save`)이 함.""" + if not isinstance(got, list) or not got: + return + known = {str(r.get("키")) for d in store.loaded()[0].values() for r in d.get("줄") or []} + lost = [str(m.get("코드")) for m in got if isinstance(m, dict) and m.get("코드") not in known] + if lost: + raise store.StoreError(422, {"errors": [f"마스터에 없는 자재 {' · '.join(lost)}"]}) + + def _write(changes: list[dict], version: str | None = None) -> dict: _make_file() return store.save( @@ -79,7 +90,7 @@ def _write(changes: list[dict], version: str | None = None) -> dict: def matsets(q: str = "", owner: str = "") -> list[dict]: """목록 — 찾기(이름 · 키)와 소유로 거름 · 줄마다 자재 수.""" out = [] - for _, row in msk.rows(store.loaded()[0]): + for row in store.loaded()[0].get(FILE, {}).get("줄") or []: if owner and row.get("소유") != owner: continue if not store._hit(row, q): diff --git a/resources/tester/test_m01_matset.py b/resources/tester/test_m01_matset.py index 58ff30cc..7be0f59b 100644 --- a/resources/tester/test_m01_matset.py +++ b/resources/tester/test_m01_matset.py @@ -53,7 +53,7 @@ def _new(client: TestClient, name: str, mats: list[dict], **more) -> dict: def test_정본_자재조합_파일은_틀대로다() -> None: data = json.loads((ROOT / "resources/master_data/자재조합.json").read_text(encoding="utf-8")) assert data["그룹"] == "자재조합" and isinstance(data["줄"], list) - assert store.cm.msk.check_form("자재조합.json", data) == [] + assert store.cm.mmc.check_form("자재조합.json", data) == [] assert '"UM"' in (ROOT / "resources/master_data/_키대장.json").read_text(encoding="utf-8") @@ -63,7 +63,7 @@ def test_새로_만들면_UM_키와_열_한_벌(client) -> None: assert res.status_code == 200, res.text made = res.json() assert made["key"].startswith("UM") and len(made["key"]) == 8 - assert tuple(made["matset"]) == store.cm.msk.COLS + assert tuple(made["matset"]) == store.cm.mmc.COLS assert made["matset"]["담은자재"] == [mat] and made["matset"]["본뜬키"] is None rows = client.get("/api/m01/matsets").json()["matsets"] assert [(r["키"], r["count"]) for r in rows] == [(made["key"], 1)]