Merge remote-tracking branches 'origin/main_laptop_1' and 'origin/sub_laptop_1' into sub_laptop_5
This commit is contained in:
@@ -22,7 +22,9 @@ from __future__ import annotations
|
||||
import copy as cp
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from decimal import Decimal
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
@@ -33,7 +35,6 @@ _SCRIPTS = str(Path(__file__).resolve().parents[1] / "resources/master_data/scri
|
||||
if _SCRIPTS not in sys.path:
|
||||
sys.path.insert(0, _SCRIPTS)
|
||||
|
||||
import master_auto as mau # noqa: E402
|
||||
import master_doc as md # noqa: E402
|
||||
import master_doc_calc as mc # noqa: E402
|
||||
import master_doc_convert as cv # noqa: E402
|
||||
@@ -262,17 +263,121 @@ def _apart(doc: dict, lines: list[dict], n: int) -> None:
|
||||
later[slot] = md.text_of(_plus(node, cost, sym))
|
||||
|
||||
|
||||
def given_of(whole: Any, code: str, given: Any) -> dict:
|
||||
"""옛 `run_line` 과 같은 입력 — 빈 입력 = 자동값(M01 줄) › 받은 값."""
|
||||
def given_of(whole: Any, code: str, given: Any, docs: dict | None = None) -> dict:
|
||||
"""옛 `run_line` 과 같은 입력 — 빈 입력 = 자동값(`auto_of` · 문서 = `docs` › 값 사본 줄 문서) ›
|
||||
받은 값."""
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
|
||||
try:
|
||||
auto = {k: v for k, v in mau.values(whole, whole.logic(code)).items() if v is not None}
|
||||
doc = (docs or {}).get(code) or doc_of(whole, code)
|
||||
auto = {k: v for k, v in auto_of(doc, whole).items() if v is not None} if doc else {}
|
||||
except _ERR:
|
||||
auto = {}
|
||||
return {**auto, **m01._dec(given or {})}
|
||||
|
||||
|
||||
# ── 자동값(옛 `master_auto.values` 같은 규칙 · 문서에서 · 855-F B9-6) ──────────
|
||||
_GUARD = re.compile(r"만약\(\s*(\w+)\s*>\s*0\s*,\s*\1\s*,")
|
||||
_INPUTS = ("입력", "선택")
|
||||
|
||||
|
||||
def _num(v: Any) -> Any:
|
||||
try:
|
||||
return Decimal(str(v)) if not isinstance(v, Decimal) else v
|
||||
except ArithmeticError:
|
||||
return v
|
||||
|
||||
|
||||
def _fits(whole: Any, ref: str, cond: str) -> list:
|
||||
"""표 `ref` 조건 칸 `cond` 에 드는 수 — 낮은 차례 · 범위 칸 = 줄마다 그 줄에 드는 끝."""
|
||||
try:
|
||||
table = whole.get(ref)
|
||||
except _ERR:
|
||||
return []
|
||||
ranged = (table.get("조건") or {}).get(cond) == "범위"
|
||||
out = set()
|
||||
for r in table.get("줄") or []:
|
||||
if r.get(cond) is None:
|
||||
continue
|
||||
low, high = r[cond] if ranged else (r[cond], None)
|
||||
ends = [Decimal(0) if low is None else low, high]
|
||||
out |= {v for v in ends if isinstance(v, Decimal) and ml._match(table, r, cond, v)}
|
||||
return sorted(out)
|
||||
|
||||
|
||||
def _lowest(whole: Any, uses: list) -> Any:
|
||||
"""같은 입력을 여러 표가 쓰면 모두에 드는 가장 낮은 수 · 없으면 첫 표의 가장 낮은 수."""
|
||||
sets = [_fits(whole, ref, cond) for ref, cond in uses]
|
||||
both = sorted(set.intersection(*map(set, sets))) if sets else []
|
||||
return (both or next((s for s in sets if s), [None]))[0]
|
||||
|
||||
|
||||
def _divisors(doc: dict, ids: dict) -> set[str]:
|
||||
"""나누는 자리에 든 이름 — 그 이름이 쓰는 이름(식 · 표 조건 · 단가산출 넘긴 입력)까지 ·
|
||||
「만약(X > 0, X, 기본)」 의 X 는 안 퍼뜨림."""
|
||||
texts = [x.get("식") for x in doc.get("식") or []]
|
||||
texts += [(doc.get("결과") or {}).get("식") if isinstance(doc.get("결과"), dict) else None]
|
||||
texts += [x.get(k) for x in doc.get("금액") or [] for k in ("수량", "단가")]
|
||||
divs, guard = set(), set()
|
||||
for text in (x for x in texts if x not in (None, "")):
|
||||
guard |= set(_GUARD.findall(str(text)))
|
||||
try:
|
||||
divs |= {
|
||||
n for p in md.walk(md.parse(text)) if p[:2] == ("bin", "/") for n in md.names(p[3])
|
||||
}
|
||||
except md.DocError:
|
||||
continue
|
||||
feeds: dict[str, list] = {}
|
||||
for x in doc.get("식") or []:
|
||||
feeds.setdefault(md.var_id(x), []).append(x.get("식"))
|
||||
for vid, v in ids.items():
|
||||
link = v.get("연결") or {}
|
||||
part = {"표": "조건", "단가산출": "입력"}.get(str(link.get("갈래")))
|
||||
if part:
|
||||
feeds.setdefault(vid, []).extend((link.get(part) or {}).values())
|
||||
todo = list(divs)
|
||||
while todo:
|
||||
for text in feeds.get(todo.pop(), []):
|
||||
try:
|
||||
more = set(md.names(md.parse(text))) - guard - divs
|
||||
except md.DocError:
|
||||
continue
|
||||
divs |= more
|
||||
todo += list(more)
|
||||
return divs
|
||||
|
||||
|
||||
def auto_of(doc: dict, whole: Any) -> dict:
|
||||
"""문서 입력마다 자동값 — 고르기 = 목록 첫째 · 범위 = 아래 끝 · 표 조건 값 = 그 표 가장 낮은
|
||||
수 · 나누는 자리 = 1 · 그 밖 0 · 가격(원) 입력 = None(1,521 문서 옛 `master_auto` 와 같음)."""
|
||||
ids = {md.var_id(v): v for v in doc.get("변수") or []}
|
||||
finds: dict[str, list] = {}
|
||||
for v in ids.values():
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") == "표":
|
||||
for col, arg in (link.get("조건") or {}).items():
|
||||
if isinstance(arg, str) and arg in ids:
|
||||
finds.setdefault(arg, []).append((link.get("표"), col))
|
||||
divs = _divisors(doc, ids)
|
||||
out: dict[str, Any] = {}
|
||||
for vid, v in ids.items():
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") not in _INPUTS or not v.get("열쇠"):
|
||||
continue
|
||||
name = str(v["열쇠"])
|
||||
if link.get("목록"):
|
||||
out[name] = link["목록"][0]
|
||||
elif link.get("범위"):
|
||||
out[name] = _num(link["범위"][0])
|
||||
else:
|
||||
got = _lowest(whole, finds.get(vid, []))
|
||||
if got is None and "원" in str(v.get("단위") or ""):
|
||||
out[name] = None
|
||||
else:
|
||||
out[name] = got if got is not None else Decimal(1 if vid in divs else 0)
|
||||
return out
|
||||
|
||||
|
||||
def apart_of(marks: Any, mats: Any) -> list[int]:
|
||||
"""별도계상 금액 줄 차례 — 옛 `drop_apart` 와 같은 판정(엔진 답 `재료` 의 차례 · 자재표시)."""
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
|
||||
@@ -17,7 +17,7 @@ STmate 꼴(「일위대가표」 · 「단가산출근거」 시트) = `M02_Hopy
|
||||
% 줄 = floor(바탕 × 율 / 100 × 10) / 10 · 호표 비목 = floor(줄 금액 합) · 총괄표 합계 —
|
||||
어긋남은 글 목록(막지 않음).
|
||||
행(329-1) = 호표 [제N호표 줄, 마지막 구성 줄] · 구성 줄 한 줄(엑셀 1부터) ·
|
||||
근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.read`) ·
|
||||
근거(330-1) = 단산N참조 줄에 「단가산출」 블록 `{출처, 직종, 행}`(`M02_Hopyo_ReadEst.from_two`) ·
|
||||
`단산` = 블록마다 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`(338 · 글 = 머리 뺀 몸 줄) ·
|
||||
`꼴` = 「엑셀꼴」 · 두 형식 끝에 `UnitLine.settle`(단위 줄 하위 · 재현 · 덮음 · 일위대가 줄
|
||||
투영 · 778-3).
|
||||
@@ -40,7 +40,6 @@ SHEET = "일위대가"
|
||||
SUMMARY = "일위대가총괄표"
|
||||
LISTS = ("단가산출총괄표", "일위대가목록표") # 엑셀 보기 목록 시트(779-1 격자) — 같이 읽음
|
||||
COSTS = ("노무비", "재료비", "경비")
|
||||
HEADS = ("호표", "품명", "규격", "수량", "단위", "비고")
|
||||
NO_SHEET = "일위대가 시트 없음"
|
||||
_HOPYO = re.compile(r"제\s*(\d+)\s*호표")
|
||||
_REF = re.compile(r"^(?:(단산|산근|단가산출)|(일위대가|일위|대가))(\d+)(?:참조|호표)?$")
|
||||
@@ -88,19 +87,6 @@ def _out(value: Decimal | None) -> int | float | None:
|
||||
return int(value) if value == value.to_integral_value() else float(value)
|
||||
|
||||
|
||||
def _columns(rows: list[list[Any]], money: tuple[str, ...]) -> tuple[int, dict[str, int]]:
|
||||
"""(자료 첫 줄, {머리: 열}) — 머리 글은 앞 10 줄 안 「호표」 · 「품명」 이 든 줄."""
|
||||
for at, row in enumerate(rows[:10]):
|
||||
flat = [_flat(v) for v in row]
|
||||
if "호표" not in flat or "품명" not in flat:
|
||||
continue
|
||||
cols = {head: flat.index(head) for head in (*HEADS, *money) if head in flat}
|
||||
below = [_flat(v) for v in rows[at + 1]] if at + 1 < len(rows) else []
|
||||
start = at + 2 if "단가" in below or "금액" in below else at + 1
|
||||
return start, cols
|
||||
raise ExcelError(f"{SHEET} 시트 머리 글(호표 · 품명)을 못 찾음")
|
||||
|
||||
|
||||
def _cell(row: list[Any], col: int | None) -> Any:
|
||||
return row[col] if col is not None and col < len(row) else None
|
||||
|
||||
@@ -200,23 +186,6 @@ def _check_hopyo(hopyo: dict[str, Any], lines: list[dict[str, Any]]) -> list[str
|
||||
return bad
|
||||
|
||||
|
||||
def _summary(rows: list[list[Any]] | None) -> dict[int, Decimal]:
|
||||
"""총괄표 {호표 번: 합계} — 머리 글이 없으면 빈 것."""
|
||||
if not rows:
|
||||
return {}
|
||||
try:
|
||||
start, cols = _columns(rows, ("합계",))
|
||||
except ExcelError:
|
||||
return {}
|
||||
out = {}
|
||||
for row in rows[start:]:
|
||||
hit = _HOPYO.fullmatch(_flat(_cell(row, cols.get("호표"))))
|
||||
total = _num(_cell(row, cols.get("합계")))
|
||||
if hit and total is not None:
|
||||
out[int(hit.group(1))] = total
|
||||
return out
|
||||
|
||||
|
||||
def _by_name(raw: list[list[dict[str, Any]]], blocks: dict[int, dict[str, Any]]) -> None:
|
||||
"""비고 빈 줄(노무비 · 경비 단가 있음) → 품명 + 단위가 같은 블록이 하나뿐이면 단산 이음."""
|
||||
index: dict[tuple[str, str], list[int]] = {}
|
||||
|
||||
@@ -8,16 +8,12 @@
|
||||
걷음(742-1 · 다르면 남김 = 금액 그대로)) · SK · SC `본뜬.또` = 그 HP 몫만 뺌 ·
|
||||
문서 몸(줄 · 덮개 · 더한줄 · 별칭 · 구분)과 별칭 장부는 그대로 ·
|
||||
끝낸 기록 없음(같은 엑셀 다시 올림 됨 · 키 번은 `불러옴.json` 번으로 다시 안 씀).
|
||||
옛 파일 정리 `tidy`(한 번 · 층 폴더마다 · 미리 보기 = 표만) — 옛 HP(지문 없음) · 하루 지난 HP 끝냄 ·
|
||||
끝낸 기록 지문 비움 · HP 가 없는 SC · SK 엑셀 사본 걷음.
|
||||
`python -m M02_MasterTemplete.M02_Hopyo_Forget <층 폴더>… [--apply]`(없으면 미리 보기).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import sys
|
||||
from collections.abc import Callable
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
@@ -30,7 +26,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
ORIGIN = "실무자료"
|
||||
KEEP = ("층", "파일", "전국자재", "복사원본")
|
||||
_MEMO = re.compile(r"^실무 ")
|
||||
_HP = re.compile(r"^(HP-\d{6}) ")
|
||||
|
||||
|
||||
# ── 사본 걷음(순수) ───────────────────────────────────────────────────
|
||||
@@ -99,8 +94,8 @@ def _here(got: dict[str, Any], here: refs.Here) -> bool:
|
||||
return not got.get("원본") or tuple(got["원본"]) == tuple(here)
|
||||
|
||||
|
||||
def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True) -> list[str]:
|
||||
"""`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키(`apply` 거짓 = 셈만)."""
|
||||
def forget(folder: str | Path, gone: Callable[[str], bool]) -> list[str]:
|
||||
"""`gone(본뜬 키)` 인 이 층 SC · SK 엑셀 사본 걷음 → 걷은 문서 키."""
|
||||
folder, out = Path(folder), []
|
||||
here = refs.where(folder)
|
||||
|
||||
@@ -120,8 +115,7 @@ def forget(folder: str | Path, gone: Callable[[str], bool], apply: bool = True)
|
||||
new["본뜬"]["또"] = also # 777-1 같은 내용 SC 를 나눠 쓴 다른 불러오기 몫은 그대로
|
||||
if new != doc:
|
||||
out.append(path.stem)
|
||||
if apply:
|
||||
atomic_write_json(path, new)
|
||||
atomic_write_json(path, new)
|
||||
return out
|
||||
|
||||
|
||||
@@ -150,46 +144,3 @@ def sweep(folder: str | Path, now: datetime | None = None) -> list[str]:
|
||||
for key in (got := expired(folder, now)):
|
||||
finish(folder, key)
|
||||
return got
|
||||
|
||||
|
||||
# ── 옛 파일 정리(한 번) ───────────────────────────────────────────────
|
||||
def tidy(folder: str | Path, apply: bool = False) -> list[dict[str, str]]:
|
||||
"""옛 실무자료 정리 표 `[{할일, 대상}]` — `apply` 거짓 = 미리 보기(쓰기 없음)."""
|
||||
folder = Path(folder)
|
||||
home = folder / hopyo_store.DIRNAME
|
||||
rows: list[dict[str, str]] = []
|
||||
every = sorted(p.stem for p in home.glob("HP-*.json"))
|
||||
old = [k for k in every if not (hopyo_store._load(home / f"{k}.json") or {}).get("지문")]
|
||||
ended = [*old, *expired(folder)]
|
||||
live = set(every) - set(ended)
|
||||
for key in ended:
|
||||
rows.append({"할일": "HP 끝냄(옛 · 하루 지남)", "대상": f"{hopyo_store.DIRNAME}/{key}"})
|
||||
if apply:
|
||||
finish(folder, key)
|
||||
log = hopyo_store.done(folder)
|
||||
if log["지문"]:
|
||||
rows.append({"할일": f"끝낸 기록 지문 {len(log['지문'])} 비움", "대상": "불러옴.json"})
|
||||
if apply:
|
||||
hopyo_store._put_done(folder, {"번": log["번"]})
|
||||
|
||||
def gone(mark: str) -> bool:
|
||||
m = _HP.match(mark)
|
||||
return bool(m) and m.group(1) not in live
|
||||
|
||||
for key in forget(folder, gone, apply):
|
||||
rows.append({"할일": "엑셀 사본 걷음(출처만)", "대상": key})
|
||||
return rows
|
||||
|
||||
|
||||
def main(argv: list[str]) -> int:
|
||||
apply = "--apply" in argv
|
||||
for one in [a for a in argv if a != "--apply"]:
|
||||
rows = tidy(one, apply)
|
||||
print(f"# {one} — {'고침' if apply else '미리 보기'} {len(rows)}")
|
||||
for row in rows:
|
||||
print(f"{row['할일']}\t{row['대상']}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
|
||||
@@ -1,14 +1,13 @@
|
||||
"""M02 일위대가 실무자료 EST(엑셀꼴) 단가산출 어댑터(PLAN 776-2 · 요구 621-1 ② 정규화) —
|
||||
엑셀 「단가산출」 시트 → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`.
|
||||
둘 꼴 EST 산근 블록(`from_two` · 857-2) → 블록 `{번, 이름, 단위, 행, 출처, 직종, 글, 금액, 항목}`.
|
||||
형식(EST 글)을 아는 곳은 여기까지.
|
||||
|
||||
블록 = B열(머리 「산출근거」) 머리 줄 「N.이름[단위]」(앞 빈칸 없음)부터 다음 머리 앞까지 ·
|
||||
블록 = 머리 「N.이름[단위]」부터 다음 머리 앞까지 ·
|
||||
출처 = 「…품셈」(오타 「품줌」) 뒤 20 글자 안 절 번호 — 책 = 앞 낱말(`book_of` · 781-1: 산림 ·
|
||||
임도(옛) · 사방(옛) · 건설 부문 · 그 밖 건설품셈(부문 모름)) ·
|
||||
부문 풀이 · 옛 번호 대응 = `M02_Hopyo_Clause.settle` ·
|
||||
직종 = 「이름 : 수」 줄의 빈칸 뺀 이름이 우리 인력(LB) 이름 · 옛이름일 때만(지금 이름으로) ·
|
||||
글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 · 산출근거 열이 빈 줄은 그 오른쪽 ~ 돈 머리
|
||||
(맨 오른쪽 묶음) 앞 칸을 빈칸으로 이어 붙임(거창 꼴 · 돈 머리 없으면 `WIDE` 열) ·
|
||||
글 = 머리 뺀 몸 줄 `GLINES` 줄 · 줄마다 `GCHARS` 자 안 ·
|
||||
금액 = 머리 줄 돈 칸(1 단위).
|
||||
항목(Book 블록 항목 · 778-3) = 글 줄 → 단위 줄(꼴 = `M02_Hopyo_UnitLine`) · 줄 금액 = 「= 금액」 ·
|
||||
끝 점(「28,500. ×」) 뗌 · 율(호표 줄 이름 · 규격)에 기대지 않는 것만(섞음 율은 지문 몫):
|
||||
@@ -34,7 +33,7 @@ from M02_MasterTemplete import M02_Labor_Inputs as labor_inputs
|
||||
from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs
|
||||
|
||||
SHEET = "단가산출"
|
||||
GLINES, GCHARS, WIDE = 200, 300, 140
|
||||
GLINES, GCHARS = 200, 300
|
||||
_HEAD = re.compile(r"^(\d+)\.\s*(.*?)\s*\[([^\[\]]*)\]\s*$")
|
||||
_BOOK = re.compile(r"품[셈줌]")
|
||||
_TRADE = re.compile(r"^[\s*·\-]*([가-힣][가-힣\s]*?)\s*:\s*[\d,]")
|
||||
@@ -46,7 +45,6 @@ _BOOK_WORDS = { # 책 낱말(781-1) — 옛 책 = 「(옛)」 · 건설 부문
|
||||
}
|
||||
_BOOK_WORD = re.compile(r"(" + "|".join(_BOOK_WORDS) + r")\s*(?:부문|사업|공사)?\s*(?:표준)?\s*$")
|
||||
_TYPO_CLAUSE = re.compile(r"^(\d+)-(\d)(\d)(\d)$") # 「13-114」 = 13-11-4
|
||||
_MONEY = {"합계": "계", "노무비": "노무비", "재료비": "재료비", "경비": "경비"}
|
||||
# 항목 풀이 — 지문(`Finger`)과 같은 규칙
|
||||
COST = ("노무비", "재료비", "경비")
|
||||
SKIPW = frozenset(
|
||||
@@ -88,12 +86,6 @@ def _flat(value: Any) -> str:
|
||||
return re.sub(r"\s+", "", str(value or ""))
|
||||
|
||||
|
||||
def _cell_text(value: Any) -> str:
|
||||
if isinstance(value, float) and value == int(value):
|
||||
value = int(value)
|
||||
return str(value).strip() if value is not None else ""
|
||||
|
||||
|
||||
# ── 이름 · 출처(두 어댑터 · 뒤 단계 공용) ────────────────────────────────
|
||||
@lru_cache(maxsize=2)
|
||||
def _trade_names(whole_id: int) -> dict[str, str]:
|
||||
@@ -156,66 +148,6 @@ def rates_in(text: Any) -> set[float]:
|
||||
return out
|
||||
|
||||
|
||||
# ── 블록 읽기 ─────────────────────────────────────────────────────────
|
||||
def _columns(rows: list[list[Any]]) -> tuple[int, int, dict[str, int]]:
|
||||
"""(자료 첫 줄, 산출근거 열, {계 · 노무비 · 재료비 · 경비: 열}) — 머리 없으면 (0, 1, {}) ·
|
||||
돈 머리가 둘 묶음이면 맨 오른쪽(거창 꼴 · 값이 든 쪽)."""
|
||||
for at, row in enumerate(rows[:10]):
|
||||
flat = [_flat(v) for v in row]
|
||||
if "산출근거" in flat:
|
||||
last = len(flat) - 1
|
||||
money = {
|
||||
key: last - flat[::-1].index(head) for head, key in _MONEY.items() if head in flat
|
||||
}
|
||||
return at + 1, flat.index("산출근거"), money
|
||||
return 0, 1, {}
|
||||
|
||||
|
||||
def read(rows: list[list[Any]] | None) -> dict[int, dict[str, Any]]:
|
||||
"""단가산출 시트 줄 → `{N: {번, 이름, 단위, 행: [시작, 끝], 출처, 직종, 글, 글행, 금액, 항목,
|
||||
절}}`(행 = 엑셀 1부터 · 글행 = 글 줄마다 행 · 절 = `M02_Hopyo_Formula.tree`)."""
|
||||
if not rows:
|
||||
return {}
|
||||
start, col, money = _columns(rows)
|
||||
end = min(money.values()) if money and min(money.values()) > col + 1 else WIDE
|
||||
names = trade_names()
|
||||
blocks: dict[int, dict[str, Any]] = {}
|
||||
block: dict[str, Any] | None = None
|
||||
for at, row in enumerate(rows[start:], start + 1):
|
||||
text = row[col] if col < len(row) else None
|
||||
head = None
|
||||
if isinstance(text, str) and text.strip():
|
||||
head = None if text[:1].isspace() else _HEAD.match(text)
|
||||
else:
|
||||
text = " ".join(_cell_text(v) for v in row[col + 1 : end] if _cell_text(v))
|
||||
if not text:
|
||||
continue
|
||||
if head:
|
||||
block = blocks.setdefault(
|
||||
int(head.group(1)),
|
||||
{
|
||||
"번": int(head.group(1)),
|
||||
"이름": head.group(2),
|
||||
"단위": head.group(3).strip(),
|
||||
"행": [at, at],
|
||||
"출처": [],
|
||||
"직종": [],
|
||||
"글": [],
|
||||
"금액": {
|
||||
key: v
|
||||
for key, c in money.items()
|
||||
for v in [row[c] if c < len(row) else None]
|
||||
if isinstance(v, (int, float)) and not isinstance(v, bool)
|
||||
},
|
||||
"_글행": [],
|
||||
},
|
||||
)
|
||||
continue
|
||||
if block is not None:
|
||||
_take(block, at, text, names)
|
||||
return _finish(blocks)
|
||||
|
||||
|
||||
def _take(block: dict[str, Any], at: int, text: str, names: dict[str, str]) -> None:
|
||||
"""몸 줄 하나 → 블록 끝 행 · 글(`GLINES` 줄 · 줄마다 `GCHARS` 자) · 출처 · 직종."""
|
||||
block["행"][1] = at
|
||||
|
||||
@@ -40,13 +40,10 @@ LISTS = ("단가산출근거목록표", "노무비목록표", "중기목록표",
|
||||
SHEETS = (SHEET, CALC, *LISTS)
|
||||
_CODE = ilwi.CODE
|
||||
_META = re.compile(r"(?<![A-Z])COD\|([A-Z]{1,2}\d{5})") # 숨은 칸 「`COD|L00001」
|
||||
_HEAD_B = re.compile(r"BDCOD\|(B\d{5})")
|
||||
_HEAD_D = re.compile(r"BDCOD\|(D\d{5})")
|
||||
_RES = re.compile(r"^([LMXS])(\d{5})_\d+$")
|
||||
_RES_A = re.compile(r"^([LMXS]\d{5})[LMS]$") # A 열 「L00002L」
|
||||
_RES_G = re.compile(r"&([LMXS]\d{5})[LMS]&") # G 열 식 「&L00002L&」
|
||||
_SECTION = re.compile(r"^\s*(?:\d+\s*[.)]|[①-⑩])\s*(.*\S)")
|
||||
_COLS = {"합계": 4, "노무비": 6, "재료비": 8, "경비": 10}
|
||||
_CALC_AMOUNT = {"합계": 2, "노무비": 3, "재료비": 4, "경비": 5} # 단가산출근거 C~F 금액
|
||||
_CALC_PRICE = {"합계": 8, "노무비": 9, "재료비": 10, "경비": 11} # I~L 단가(T · L · M · S)
|
||||
NOTE, CODE_COLS, RES_COL, QTY_COL, NAME_COL = 12, range(12, 26), 12, 7, 23
|
||||
@@ -293,27 +290,9 @@ def _finish(out: dict[str, dict[str, Any]]) -> dict[str, dict[str, Any]]:
|
||||
return out
|
||||
|
||||
|
||||
def _blocks(rows: list[list[Any]], table: dict[str, dict[str, str]]) -> dict[str, dict[str, Any]]:
|
||||
"""{D 코드: {번, 코드, 이름, 규격, 단위, 행, 출처, 직종, 글, 자원, 금액, 항목}}."""
|
||||
out: dict[str, dict[str, Any]] = {}
|
||||
block: dict[str, Any] | None = None
|
||||
state = {"절": "", "라벨": ""} # 절 제목 · 율 행 위 라벨 줄(코드 · 금액 없는 글)
|
||||
for at, row in enumerate(rows, 1):
|
||||
head = next(
|
||||
(hit for v in row[:8] if (hit := _HEAD_D.search(_s(v)))), None
|
||||
) # 머리 = G 열(판마다 B 열 글이 다름)
|
||||
if head:
|
||||
block = out.setdefault(head.group(1), _new(head.group(1), at, row, table))
|
||||
state = {"절": "", "라벨": ""}
|
||||
continue
|
||||
if block is not None and not _take(block, at, row, table, state):
|
||||
block = None
|
||||
return _finish(out)
|
||||
|
||||
|
||||
def from_two(blocks: list[dict[str, Any]], table: dict[str, dict[str, str]]) -> dict[str, Any]:
|
||||
"""둘 꼴 STmate 산근 블록 `칸줄`(머리 ~ 다음 머리 앞 칸 · `M02_San_Xlsx_Stmate.cells` · 857-2) →
|
||||
`_blocks` 와 같은 블록 — 시트를 다시 가르지 않음 · D 코드 블록만."""
|
||||
블록 — 시트를 다시 가르지 않음 · D 코드 블록만."""
|
||||
out: dict[str, dict[str, Any]] = {}
|
||||
for b in blocks:
|
||||
code = str(b.get("코드") or "")
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫.
|
||||
한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것
|
||||
(작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) ·
|
||||
`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀 · 옛 `지문` 안 읽음).
|
||||
`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀).
|
||||
판(776-2) = 읽기 꼴(Book) 판 `BOOK` 을 HP 에 찍음 · 다른 판 = 지난 것(목록에서 숨김 ·
|
||||
다음 올림 때 끝냄 · 작업 중 열기 = 409 「다시 올림」 · 옛 꼴 읽기 갈래 없음).
|
||||
"""
|
||||
@@ -95,11 +95,9 @@ def rows(folder: str | Path) -> list[dict[str, Any]]:
|
||||
|
||||
|
||||
def done(folder: str | Path) -> dict[str, Any]:
|
||||
"""키 번 기록 `{번, 지문}`(지문 = 743 전 끝낸 기록 · 안 읽음 · 정리 `Forget.tidy`)."""
|
||||
"""키 번 기록 `{번}`."""
|
||||
doc = _load(_dir(folder) / f"{DONE}.json")
|
||||
doc = doc if isinstance(doc, dict) else {}
|
||||
marks = doc.get("지문")
|
||||
return {"번": int(doc.get("번") or 0), "지문": marks if isinstance(marks, dict) else {}}
|
||||
return {"번": int((doc if isinstance(doc, dict) else {}).get("번") or 0)}
|
||||
|
||||
|
||||
def _put_done(folder: str | Path, got: dict[str, Any]) -> None:
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
"""M02 일위대가 실무자료 단위 줄(PLAN 778-3 · D-1 · 요구 622) — 단가산출 블록 · 일위대가 줄을 같은
|
||||
「세부항목 계산 단위」 꼴로 · 자체 검산. 형식(EST · STmate)을 모름 — 읽기 어댑터
|
||||
(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate._blocks`)가 블록 `항목` 을 단위 줄로 냄.
|
||||
(`M02_Hopyo_ReadEst.items` · `M02_Hopyo_Stmate.from_two`)가 블록 `항목` 을 단위 줄로 냄.
|
||||
|
||||
단위 줄 = `{묶음, 이름, 규격, 단위, 품, 밑품, 율, 인자, 계수, 단가, 금액, 밖, 기준, 기준값,
|
||||
하위, 할증, 재현, 직종, 절, 절율, 코드, 어떻게, 행}`:
|
||||
|
||||
@@ -22,6 +22,7 @@ from common_util.common_util_summary_item import GROUP_JOIN
|
||||
from M02_MasterTemplete import M02_Item_Personal as personal
|
||||
from M02_MasterTemplete import M02_Item_Prices as prices
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
from M02_MasterTemplete.M02_Doc_B09 import FILE as FORMULA_FILE
|
||||
from M02_MasterTemplete.M02_Item_Snapshot import (
|
||||
FOLDER_PATTERN,
|
||||
LOCAL_FILES,
|
||||
@@ -191,12 +192,9 @@ def write_file(
|
||||
# ── 새로 가져오기 · 미리 가져오기 ─────────────────────────────────────
|
||||
|
||||
|
||||
def _kept_values(values: Any, labor: dict[str, Any]) -> dict[str, Any]:
|
||||
"""같은 로직 · 같은 입력 이름만 살림."""
|
||||
names = {
|
||||
str(row.get("키")): {spec["이름"] for spec in row.get("입력", [])}
|
||||
for row in labor.get("로직", [])
|
||||
}
|
||||
def _kept_values(values: Any, docs: dict[str, dict]) -> dict[str, Any]:
|
||||
"""같은 로직 · 같은 입력 이름만 살림(입력 = 새 사본 수식 문서 · 855-F B9-6)."""
|
||||
names = {key: set(prices.doc_inputs(doc)) for key, doc in docs.items()}
|
||||
out: dict[str, Any] = {}
|
||||
for logic, inputs in (values or {}).items():
|
||||
kept = {k: v for k, v in (inputs or {}).items() if k in names.get(logic, set())}
|
||||
@@ -205,14 +203,10 @@ def _kept_values(values: Any, labor: dict[str, Any]) -> dict[str, Any]:
|
||||
return out
|
||||
|
||||
|
||||
def _kept_picks(picks: Any, labor: dict[str, Any]) -> dict[str, Any]:
|
||||
"""같은 로직 · 있는 호표 차례만 살림."""
|
||||
lines = {str(row.get("키")): len(row.get("호표", [])) for row in labor.get("로직", [])}
|
||||
slots = { # 흐름 로직 — 고른 자재는 재료 자리 이름(= 입력 이름)
|
||||
str(row.get("키")): {s["이름"] for s in row.get("입력", [])}
|
||||
for row in labor.get("로직", [])
|
||||
if isinstance(row.get("흐름"), dict)
|
||||
}
|
||||
def _kept_picks(picks: Any, docs: dict[str, dict]) -> dict[str, Any]:
|
||||
"""같은 로직 · 있는 줄 차례(문서 금액 줄) · 흐름 로직 재료 자리 이름(= 입력 이름)만 살림."""
|
||||
lines = {key: len(doc.get("금액") or []) for key, doc in docs.items()}
|
||||
slots = {key: set(prices.doc_inputs(doc)) for key, doc in docs.items()}
|
||||
out: dict[str, Any] = {}
|
||||
for logic, chosen in (picks or {}).items():
|
||||
kept = {
|
||||
@@ -238,12 +232,12 @@ def reapply(
|
||||
picks = read_json(target / PICKS_FILE)
|
||||
before = {name: read_json(target / file) for name, file in KINDS.items()}
|
||||
files = build_snapshot(manifest["원본"])
|
||||
labor = files.get(LABOR_FILE) or {}
|
||||
docs = (files.get(FORMULA_FILE) or {}).get("문서") or {} # 새 사본 수식 문서
|
||||
seeded = files[VALUES_FILE] # 새 원본의 첫 값 — 프로젝트에서 넣은 값이 같은 키면 이김
|
||||
kept_values = _kept_values(values, labor)
|
||||
kept_values = _kept_values(values, docs)
|
||||
for logic, inputs in kept_values.items():
|
||||
seeded[logic] = {**seeded.get(logic, {}), **inputs}
|
||||
files[PICKS_FILE] = _kept_picks(picks, labor)
|
||||
files[PICKS_FILE] = _kept_picks(picks, docs)
|
||||
for old in target.glob("*.json"): # 원본에서 빠진 파일(도면 없앰 등)은 지움
|
||||
if old.name != MANIFEST_NAME and old.name not in files:
|
||||
old.unlink()
|
||||
|
||||
@@ -303,22 +303,43 @@ def load_prices(prices: dict[str, Any]) -> Any:
|
||||
|
||||
def _logic_keys(labor: dict[str, Any]) -> list[str]:
|
||||
"""담은 로직 키 — 참조 줄(로직 없음 · 50-3)은 뺌."""
|
||||
return [key for key in mcb.logic_keys(labor.get("줄") or {}) if key]
|
||||
lines = (labor.get("줄") or {}).get("담은로직") or []
|
||||
return [str(one["로직"]) for one in lines if isinstance(one, dict) and one.get("로직")]
|
||||
|
||||
|
||||
def missing_inputs(snapshot: Any, labor: dict[str, Any], values: dict[str, Any]) -> list[dict]:
|
||||
"""담은 로직마다 값이 없는(null · 안 적음) 입력 — `{로직, 입력}`."""
|
||||
def doc_inputs(doc: Any) -> list[str]:
|
||||
"""수식 문서 입력 이름(입력 · 선택 변수 열쇠 · 옛 로직 줄 `입력` 이름 · 차례와 같음)."""
|
||||
return [
|
||||
str(v["열쇠"])
|
||||
for v in (doc or {}).get("변수") or []
|
||||
if (v.get("연결") or {}).get("갈래") in ("입력", "선택") and v.get("열쇠")
|
||||
]
|
||||
|
||||
|
||||
def doc_specs(doc: Any) -> list[dict[str, Any]]:
|
||||
"""수식 문서 입력 꼴(옛 로직 줄 `입력` 자리) — {이름(열쇠), 단위, 설명, 출처, 고르기, 범위}."""
|
||||
out = []
|
||||
for v in (doc or {}).get("변수") or []:
|
||||
link = v.get("연결") or {}
|
||||
if link.get("갈래") not in ("입력", "선택") or not v.get("열쇠"):
|
||||
continue
|
||||
spec = {"이름": str(v["열쇠"]), **{k: v[k] for k in ("단위", "설명", "출처") if v.get(k)}}
|
||||
spec |= {"고르기": list(link["목록"])} if link.get("목록") else {}
|
||||
out.append(spec | ({"범위": list(link["범위"])} if link.get("범위") else {}))
|
||||
return out
|
||||
|
||||
|
||||
def missing_inputs(
|
||||
docs: dict[str, dict], labor: dict[str, Any], values: dict[str, Any]
|
||||
) -> list[dict]:
|
||||
"""담은 로직마다 값이 없는(null · 안 적음) 입력 — `{로직, 입력}` · 입력 = 사본 수식 문서."""
|
||||
out = []
|
||||
for key in _logic_keys(labor):
|
||||
try:
|
||||
row = snapshot.logic(key)
|
||||
except mf.FormulaError:
|
||||
continue
|
||||
mine = values.get(key) or {}
|
||||
for spec in row.get("입력", []):
|
||||
got = mine.get(spec["이름"])
|
||||
for name in doc_inputs(docs.get(key)):
|
||||
got = mine.get(name)
|
||||
if not isinstance(got, dict) or got.get("값") in (None, ""):
|
||||
out.append({"로직": key, "입력": spec["이름"]})
|
||||
out.append({"로직": key, "입력": name})
|
||||
return out
|
||||
|
||||
|
||||
@@ -401,7 +422,7 @@ def line(whole: Any, docs: dict[str, dict] | None, one: dict[str, Any]) -> dict[
|
||||
return {"기준": None, "줄": [], "재료": [], "까닭": f"수식 문서 없음 「{code}」"}
|
||||
apart = dc.apart_of(one.get("자재표시"), [{"차례": n} for n, _, _ in _mat_lines(base)])
|
||||
doc = dc.line_doc(base, one.get("켜쌓기율"), one.get("고름"), apart)
|
||||
given = dc.given_of(whole, code, one.get("입력값"))
|
||||
given = dc.given_of(whole, code, one.get("입력값"), docs)
|
||||
copy = {"부름": docs}
|
||||
try:
|
||||
ans = mt.calc(doc, mt.Trace(whole, docs), given, dc.cover_of(copy, doc))
|
||||
@@ -450,5 +471,5 @@ def calc(
|
||||
return {
|
||||
**got,
|
||||
"알약": saved if isinstance(saved, list) else labor_doc.pills(doc),
|
||||
"빠진입력": missing_inputs(snapshot, labor, values or {}),
|
||||
"빠진입력": missing_inputs(docs, labor, values or {}),
|
||||
}
|
||||
|
||||
@@ -333,6 +333,7 @@ export function createItemCards(opts: ItemCardsOptions): ItemCardsHandle {
|
||||
? {
|
||||
calc: (doc, 수량) => via.calc(at, doc, 수량),
|
||||
readArea: () => src.read("area", at),
|
||||
...(via.sk ? { skCopy: via.sk } : {}), // 856-3 사본 단가산출 줄 = 보기만
|
||||
}
|
||||
: {}),
|
||||
onChanged: (dirty) => laborCard.saver.mark(dirty && laborWritable()),
|
||||
|
||||
@@ -12,7 +12,7 @@ import {
|
||||
type Layer,
|
||||
} from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborDoc } from "./M02_MasterTemplete_Labor_Api";
|
||||
import type { LaborCalc } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import type { LaborCalc, LaborRef } from "./M02_MasterTemplete_Labor_Calc";
|
||||
|
||||
/** 집계표 열 하나에 딸린 문서 — 구조물 도면 · 면적산출 */
|
||||
export type ItemPart = "structure" | "area";
|
||||
@@ -34,6 +34,8 @@ export interface ItemSource {
|
||||
doc: LaborDoc,
|
||||
수량?: Record<string, number>,
|
||||
) => Promise<LaborCalc & { 알약: unknown[] }>;
|
||||
/** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서(`참조사본`) · 줄 누름 = 줄 쌓기 보기만 */
|
||||
sk?: (ref: LaborRef) => Promise<Record<string, unknown> | null>;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -12,6 +12,7 @@
|
||||
import type { DataColumn } from "@ui/ui_template_data_table";
|
||||
import type { Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborCalc, LaborDoc } from "./M02_MasterTemplete_Labor_Api";
|
||||
import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import { mountLaborTable } from "./M02_MasterTemplete_Labor_Table";
|
||||
|
||||
export interface LaborDetailOptions {
|
||||
@@ -32,6 +33,8 @@ export interface LaborDetailOptions {
|
||||
/** 셈 · 면적 자리 주입(142-1 · 고르기 모달 = 프로젝트 복사본) — 없으면 층 길 */
|
||||
calc?: (doc: LaborDoc, 수량?: Record<string, number>) => Promise<LaborCalc & { 알약: unknown[] }>;
|
||||
readArea?: () => Promise<{ 문서: unknown; 판?: string | null }>;
|
||||
/** 프로젝트 사본(856-3) — 단가산출 줄의 굳힌 SK 문서 · 있으면 그 줄 누름 = 줄 쌓기 보기만 */
|
||||
skCopy?: (ref: LaborRef) => Promise<Record<string, unknown> | null>;
|
||||
}
|
||||
|
||||
/** 덧칸 — `cell(n, 열)` = 문서 줄 n 의 값 · `onRow(n)` 참 = 기본 줄 모달 안 엶 */
|
||||
|
||||
@@ -2,34 +2,19 @@
|
||||
* M02_MasterTemplete_Labor_LogicMats.ts
|
||||
* 자재목록 표의 로직 자재 줄(103-1) — 담은 로직 맨 위 층 재료 줄(서버 calc `줄[].재료`) · 사용자 자재 줄과 같은 칸
|
||||
* (코드 · 이름 · 규격 · 수량 · 단위 · 가격 다섯 · 단가 / 금액) · 사용자 자재 앞.
|
||||
* · 삭제 없음 · [바꾸기] = M01 자재품목 표에서 고름(문서 `담은로직[].고름` · 엔진 `choosing`) · 바꾼 줄만 [기본](고름 풂)
|
||||
* · 금액은 로직 단가 안이라 합에 다시 안 더함(보기만) · 수량은 로직 것(누름 · 알약 없음)
|
||||
* · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름)
|
||||
* · 줄 누름(148-1) = 그 로직 줄 [옵션] 모달(읽기만이면 보기) · [바꾸기] · [기본]은 고칠 때만
|
||||
* · 보기만(856-3 — 로직 줄 창 · [바꾸기] · [기본] · 세 칸 고침 걷음 · 일위대가 면적 보기 `Labor_View` 가 씀)
|
||||
* · 금액은 로직 단가 안이라 합에 다시 안 더함 · 수량은 로직 것 · 하위 로직 안 재료는 안 보임(엔진이 맨 위 층만 고름)
|
||||
* ========================================================================== */
|
||||
|
||||
import { createButton, el } from "@ui/ui_template_elements";
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { formatMoney } from "../common_util/common_util_money";
|
||||
import { openPickTable } from "../M01_MasterData/M01_MasterData_UI_Logic_PickTable";
|
||||
import { headWord } from "../M01_MasterData/M01_MasterData_UI_LogicLab_Modal";
|
||||
import type { LaborCalc, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
|
||||
import type { LaborCalc, LaborRow } from "./M02_MasterTemplete_Labor_Api";
|
||||
import { lineId } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import { markCells } from "./M02_MasterTemplete_Labor_MatMarks";
|
||||
import { moneyCell, PRICE_SLOTS } from "./M02_MasterTemplete_Labor_Rows";
|
||||
import { tc } from "./M02_MasterTemplete_Labor_Text";
|
||||
import type { LogicMat } from "./M02_Labor_LogicMats_Model";
|
||||
|
||||
export interface LogicMatHandlers {
|
||||
/** 줄 누름(148-1) = 그 자재를 낸 로직 줄 [옵션] 모달 — `row` = 담은 로직 차례 */
|
||||
open: (row: number) => void;
|
||||
/** [바꾸기]로 고른 품목 키 — `row` = 담은 로직 차례 · `at` = 호표 차례 · 없으면(읽기만) 단추 칸 없음 */
|
||||
swap?: (row: number, at: number, key: string) => void;
|
||||
/** [기본] — 그 줄 고름 풂 */
|
||||
reset?: (row: number, at: number) => void;
|
||||
/** 세 칸(148-4) — 로직 줄 `자재표시` · 없으면 글만 */
|
||||
mark?: (row: number, at: number, key: MatMarkKey, v: string) => void;
|
||||
}
|
||||
|
||||
const num = (v: number | null): string =>
|
||||
v === null
|
||||
? "—"
|
||||
@@ -40,21 +25,14 @@ export function logicMatRows(
|
||||
rows: LaborRow[],
|
||||
calc: LaborCalc | null,
|
||||
wait: boolean,
|
||||
on?: LogicMatHandlers,
|
||||
): HTMLElement[] {
|
||||
return rows.flatMap((row, r) => {
|
||||
return rows.flatMap((row) => {
|
||||
const line = row.참조 ? undefined : calc?.줄.find((l) => lineId(l) === lineId(row));
|
||||
return (line?.재료 ?? []).map((mat) => matRow(row, r, mat, wait, on));
|
||||
return (line?.재료 ?? []).map((mat) => matRow(row, mat, wait));
|
||||
});
|
||||
}
|
||||
|
||||
function matRow(
|
||||
row: LaborRow,
|
||||
r: number,
|
||||
mat: LogicMat,
|
||||
wait: boolean,
|
||||
on?: LogicMatHandlers,
|
||||
): HTMLElement {
|
||||
function matRow(row: LaborRow, mat: LogicMat, wait: boolean): HTMLElement {
|
||||
const item = mat.품목;
|
||||
const name = item?.이름 ?? mat.이름;
|
||||
const owner = `${row.별칭 ?? row.로직} · ${mat.이름}`;
|
||||
@@ -69,51 +47,8 @@ function matRow(
|
||||
};
|
||||
const money = moneyCell(mat.단가, mat.금액, wait, tc("Labor_AppliedSum"));
|
||||
money.title = tc("LogicMat_Inside");
|
||||
const swap = on?.swap;
|
||||
const reset = on?.reset;
|
||||
const tools = swap
|
||||
? [
|
||||
el("td", {
|
||||
className: "m02-labrow__move",
|
||||
children: [
|
||||
el("div", {
|
||||
className: "ui-btn-group",
|
||||
children: [
|
||||
createButton({
|
||||
label: tc("LogicMat_Swap"),
|
||||
variant: "ghost",
|
||||
onClick: (e) => {
|
||||
e.stopPropagation();
|
||||
openPickTable({
|
||||
kind: "재료",
|
||||
title: `${tc("LogicMat_PickTitle")} · ${mat.이름}`,
|
||||
seed: headWord(name),
|
||||
alt: [headWord(mat.이름)],
|
||||
isCurrent: (x) => String(x["키"]) === item?.키,
|
||||
onPick: (x) => swap(r, mat.차례, String(x["키"])),
|
||||
});
|
||||
},
|
||||
}),
|
||||
...(mat.고름 && reset
|
||||
? [
|
||||
createButton({
|
||||
label: tc("LogicMat_Reset"),
|
||||
variant: "ghost",
|
||||
onClick: (e) => {
|
||||
e.stopPropagation();
|
||||
reset(r, mat.차례);
|
||||
},
|
||||
}),
|
||||
]
|
||||
: []),
|
||||
],
|
||||
}),
|
||||
],
|
||||
}),
|
||||
]
|
||||
: [];
|
||||
const tr = el("tr", {
|
||||
className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}${on ? " is-open" : ""}`,
|
||||
return el("tr", {
|
||||
className: `m02-labrow__row m02-labrow__logic-mat${mat.고름 ? " is-picked-mat" : ""}`,
|
||||
attrs: { "data-labor-logic-mat": `${row.로직}|${mat.차례}` },
|
||||
children: [
|
||||
el("td", { className: "m02-labrow__code", text: item?.키 ?? "—" }),
|
||||
@@ -146,15 +81,9 @@ function matRow(
|
||||
text: mat.단위,
|
||||
attrs: { "data-label": tc("Labor_Unit") },
|
||||
}),
|
||||
...markCells(
|
||||
row.자재표시?.[String(mat.차례)] ?? {},
|
||||
on?.mark ? (k, v) => on.mark?.(r, mat.차례, k, v) : undefined,
|
||||
),
|
||||
...markCells(row.자재표시?.[String(mat.차례)] ?? {}),
|
||||
...PRICE_SLOTS.map(priceCell),
|
||||
money,
|
||||
...tools,
|
||||
],
|
||||
});
|
||||
if (on) tr.addEventListener("click", () => on.open(r));
|
||||
return tr;
|
||||
}
|
||||
|
||||
@@ -10,7 +10,6 @@ import { createSelectField, el } from "@ui/ui_template_elements";
|
||||
import {
|
||||
MAT_MARK_DEFAULT,
|
||||
MAT_MARKS,
|
||||
type LaborRow,
|
||||
type MatMarkKey,
|
||||
type MatMarks,
|
||||
} from "./M02_MasterTemplete_Labor_Api";
|
||||
@@ -60,12 +59,3 @@ export function setMark(target: MatMarks, key: MatMarkKey, v: string): void {
|
||||
if (v) (target as Record<string, string>)[key] = v;
|
||||
else delete target[key];
|
||||
}
|
||||
|
||||
/** 로직 줄 `자재표시` 한 차례 한 칸 — 빈 차례 · 빈 묶음은 뺌 */
|
||||
export function setLogicMark(row: LaborRow, at: number, key: MatMarkKey, v: string): void {
|
||||
const all = (row.자재표시 ??= {});
|
||||
const one = (all[String(at)] ??= {});
|
||||
setMark(one, key, v);
|
||||
if (!Object.keys(one).length) delete all[String(at)];
|
||||
if (!Object.keys(all).length) delete row.자재표시;
|
||||
}
|
||||
|
||||
@@ -1,134 +1,20 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Labor_RowModal.ts
|
||||
* 일위대가표 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5 · 856-1) — 일위대가표에서 빠진 줄 동작을 모달 안으로.
|
||||
* · 로직 줄(단가산출 문서 없음) · 셈 주입 줄(프로젝트 사본) = 머리(이름 · 「1 ㎡ 당」 · 옵션 값 · 메모) + 안내 한 줄
|
||||
* (856-1 — 옛 단가산출 상세 몸 · [적용] 걷음 · 고침 = 단가산출 줄 쌓기 · 856-3 에서 줄 쌓기 보기로) ·
|
||||
* 로직 자재(바꾸기 · 기본 · 세 칸 · `Labor_LogicMats`)
|
||||
* · 사용자 자재 줄 = 자재 모달(세 칸 · `Labor_MatTable` 한 줄)
|
||||
* 일위대가표 사용자 자재 줄 누름 모달(PLAN 723-2 · 요구서_내역16 2장 4 · 5) — 세 칸(`Labor_MatTable` 한 줄) · 가격 다섯 보기.
|
||||
* · 고침 = 그 줄 화면 캐시(저장은 [저장]) · 금액은 표가 다시 셈 → `watch` 로 받아 다시 그림
|
||||
* · 단가산출(SK) 줄 = `Labor_SkEdit`(프로젝트 사본 = 보기만) · M01 로직 줄 창은 걷음(856-3)
|
||||
* ========================================================================== */
|
||||
|
||||
import { createBanner } from "@ui/ui_template_banner";
|
||||
import { el, showToast } from "@ui/ui_template_elements";
|
||||
import { el } from "@ui/ui_template_elements";
|
||||
import { openModal } from "@ui/ui_template_modal";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborCalc, LaborMat, LaborRow, MatMarkKey } from "./M02_MasterTemplete_Labor_Api";
|
||||
import { logicMatRows } from "./M02_MasterTemplete_Labor_LogicMats";
|
||||
import { setLogicMark, setMark } from "./M02_MasterTemplete_Labor_MatMarks";
|
||||
import type { LaborCalc, LaborMat } from "./M02_MasterTemplete_Labor_Api";
|
||||
import { setMark } from "./M02_MasterTemplete_Labor_MatMarks";
|
||||
import { matTable } from "./M02_MasterTemplete_Labor_MatTable";
|
||||
import { tc } from "./M02_MasterTemplete_Labor_Text";
|
||||
import { valueLine } from "./M02_Labor_Values_Model";
|
||||
|
||||
/** 표가 다시 센 답을 받음 — 돌려준 함수 = 그만 받음 */
|
||||
export type CalcWatch = (fn: (calc: LaborCalc | null) => void) => () => void;
|
||||
|
||||
export interface RowModalOptions {
|
||||
row: LaborRow;
|
||||
logic: ItemLogic | null;
|
||||
title: string;
|
||||
/** 일위대가 머리(이름 · 「1 ㎡ 당」) */
|
||||
head: string;
|
||||
readOnly: boolean;
|
||||
/** 셈 주입(프로젝트 복사본) — 안내 글이 다름 */
|
||||
inject: boolean;
|
||||
/** 사용자 자재 코드 — 로직 자재 [바꾸기]로 같은 품목 막음 */
|
||||
userMats: string[];
|
||||
watch: CalcWatch;
|
||||
/** 고침 뒤 — `again` = 서버 다시 셈(입력 · 고름 · 별도계상) · 아니면 화면만 */
|
||||
done: (again: boolean) => void;
|
||||
}
|
||||
|
||||
const TEXT = {
|
||||
NoDoc: [
|
||||
"M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 고침은 단가산출로 담아(일위대가 [로직 추가]) 그 줄에서",
|
||||
"Uses the M01 logic directly — add it as a build-up to edit",
|
||||
],
|
||||
FromSk: [
|
||||
"단가산출 「{k}」 에서 담아 온 줄 — 고침은 그 단가산출에서 고쳐 다시 담음",
|
||||
"Copied from build-up 「{k}」 — edit it there and re-add",
|
||||
],
|
||||
Inject: [
|
||||
"프로젝트 사본 줄 — 단가산출 화면 없음 · 수식 고침은 M02 단가산출에서 고쳐 [재생성]",
|
||||
"Project copy line — edit the build-up in M02 and regenerate",
|
||||
],
|
||||
} as const;
|
||||
const t = (k: keyof typeof TEXT): string => TEXT[k][0];
|
||||
|
||||
export function openRowModal(o: RowModalOptions): void {
|
||||
const row = o.row;
|
||||
const edit = !o.readOnly;
|
||||
const info = el("div", { attrs: { "data-row-head": "" } });
|
||||
const mats = el("div", { attrs: { "data-row-mats": "" } });
|
||||
let calc: LaborCalc | null = null;
|
||||
|
||||
const draw = (): void => {
|
||||
const values = valueLine(o.logic?.입력 ?? [], row.입력값);
|
||||
info.replaceChildren(
|
||||
createText(o.head, "muted", 14),
|
||||
...(values.text ? [createText(values.text)] : []),
|
||||
...(values.empty
|
||||
? [createText(tc("Labor_Empty").replace("{n}", String(values.empty)), "error")]
|
||||
: []),
|
||||
...(row.켜쌓기율 != null
|
||||
? [createText(tc("Labor_Layer").replace("{n}", String(row.켜쌓기율)), "muted")]
|
||||
: []),
|
||||
...(row.메모 ? [createText(row.메모, "muted")] : []),
|
||||
);
|
||||
const lead = row.참조
|
||||
? []
|
||||
: logicMatRows([row], calc, !calc, {
|
||||
open: () => undefined,
|
||||
...(edit
|
||||
? {
|
||||
swap: (_r: number, at: number, key: string) => {
|
||||
if (o.userMats.includes(key))
|
||||
return showToast(tc("Labor_AlreadyMat").replace("{value}", key), "error");
|
||||
row.고름 = { ...row.고름, [String(at)]: key };
|
||||
o.done(true);
|
||||
},
|
||||
reset: (_r: number, at: number) => {
|
||||
if (!row.고름) return;
|
||||
delete row.고름[String(at)];
|
||||
if (!Object.keys(row.고름).length) delete row.고름;
|
||||
o.done(true);
|
||||
},
|
||||
mark: (_r: number, at: number, key: MatMarkKey, v: string) => {
|
||||
setLogicMark(row, at, key, v);
|
||||
o.done(key === "별도계상");
|
||||
draw();
|
||||
},
|
||||
}
|
||||
: {}),
|
||||
});
|
||||
mats.replaceChildren(
|
||||
...(lead.length
|
||||
? [el("h4", { text: tc("Labor_Mats") }), matTable({ mats: [], calc, lead })]
|
||||
: []),
|
||||
);
|
||||
};
|
||||
|
||||
// 안내 한 줄(856-1) — 로직 줄 = 온 단가산출(`본뜬`) · 셈 주입 = 프로젝트 사본
|
||||
const from = row.본뜬 && typeof row.본뜬.이름 === "string" ? row.본뜬.이름 : "";
|
||||
const note = createBanner({
|
||||
tone: "info",
|
||||
text: o.inject ? t("Inject") : from ? t("FromSk").replace("{k}", from) : t("NoDoc"),
|
||||
});
|
||||
const stop = o.watch((c) => {
|
||||
calc = c;
|
||||
draw();
|
||||
});
|
||||
openModal({
|
||||
title: o.title,
|
||||
closeLabel: tc("In_Close"),
|
||||
width: "1100px",
|
||||
wide: true,
|
||||
beforeClose: () => (stop(), true),
|
||||
mount: (body) => body.append(info, note, mats),
|
||||
});
|
||||
draw();
|
||||
}
|
||||
|
||||
export interface MatModalOptions {
|
||||
mat: LaborMat;
|
||||
watch: CalcWatch;
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
* · [저장] = 수식 저장(`flush`) → 그 SK 문서 저장(`saveTemplate` · 그 층 · 그 주인) → 닫음 → 부르는 쪽이 일위대가 금액을 다시 셈
|
||||
* · 그 층을 못 고치면(위 층 · 남의 주인) 읽기만 · [저장] 없음 · 고친 것 있이 닫으면 물음(버리면 수식 캐시도 비움)
|
||||
* · 머리(808-1 · 요구 701-4 · 5) = 단가산출 페이지 머리와 같음 — 보기 고르기 · [단가 갱신] · [재생성] · [저장] · [닫기]
|
||||
* · 프로젝트 사본(856-3 · `copy`) = 사본의 굳힌 SK 문서째 줄 쌓기 보기만(`memory` · 파일 안 읽음 · 저장 없음) ·
|
||||
* 고침은 M02 단가산출에서 고쳐 [재생성](요구 898 ①)
|
||||
* 짝 모달 = `Labor_RefEdit`(일위조합 SC 줄).
|
||||
* ========================================================================== */
|
||||
|
||||
@@ -23,6 +25,8 @@ export interface SkEditOptions {
|
||||
/** 일위대가 머리(이름 · 「1 ㎡ 당」) */
|
||||
head: string;
|
||||
readOnly: boolean;
|
||||
/** 프로젝트 사본(856-3) — 그 사본의 굳힌 SK 문서(있으면 보기만 · 파일 안 읽음) */
|
||||
copy?: Record<string, unknown>;
|
||||
/** 닫힘 — `saved` = 그 SK 문서를 저장함(부르는 쪽이 금액을 다시 셈) */
|
||||
closed: (saved: boolean) => void;
|
||||
}
|
||||
@@ -39,12 +43,16 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
const at = `${layer}/${opt.ref.주인 ?? ""}/${opt.ref.키}`;
|
||||
if (opened.has(at)) return;
|
||||
opened.add(at);
|
||||
let doc: unknown;
|
||||
let version: string;
|
||||
const copy = !!opt.copy;
|
||||
const readOnly = copy || opt.readOnly;
|
||||
let doc: unknown = opt.copy;
|
||||
let version = "";
|
||||
try {
|
||||
const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인);
|
||||
doc = got.문서;
|
||||
version = got.판 ?? "";
|
||||
if (!copy) {
|
||||
const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인);
|
||||
doc = got.문서;
|
||||
version = got.판 ?? "";
|
||||
}
|
||||
} catch (error) {
|
||||
opened.delete(at);
|
||||
return void showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error");
|
||||
@@ -72,12 +80,13 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
const host = el("div", { attrs: { "data-labor-sk": opt.ref.키 } });
|
||||
const slot = el("span", { className: "m02-main__tools" }); // 보기 고르기 · [단가 갱신] · [재생성](808-1 · 페이지 머리와 같음)
|
||||
handle = mountSangeunDetail(host, doc, {
|
||||
layer,
|
||||
owner: opt.ref.주인,
|
||||
readOnly: opt.readOnly,
|
||||
onChanged: (d) => (dirty = d && !opt.readOnly),
|
||||
// 사본 = 층 읽기 길(굳힌 문서째 셈 · 주인 층 권한 없이)
|
||||
layer: copy ? "system" : layer,
|
||||
owner: copy ? null : opt.ref.주인,
|
||||
readOnly,
|
||||
onChanged: (d) => (dirty = d && !readOnly),
|
||||
onVersion: (v) => (version = v), // 수식 저장이 파일 판을 바꿈 — 문서 저장이 이어 받음
|
||||
mode: "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
mode: copy ? "memory" : "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
slot,
|
||||
});
|
||||
const ok = createButton({
|
||||
@@ -110,13 +119,17 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
body.append(
|
||||
createText(opt.head, "muted", 14),
|
||||
createText(
|
||||
opt.readOnly ? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}` : tc("Ref_Shared"),
|
||||
copy
|
||||
? tc("Ref_Copy")
|
||||
: opt.readOnly
|
||||
? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}`
|
||||
: tc("Ref_Shared"),
|
||||
"hint",
|
||||
),
|
||||
host,
|
||||
);
|
||||
head.append(slot);
|
||||
if (!opt.readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽
|
||||
if (!readOnly) head.append(ok); // [저장] = 머리 [닫기] 왼쪽
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
@@ -7,15 +7,16 @@
|
||||
* 금액 빠짐) → 그 줄 금액 · 합계 바로(짝 셈 `Labor_Calc.settle`) · 구조물 조합 · 공사 알약이 이어지면 그 값이 앞섬
|
||||
* · 합계 열 = 「기준단위 단가」(줄 1 단위) · 「수량 반영 금액」(× 수량)
|
||||
* · 머리 단추 = [항목 추가](736-1 · 자재는 찾기 창에서 고름 → 자재 목록) · 줄 우클릭 · 줄 끝 ⋯ = 위로 · 아래로 · 별칭 · 삭제
|
||||
* · 줄 누름 = 줄 모달(`Labor_RowModal` — 옵션 · 메모 · 켜쌓기율 · 로직 자재 바꾸기 · 세 칸 · 안내 한 줄 · 856-1) ·
|
||||
* 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸)
|
||||
* · 줄 누름 = 단가산출 줄 = 줄 쌓기(`Labor_SkEdit` · 프로젝트 사본 = 굳힌 문서 보기만 · 856-3) ·
|
||||
* 사전조합 참조 줄 = 서고 원본 모달(`Labor_RefEdit`) · 사용자 자재 줄 = 자재 모달(세 칸) ·
|
||||
* M01 로직을 바로 담은 줄 = 안내 한 줄(창 없음 · 새로 안 생김)
|
||||
* · 금액 = 서버 calc(최신 응답만 · 저장 안 함) · [저장]은 UI_Main(서버가 다시 셈)
|
||||
* · 안 이은 고정 줄(729-3) = 격자 위 띠 · [연결](`Labor_Unlinked` — 이음만 · 저장은 [저장])
|
||||
* 구조물 조합 일위대가(카드 · 열 상세 · PLAN 806-1)도 이 한 부품 — `mode` 없음 = 조합 갈래: 정보 칸(이름 · 구분)
|
||||
* 없음 · 수량 칸 = 수량산출 모달(`Labor_Combo` — 면적산출 잇기) · 규격 열 줄(`Labor_Spec`) · 다이어그램(열 상세) ·
|
||||
* 새 줄 수량 = 면적을 따름(빈 값). 단가산출(SK) 참조 줄 누름 = 그 단가산출 문서 모달(`Labor_SkEdit` — 수식 탭 · 저장 = 그 SK).
|
||||
* 811-1(요구 707-1) — 단가산출 줄 = SK 참조 한 행(저장 때 안 펼침) · [로직 추가] M01 기초 = 이 층 SK 사본 · 다른 층 SK =
|
||||
* 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 = 옛 로직 줄.
|
||||
* 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 표 = 늘 보기만이라 [로직 추가] 없음(856-3).
|
||||
* ========================================================================== */
|
||||
|
||||
import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
|
||||
@@ -49,7 +50,7 @@ import { unlinkedBar } from "./M02_MasterTemplete_Labor_Unlinked";
|
||||
import { pasteInto } from "./M02_MasterTemplete_Labor_Paste";
|
||||
import { openLogicPicker, withSangeun } from "./M02_MasterTemplete_Labor_Pick";
|
||||
import { openRefEdit } from "./M02_MasterTemplete_Labor_RefEdit";
|
||||
import { openMatModal, openRowModal } from "./M02_MasterTemplete_Labor_RowModal";
|
||||
import { openMatModal } from "./M02_MasterTemplete_Labor_RowModal";
|
||||
import { tc } from "./M02_MasterTemplete_Labor_Text";
|
||||
import { insideKeys } from "./M02_Labor_LogicMats_Model";
|
||||
import { valueLine } from "./M02_Labor_Values_Model";
|
||||
@@ -333,26 +334,23 @@ export function mountLaborTable(
|
||||
closed: () => alive && recalc(),
|
||||
});
|
||||
if (row.고정) return; // 고정 줄 = 숫자 그대로(이름 · 별칭은 우클릭)
|
||||
// 단가산출(SK) 줄 = 그 단가산출 문서 모달(수식 탭 · 806-1) — 셈 주입(프로젝트 복사본)엔 줄 모달(안내 · 856-3 까지)
|
||||
if (isSkRef(row.참조) && !opt.calc)
|
||||
return void openSkEdit({
|
||||
ref: row.참조,
|
||||
title: nameOf(row),
|
||||
head: head(),
|
||||
readOnly: !edit || row.참조.층 !== opt.layer,
|
||||
closed: (done) => alive && done && recalc(), // 저장했으면 금액을 다시 셈
|
||||
});
|
||||
openRowModal({
|
||||
row,
|
||||
logic: logics.get(row.로직) ?? null,
|
||||
if (!isSkRef(row.참조)) return showToast(tc("Logic_Direct"), "info"); // M01 로직 줄 — 창 없음(856-3)
|
||||
const ref = row.참조;
|
||||
const sk = {
|
||||
ref,
|
||||
title: nameOf(row),
|
||||
head: head(),
|
||||
watch,
|
||||
readOnly: !edit,
|
||||
inject: !!opt.calc,
|
||||
userMats: cur.자재.map((m) => m.코드),
|
||||
done: (again) => changed(!again),
|
||||
});
|
||||
readOnly: !edit || ref.층 !== opt.layer,
|
||||
closed: (done: boolean) => alive && done && recalc(), // 저장했으면 금액을 다시 셈
|
||||
};
|
||||
// 단가산출(SK) 줄 = 그 단가산출 문서 줄 쌓기(806-1) · 프로젝트 사본 = 굳힌 문서 보기만(856-3)
|
||||
if (!opt.skCopy) return void openSkEdit(sk);
|
||||
void opt
|
||||
.skCopy(ref)
|
||||
.then(
|
||||
(copy) => (copy ? void openSkEdit({ ...sk, copy }) : showToast(tc("Sk_NoCopy"), "error")),
|
||||
failed,
|
||||
);
|
||||
}
|
||||
function openMat(i: number): void {
|
||||
const mat = cur.자재[i];
|
||||
@@ -456,7 +454,7 @@ export function mountLaborTable(
|
||||
changed();
|
||||
},
|
||||
};
|
||||
/** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 옛 로직 줄) */
|
||||
/** SK 사본 길(811-1) — M02 층 일위대가 · 조합만(프로젝트 · 셈 주입 = 늘 보기만 · [로직 추가] 없음 · 856-3) */
|
||||
const own: SkPickScope | null =
|
||||
opt.layer !== "project" && !opt.calc ? { layer: opt.layer, owner: library.owner } : null;
|
||||
const addLogic = createButton({
|
||||
@@ -464,16 +462,12 @@ export function mountLaborTable(
|
||||
variant: "filled",
|
||||
onClick: () =>
|
||||
openLogicPicker((x) => {
|
||||
// 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음)
|
||||
if (own)
|
||||
// 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음)
|
||||
return void skFromLogic(own, x.키).then(
|
||||
void skFromLogic(own, x.키).then(
|
||||
(r) => r && alive && addRef(r, x.이름 || x.키, null),
|
||||
failed,
|
||||
);
|
||||
if (cur.담은로직.some((r) => r.로직 === x.키))
|
||||
return showToast(tc("Labor_Already").replace("{value}", `${x.키} ${x.이름}`), "error");
|
||||
cur.담은로직.push({ 로직: x.키, 별칭: null, 메모: null, 입력값: {}, 수량: fresh() });
|
||||
void loadLogics().then(() => changed());
|
||||
}, withSangeun(library)),
|
||||
});
|
||||
|
||||
@@ -538,7 +532,7 @@ export function mountLaborTable(
|
||||
className: "m01-logic__section-head",
|
||||
children: [
|
||||
el("h3", { text: tc("Grid_Title") }),
|
||||
...(edit && !(combo && opt.card)
|
||||
...(edit && own && !(combo && opt.card)
|
||||
? [el("div", { className: "ui-btn-group", children: [addLogic] })]
|
||||
: []),
|
||||
],
|
||||
|
||||
@@ -42,6 +42,15 @@ const TEXT = {
|
||||
"Edits the library original — every structure using it follows",
|
||||
],
|
||||
Ref_ReadOnly: ["이 층은 고칠 수 없음 — 읽기만", "Read-only layer"],
|
||||
Ref_Copy: [
|
||||
"프로젝트 사본 — 보기만 · 고침은 M02 단가산출에서 고쳐 [재생성]",
|
||||
"Project copy — view only · edit the build-up in M02 and regenerate",
|
||||
],
|
||||
Sk_NoCopy: ["사본에 이 단가산출 문서가 없음", "This copy has no build-up document"],
|
||||
Logic_Direct: [
|
||||
"M01 로직을 바로 담은 줄 — 단가산출 화면 없음 · 단가산출로 담아 쓰세요(일위대가 [로직 추가])",
|
||||
"Uses the M01 logic directly — add it as a build-up to view or edit",
|
||||
],
|
||||
Lib_SaveFailed: ["저장 못 함", "Save failed"],
|
||||
Ref_Discard: ["저장 안 한 고침을 버리고 닫음?", "Discard unsaved edits?"],
|
||||
Labor_Source: ["원문", "Source"],
|
||||
@@ -109,13 +118,9 @@ const TEXT = {
|
||||
],
|
||||
Labor_Code: ["코드", "Code"],
|
||||
Labor_Spec: ["규격", "Spec"],
|
||||
Labor_Already: ["이미 담은 단가산출 기초 — {value}", "Already added — {value}"],
|
||||
Labor_AlreadyMat: ["이미 담은 자재 — {value}", "Already added — {value}"],
|
||||
// 로직 자재(103-1)
|
||||
Labor_InLogicMat: ["로직 자재에 있는 품목 — {value}", "Already a logic material — {value}"],
|
||||
LogicMat_Swap: ["바꾸기", "Change"],
|
||||
LogicMat_Reset: ["기본", "Default"],
|
||||
LogicMat_PickTitle: ["로직 자재 바꾸기", "Change logic material"],
|
||||
LogicMat_Inside: [
|
||||
"로직 단가 안 금액 — 합계에 다시 안 더함",
|
||||
"Inside the logic price — not added again",
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
STmate(.xlsx) = 단가산출근거 시트 G 열 「BDCOD|D…」 머리 · POSS~POSE 몸(숨은 G 열 원문) ·
|
||||
꼬리(계 · 계약단가 · 총계) + 목록표 단가(노무비 · 재료비 · 경비 = E 열 · 숨은 G 열 `COD` ·
|
||||
중기 · 단가산출근거 = E~H 열 계 · 노 · 재 · 경 · 숨은 J 열 메타).
|
||||
EST(.xls · .xlsx) = 단가산출 시트 블록 글(`M02_Hopyo_ReadEst.read`) + 노임단가 ·
|
||||
EST(.xls · .xlsx) = 단가산출 시트 블록 글 + 노임단가 ·
|
||||
자재단가(적용단가) · 기계경비총괄표 · 견적단가 · 단가산출총괄표(적용 칸 · 합이 안 맞으면 당초 칸).
|
||||
"""
|
||||
|
||||
|
||||
@@ -13,7 +13,7 @@
|
||||
구성 없음 → 직접(그 파일 시간당 노 · 재 · 경).
|
||||
잇기(`attach` · 층 저장 길 `M02_Sangeun_FromHopyo.make` 만) = 그 층 내 기계 같은 이름 · 규격이면 그 줄 · 없으면
|
||||
새로(`M02_MyMachine.create`) · 바로 = 기계 줄 이음 키 · 로직 줄 = 시간당 부름 글 / 직접 = 이음 없이 자원
|
||||
`내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당 · `M02_Sangeun_Imported.row_of`) ·
|
||||
`내기계` 키(셈 = 그 파일 값 · [우리 단가로] = 내 기계 시간당) ·
|
||||
원본 `내기계` [{키, 이름, 규격, 새로}] · 개인 층 아님 = 안 만듦(원본 `내기계예정` [{이름, 규격}] 만).
|
||||
금액(엑셀 단가 그대로)은 줄 값을 안 건드려 그대로.
|
||||
기계 한 대 안 여러 줄(842-4) = 구성에 `인력줄` [[직종 글, 인]] · `연료줄` [[종류, ℓ]] · `잡품줄` [율 %] · `재료줄` [[이름, 수량, 단위]]
|
||||
|
||||
@@ -92,11 +92,6 @@ def hourly_of(key: str) -> dict:
|
||||
return _HOURLY["rows"][key]
|
||||
|
||||
|
||||
def row_of(doc: Any) -> None:
|
||||
"""옛 가져온 줄(엔진 로직 줄) — 857-3b 부터 저장 안 함 · 읽지 않음(늘 None · 2-D 가 부름 걷음)."""
|
||||
return None
|
||||
|
||||
|
||||
def base_row(doc: dict) -> dict[str, Any]:
|
||||
"""바탕 없는 SK 바탕 줄(`sd.empty_row`) — 입력 · 줄 없음 · 가져온 식 결과단위 = 문서 결과단위(1 단위 배)."""
|
||||
first = (doc.get(KEY) or {}).get(FIRST) if isinstance(doc.get(KEY), dict) else None
|
||||
|
||||
Reference in New Issue
Block a user