diff --git a/A00_Common/master_unit_swap.ts b/A00_Common/master_unit_swap.ts index 6ac088014..b30ffc4fa 100644 --- a/A00_Common/master_unit_swap.ts +++ b/A00_Common/master_unit_swap.ts @@ -13,13 +13,14 @@ const ALIAS: Record = { 리터: "ℓ", set: "조", 세트: "조", + hr: "시간", }; const UNITS: Record> = { 무게: { g: 1, kg: 1000, 톤: 1000000 }, 길이: { mm: 1, cm: 10, m: 1000, km: 1000000 }, 넓이: { cm2: 1, m2: 10000 }, 부피: { cm3: 1, ℓ: 1000, m3: 1000000 }, - 개수: { 개: 1, 본: 1, 매: 1 }, + 개수: { 개: 1, 본: 1, 매: 1, 개소: 1 }, }; const SCALE: Record = {}; for (const [kind, group] of Object.entries(UNITS)) { diff --git a/M01_MasterData/M01_MasterData_UI_LogicLab_Ho.ts b/M01_MasterData/M01_MasterData_UI_LogicLab_Ho.ts index f76aa17f8..4229f4f45 100644 --- a/M01_MasterData/M01_MasterData_UI_LogicLab_Ho.ts +++ b/M01_MasterData/M01_MasterData_UI_LogicLab_Ho.ts @@ -449,17 +449,22 @@ function formulaCell(e: Entry, ctx: HoContext, text = ""): HTMLElement { const tagOf = (x: object): string | undefined => (x as { 꼬리표?: string }).꼬리표 || undefined; const sourceTag = (text: string): HTMLElement => { - const tag = createBadge(text, "neutral"); + const [shown, ...tip] = text.split("\n"); // 첫 줄 = 보임 · 나머지 = 풍선(없으면 같은 글) — 740-2 + const tag = createBadge(shown, "neutral"); tag.classList.add("m01lab__src"); - tag.title = text; + tag.title = tip.length ? tip.join(" ") : shown; return tag; }; function nameCell(e: Entry, label: string, tag: string): HTMLElement { return el("div", { children: [ - el("div", { text: label }), - ...(e.source ? [sourceTag(e.source)] : []), + e.source + ? el("div", { + className: "m01lab__namerow", // 이름 옆에 꼬리표 — 줄 높이 안 바뀜(740-2) + children: [el("span", { text: label }), sourceTag(e.source)], + }) + : el("div", { text: label }), ...(e.share && label === e.name ? [createBadge(`${e.share} ${tl("Share")}`, "accent")] : []), ...(e.spec ? [el("div", { className: "ui-text ui-text--muted", text: e.spec })] : []), ...(e.warn ? [createBadge(`${tx("Calc_UnitWarn")} · ${e.warn}`, "warning")] : []), diff --git a/M02_MasterTemplete/M02_Hopyo_Elem.py b/M02_MasterTemplete/M02_Hopyo_Elem.py new file mode 100644 index 000000000..86f2c99ce --- /dev/null +++ b/M02_MasterTemplete/M02_Hopyo_Elem.py @@ -0,0 +1,125 @@ +"""M02 일위대가 불러오기 — 못옮김 · 안 이은 기계 줄 → M01 요소 후보 셋(PLAN 746-1 · 요구 585). + +후보 = `[{키, 갈래 노임|기계|자재, 이름, 규격, 단위, 단가}]` 셋까지 — 보여주기만(자동 이음 없음 · 고르면 지금 +잇기 길 `{노임|기계|자재: 키}`). + 자재 = `M02_Hopyo_Material.candidates` 점수(이름 글자 묶음 · 규격) · 단가 = M01 자재 값(엑셀 줄 단위) + 노임 = LB 이름 글자 묶음 닮음 · 단가 = LB 값 + 기계 = EQ 갈래 겹침 · 규격 수(같음 1 · 겹침 0.5) · 이름 낱말 덤 · 단가 없음(기계경비는 로직 셈) +차례 = 점수(0.1 단위로 접음) › 엑셀 단가에 가까운 것(엑셀 단가 = 블록 글 「이름 단가 × 식 = 금액」 · 모르면 점수만). +서버 단독 · 읽기만. +""" + +from __future__ import annotations + +import math +import re +from typing import Any + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Hopyo_Finger as finger +from M02_MasterTemplete import M02_Hopyo_Match as hm +from M02_MasterTemplete import M02_Hopyo_Material as hmat +from M02_MasterTemplete.M02_Hopyo_Words import mtypes, parse_rhs, specnums + +TOP = 3 +POOL = 5 + + +def prices(block: dict[str, Any] | None) -> dict[str, float]: + """블록 글 → `{이름: 엑셀 단가}`(직종 줄 「직종 : 단가 × 식」 · 자재 줄 「이름 단가 × 식 = 금액」).""" + out: dict[str, float] = {} + for raw in (block or {}).get("글") or []: + row = str(raw).rstrip() + cm = finger._COLON.match(row) + mm = None if cm else finger._MAT.match(row) + name = (cm or mm).group("name").strip() if (cm or mm) else "" + got = parse_rhs((cm or mm).group("rhs")) if name else None + if got and got.get("단가"): + out.setdefault(re.sub(r"^[0-9가-힣]\.", "", name).strip(), float(got["단가"])) + return out + + +def _gap(price: Any, want: float | None) -> float: + try: + p = float(price) + except (TypeError, ValueError): + return math.inf + return abs(math.log(p / want)) if want and p > 0 else math.inf + + +def _order(rows: list[tuple[float, dict]], want: float | None) -> list[dict]: + rows.sort(key=lambda x: -x[0]) + pool = rows[:POOL] + pool.sort(key=lambda x: (-round(x[0], 1), _gap(x[1].get("단가"), want))) + return [one for _, one in pool[:TOP]] + + +def _num(x: Any) -> int | float | None: + if x is None: + return None + f = float(x) + return int(f) if f == int(f) else round(f, 4) + + +def materials(name: str, unit: str = "", want: float | None = None) -> list[dict[str, Any]]: + whole = m01.loaded()[1] + rows = [] + for c in hmat.candidates({"이름": name, "규격": "", "단위": unit}, POOL): + code = c.get("자재") + if not code: + continue + try: + price = hmat.mm.element(whole, code, {}, unit or None)[0] + except Exception: # noqa: BLE001 — 값 못 읽음 = 단가 없음 + price = None + one = {"키": code, "갈래": "자재", "이름": c.get("이름"), "규격": c.get("규격") or ""} + rows.append((c.get("점수") or 0.0, {**one, "단위": c.get("단위"), "단가": _num(price)})) + return _order(rows, want) + + +def labor(name: str, want: float | None = None) -> list[dict[str, Any]]: + whole = m01.loaded()[1] + me = hm._grams(re.sub(r"\s", "", name)) + rows = [] + for row in whole.numbers.get("LB", {}).values(): + them = hm._grams(re.sub(r"\s", "", str(row.get("이름") or ""))) + score = 2 * len(me & them) / (len(me) + len(them)) + if score > 0: + one = {"키": str(row.get("키")), "갈래": "노임", "이름": row.get("이름"), "규격": ""} + rows.append((score, {**one, "단위": "인", "단가": _num(row.get("값"))})) + return _order(rows, want) + + +def machines(text: str, kinds: set | None = None, nums: set | None = None) -> list[dict]: + """기계 글(이름 규격) → EQ 후보 — 갈래 · 규격 수가 없으면 글에서 읽음.""" + whole = m01.loaded()[1] + kinds = set(kinds or ()) or mtypes(text) + nums = set(nums or ()) or set(specnums(text)) + mine = hm.words(text) + rows = [] + for row in whole.numbers.get("EQ", {}).values(): + types = mtypes(f"{row.get('상세구분')} {row.get('이름')}") + if not kinds & types: + continue + spec = set(specnums(row.get("규격"))) + score = len(kinds & types) / len(kinds | types) + score += 1.0 if nums and nums == spec else 0.5 if nums & spec else 0.0 + score += 0.3 * len(mine & hm.words(row.get("이름"))) + one = {"키": str(row.get("키")), "갈래": "기계", "이름": row.get("이름")} + unit = (row.get("단위") or {}).get("내용시간") if isinstance(row.get("단위"), dict) else "" + rows.append( + (score, {**one, "규격": row.get("규격") or "", "단위": unit or "시간", "단가": None}) + ) + return _order(rows, None) + + +def lost(one: dict[str, Any], want: float | None = None) -> list[dict[str, Any]]: + """못옮김 한 줄(`M02_Hopyo_SkPatch` 꼴) → 후보.""" + kind, name = one.get("갈래"), str(one.get("이름") or "") + if kind == "자재": + return materials(name, str(one.get("단위") or ""), want) + if kind == "노임": + return labor(name, want) + if kind == "기계": + return machines(f"{name} {one.get('규격') or ''}", set(name.split("·"))) + return [] diff --git a/M02_MasterTemplete/M02_Hopyo_Fit.py b/M02_MasterTemplete/M02_Hopyo_Fit.py index b4a3c16a4..a5b58c2cf 100644 --- a/M02_MasterTemplete/M02_Hopyo_Fit.py +++ b/M02_MasterTemplete/M02_Hopyo_Fit.py @@ -377,13 +377,22 @@ def run_job(folder: Path, key: str) -> dict[str, Any]: if unit not in out["블록"]: out["블록"][unit] = compute(block, line, targets) out["셈"] = [at, len(todo)] - if at % EVERY == 0: - atomic_write_json(path, out) + if at % EVERY == 0 and not _put(folder, key, path, out): + return out out["끝"] = True - atomic_write_json(path, out) + _put(folder, key, path, out) return out +def _put(folder: Path, key: str, path: Path, out: dict[str, Any]) -> bool: + """캐시 씀 — 셈 도중 HP 를 끝냈으면(743-1) 안 쓰고 지움 → 거짓.""" + if not _hp_path(folder, key).is_file(): + path.unlink(missing_ok=True) + return False + atomic_write_json(path, out) + return True + + def _work() -> None: while True: folder, key = _JOBS.get() diff --git a/M02_MasterTemplete/M02_Hopyo_Forget.py b/M02_MasterTemplete/M02_Hopyo_Forget.py new file mode 100644 index 000000000..adfca6def --- /dev/null +++ b/M02_MasterTemplete/M02_Hopyo_Forget.py @@ -0,0 +1,205 @@ +"""M02 일위대가 불러오기 끝냄(PLAN 743-1 · 요구 582-3 · 584-2) — 올린 엑셀은 그 불러오기 동안만. + +끝냄 한 길 `finish` = [끝내기] · 화면 떠남 · 하루 지남(`Store.EXPIRE`) · 붙여넣기 만듦 뒤 · +엑셀 보기 [삭제]: + HP · 격자 · 맞춤셈 캐시 지움 · 그 HP 로 만든 이 층 일위대가(SC) · 단가산출(SK) 엑셀 사본 걷음 + (`본뜬` → 출처 `{층 「실무자료」, 파일, 때, 누가}` + 전국자재 · 복사원본 · + SC 줄 메모 「실무 …」 걷음 · `본뜬.실무수량` = 모든 값이 그 줄 저장 `수량.손` 과 같을 때만 + 걷음(742-1 · 다르면 남김 = 금액 그대로)) · SK `본뜬.또` = 그 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 +from typing import Any + +from common_util.common_util_json import atomic_write_json +from M02_MasterTemplete import M02_Hopyo_Store as hopyo_store +from M02_MasterTemplete import M02_Labor_Ref as refs + +ORIGIN = "실무자료" +KEEP = ("층", "파일", "전국자재", "복사원본") +_MEMO = re.compile(r"^실무 ") +_HP = re.compile(r"^(HP-\d{6}) ") + + +# ── 사본 걷음(순수) ─────────────────────────────────────────────────── +def _slim(got: dict[str, Any]) -> dict[str, Any]: + """출처만 — 파일 · 때 · 누가(+ 전국자재 · 복사원본).""" + sure = got.get("확인") if isinstance(got.get("확인"), dict) else {} + out = {k: got[k] for k in KEEP if got.get(k) is not None} + return {**out, "층": ORIGIN, "때": sure.get("때"), "누가": sure.get("누가")} + + +def _hand(one: Any) -> Any: + qty = one.get("수량") if isinstance(one, dict) else None + return qty.get("손") if isinstance(qty, dict) else None + + +def _carried(doc: dict[str, Any], hands: dict[str, Any]) -> bool: + """실무수량 값이 모두 그 줄 · 자재 저장 수량과 같음(742-1 저장 뒤).""" + lines = doc.get("담은로직") or [] + mats = {m.get("코드"): m for m in doc.get("자재") or [] if isinstance(m, dict)} + for at, value in (hands.get("줄") or {}).items(): + i = int(at) if str(at).isdigit() else -1 + if not 0 <= i < len(lines) or _hand(lines[i]) != value: + return False + return all(_hand(mats.get(code)) == value for code, value in (hands.get("자재") or {}).items()) + + +def strip_sc(doc: dict[str, Any]) -> dict[str, Any]: + """일위대가(SC) 엑셀 사본 걷음 — 본뜬 출처만 · 줄 메모 「실무 …」 뺌.""" + got = doc.get("본뜬") or {} + lines = [ + {k: v for k, v in one.items() if k != "메모"} + if isinstance(one, dict) and _MEMO.match(str(one.get("메모") or "")) + else one + for one in doc.get("담은로직") or [] + ] + out = {**doc, "담은로직": lines, "본뜬": _slim(got)} + hands = got.get("실무수량") + if isinstance(hands, dict) and hands and not _carried(out, hands): + out["본뜬"]["실무수량"] = hands # 742 전 저장본 — 셈이 기대므로 남김 + return out + + +def strip_sk(doc: dict[str, Any], gone: Callable[[dict], bool]) -> dict[str, Any]: + """단가산출(SK) — 끝낸 출처(`gone(본뜬 · 또 한 칸)`) 몫만 걷음 · 다른 불러오기 몫은 그대로.""" + got = doc.get("본뜬") or {} + also = [x for x in got.get("또") or [] if isinstance(x, dict) and not gone(x)] + own = _slim(got) if gone(got) else {k: v for k, v in got.items() if k != "또"} + return {**doc, "본뜬": {**own, "또": also} if also else own} + + +# ── 끝냄 ───────────────────────────────────────────────────────────── +def _docs(folder: Path, kind: str): + prefix = "SC" if kind == "precombo" else "SK" + for path in sorted((folder / kind).glob(f"{prefix}-*.json")): + try: + doc = json.loads(path.read_bytes()) + except (OSError, ValueError): + continue + got = doc.get("본뜬") if isinstance(doc, dict) else None + if isinstance(got, dict) and got.get("층") == ORIGIN: + yield path, doc + + +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` 거짓 = 셈만).""" + folder, out = Path(folder), [] + here = refs.where(folder) + + def hit(one: dict[str, Any]) -> bool: + mark = str(one.get("키") or "") + return bool(mark) and _here(one, here) and gone(mark) + + for kind in ("precombo", "sangeun"): + for path, doc in _docs(folder, kind): + got = doc["본뜬"] + if not any(hit(x) for x in [got, *(got.get("또") or [])] if isinstance(x, dict)): + continue + new = strip_sc(doc) if kind == "precombo" else strip_sk(doc, hit) + if new != doc: + out.append(path.stem) + if apply: + atomic_write_json(path, new) + return out + + +def _caches(folder: Path, key: str) -> list[Path]: + from M02_MasterTemplete import M02_Hopyo_Fit as fit + + try: + got = fit.cache_path(folder, key) + except Exception: # noqa: BLE001 — 캐시 자리 못 찾음 = 지울 것 없음 + return [] + return list(got.parent.glob(f"{'_'.join(got.name.split('_')[:2])}_*.json")) + + +def finish(folder: str | Path, key: str) -> dict[str, Any]: + """불러오기 끝냄 — 만든 문서 사본 걷음 · HP · 격자 · 맞춤셈 캐시 지움 → `{지움, 만든}`.""" + folder = Path(folder) + hopyo_store.read(folder, key) # 없으면 404 + head = f"{key} " + made = forget(folder, lambda mark: mark.startswith(head)) + caches = _caches(folder, key) # HP 지우기 전에 자리 셈(HP 지문) + hopyo_store.delete(folder, key) # 먼저 지움 — 뒤 셈은 HP 없으면 캐시 안 씀(`Fit._put`) + # ponytail: 뒤 셈이 HP 확인 직후 · 쓰기 직전이면 한 벌 남을 수 있음(ms 틈) — tmp 캐시라 둠 + for old in caches: + old.unlink(missing_ok=True) + return {"지움": key, "만든": len(made)} + + +def expired(folder: str | Path, now: datetime | None = None) -> list[str]: + """하루 지난 작업 중 HP 키(`M02_Hopyo_Store.stale`).""" + out = [] + for path in sorted((Path(folder) / hopyo_store.DIRNAME).glob("HP-*.json")): + doc = hopyo_store._load(path) + if isinstance(doc, dict) and doc.get("지문") and hopyo_store.stale(doc, now): + out.append(path.stem) + return out + + +def sweep(folder: str | Path, now: datetime | None = None) -> list[str]: + """하루 지난 HP 끝냄 → 끝낸 키.""" + 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:])) diff --git a/M02_MasterTemplete/M02_Hopyo_Line.py b/M02_MasterTemplete/M02_Hopyo_Line.py index f2b98770a..3ebb01590 100644 --- a/M02_MasterTemplete/M02_Hopyo_Line.py +++ b/M02_MasterTemplete/M02_Hopyo_Line.py @@ -309,7 +309,12 @@ def _grouped(got: dict, line: dict, ctx: Ctx) -> dict: return {**c, "뜻겹침": hm.near(mine, one["words"]), "출처같음": same, "책": book} named = [mark(c) for c in hm.name_cands(line, ctx.got)] - return {**got, "후보": [mark(c) for c in got.get("후보") or []], "이름후보": named} + cands = [mark(c) for c in got.get("후보") or []] + # 745-1 미리 고름 점 — 「다른 점」 1위 + 출처 같음 · 누르기는 사용자 + top = cands[0] if cands else {} + if top.get("판정") == "다른 점" and top.get("출처같음"): + top["미리"] = True + return {**got, "후보": cands, "이름후보": named} def _ledger_off(entry: dict | None, alias: dict) -> bool: diff --git a/M02_MasterTemplete/M02_Hopyo_Paste.py b/M02_MasterTemplete/M02_Hopyo_Paste.py index 4bfc4c117..5cc8d666d 100644 --- a/M02_MasterTemplete/M02_Hopyo_Paste.py +++ b/M02_MasterTemplete/M02_Hopyo_Paste.py @@ -24,6 +24,7 @@ from typing import Any from M02_MasterTemplete import M02_Hopyo_Build as hb from M02_MasterTemplete import M02_Hopyo_Excel as hx from M02_MasterTemplete import M02_Hopyo_Fixed as hfix +from M02_MasterTemplete import M02_Hopyo_Forget as forget from M02_MasterTemplete import M02_Hopyo_Store as hstore from M02_MasterTemplete import M02_MasterTemplete_Store as store @@ -296,7 +297,8 @@ def paste( folder: Any, text: str, cols: Any, who: Any, lines_only: bool = False, taken: Any = () ) -> dict[str, Any]: """[Ctrl+V] — `갈래` 「물음」(열 짝 짐작 + 보기 · 안 씀) · 「줄」(호표 머리 없음 · `lines_only`) · - 「만듦」(호표 머리 있음 = 실무자료 「붙여넣기 …」 + 호표마다 사전조합 · 705-3 `build_all` 그대로).""" + 「만듦」(호표 머리 있음 = 실무자료 「붙여넣기 …」 + 호표마다 사전조합 · 705-3 `build_all` 그대로 + · 만든 뒤 실무자료 끝냄 743-1).""" try: parsed = read_text(text, cols) except PasteError as error: @@ -310,4 +312,6 @@ def paste( return {**head, "갈래": "줄", **fixed_lines(parsed, taken)} keep = {k: parsed[k] for k in ("꼴", "시트", "호표", "단산", "검산")} row = hstore.save(folder, f"{SHEET} {datetime.now():%m-%d %H:%M}", keep, who) - return {**head, "갈래": "만듦", "키": row["키"], **hb.build_all(folder, folder, row["키"], who)} + made = hb.build_all(folder, folder, row["키"], who) + forget.finish(folder, row["키"]) # 743-1 — 붙인 글 실무자료는 만든 뒤 지움(엑셀 사본 걷음) + return {**head, "갈래": "만듦", "키": row["키"], **made} diff --git a/M02_MasterTemplete/M02_Hopyo_SkLink.py b/M02_MasterTemplete/M02_Hopyo_SkLink.py index 3cd6f3cca..171e352a5 100644 --- a/M02_MasterTemplete/M02_Hopyo_SkLink.py +++ b/M02_MasterTemplete/M02_Hopyo_SkLink.py @@ -15,6 +15,7 @@ from decimal import Decimal from typing import Any from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Hopyo_Elem as elem from M02_MasterTemplete import M02_Hopyo_Finger as finger from M02_MasterTemplete import M02_Hopyo_Sangeun as sangeun from M02_MasterTemplete import M02_Labor_Doc as labor @@ -118,10 +119,13 @@ def kept( def left(line: dict[str, Any], why: dict | None) -> dict[str, Any]: - """남은 줄 한 줄 — 엑셀 줄 · 갈래 · 까닭 · 후보.""" + """남은 줄 한 줄 — 엑셀 줄 · 갈래 · 까닭 · 후보(기계 = M01 EQ 셋 · 746-1).""" kind = finger.kind_of(line) keep = ("차례", "이름", "규격", "단위", "수량") out = {**{k: line.get(k) for k in keep}, "갈래": kind} out["까닭"] = (why or {}).get("까닭") or WHY.get(kind, "이을 것 없음") more = {k: v for k, v in (why or {}).items() if k not in ("까닭", "후보")} - return {**out, "후보": (why or {}).get("후보") or [], **more} + cands = (why or {}).get("후보") or [] + if not cands and kind == "기계": + cands = elem.machines(f"{line.get('이름') or ''} {line.get('규격') or ''}") + return {**out, "후보": cands, **more} diff --git a/M02_MasterTemplete/M02_Hopyo_SkPatch.py b/M02_MasterTemplete/M02_Hopyo_SkPatch.py index f4073176f..ef390969d 100644 --- a/M02_MasterTemplete/M02_Hopyo_SkPatch.py +++ b/M02_MasterTemplete/M02_Hopyo_SkPatch.py @@ -12,7 +12,10 @@ `[{id, 노임|기계|자재: 키}]` = SK 더한줄 인력 · 기계 · 재료(엑셀 수량 그대로) · `{id, 뺌: 까닭}` = 놓음. SK 단위(728-2) = 엑셀 줄 단위 · 바탕 기준단위와 성격 다름 = 환산 계수 = 우리 품 ÷ 엑셀 품(인력 · 장비 둘 이상이 같은 비일 때만 · `환산` {계수}) · 못 구함 = 고름 대기(까닭 「단위 성격 다름 · 계수 필요」). - 고름 대기 = 후보 · 숫자 없음 — SK 안 만듦 · 후보 다섯(사용자가 고른 기초 `pick` = 견줘 SK · 기초). + 고름 대기 = 후보 · 숫자 없음 — SK 안 만듦 · 후보 다섯(사용자가 고른 기초 `pick` = 견줘 SK · 기초) · + 앞 셋 `줄비교`(746-1) = 그 기초로 견준 줄마다 꼴(같음 · 품다름 · 엑셀만 · 기초만 · 1 단위 품) · 못옮김 · + 견줌 못함(단위 성격 다름) = null — 판정 · 순위 · 미리 고름은 안 바꿈. + 못옮김 `후보` = M01 요소 셋(`M02_Hopyo_Elem` · 보여주기만). cid = `kind:키#n`(첫 기초 바탕 줄만 · `M02_Sangeun_Doc.line_ids`) · 더한줄 · 덮개 qty = 바탕 행 몫 (1 단위 품 × 바탕 결과단위 앞 수 · 셈이 ÷ 배) · 더한줄 로직 수량 = 몫 × 바탕 배 ÷ 그 기초 배. 품 견줌 = 우리 셈(`M02_Sangeun_Calc.run` 줄 수량 ÷ 배) · 같음 = `Option.near`(0.5 % + 엑셀 자릿수 반올림). @@ -27,6 +30,7 @@ from decimal import Decimal from typing import Any from M02_MasterTemplete import M02_Hopyo_Combine as combine +from M02_MasterTemplete import M02_Hopyo_Elem as elem from M02_MasterTemplete import M02_Hopyo_Finger as finger from M02_MasterTemplete import M02_Hopyo_Fit as fit from M02_MasterTemplete import M02_Hopyo_Option as option @@ -40,6 +44,8 @@ KEYS = ("덮개", "자재표시", "더한줄", "뺀줄", "못옮김") TINY = 1e-9 _ADD = re.compile(r"^add:#(\d+)$") UNIT_WHY = "단위 성격 다름 · 계수 필요" +LOOKS = ("같음", "품다름", "엑셀만", "기초만") # 줄비교 꼴(746-1) +COMPARE = 3 # 고름 대기 후보 앞 몇에 줄비교 LINK = { "노임": ("인력", "LB"), "기계": ("기계", "EQ"), @@ -96,7 +102,7 @@ def parts(doc: dict, whole: Any) -> list[dict[str, Any]]: if kind == "인력": one.update(갈래="인력", 이름=labor.get(str(item.get("요소")), str(item.get("이름")))) elif kind == "재료": - one.update(갈래="자재", 이름=str(item.get("이름") or "")) + one.update(갈래="자재", 이름=str(item.get("이름") or ""), 단위=item.get("단위") or "") elif kind == "로직" and found: sub = found.group(1) if ours.is_mach_logic(whole.logic(sub)): @@ -138,6 +144,27 @@ class _Plan: self.lines = parts(doc, whole) self.lost: list[dict[str, Any]] = [] self.lb = {name: key for key, name in ours._labor_names().items()} + self.rows: list[dict[str, Any]] = [] # 줄비교(746-1) + self.prices: dict[str, float] = {} # 엑셀 단가(못옮김 후보 차례) + + def note(self, kind: str, name: str, excel: float, mine: float | None, **more: Any) -> None: + """줄비교 한 줄 — 꼴 = 같음 · 품다름 · 엑셀만 · 기초만(`꼴` 주면 그대로).""" + look = more.pop("꼴", None) + if look is None: + if excel and mine: + look = LOOKS[0] if _near(excel, mine) else LOOKS[1] + else: + look = LOOKS[2] if excel else LOOKS[3] + num = lambda x: _num(float(f"{x:.10g}")) if x else None # noqa: E731 + one = { + "갈래": kind, + "이름": name, + "규격": "", + "단위": "", + "엑셀": num(excel), + "기초": num(mine), + } + self.rows.append({**one, **more, "꼴": look}) def cover(self, cid: str, **one: float) -> None: self.doc["덮개"][cid] = {k: _num(v) for k, v in one.items()} @@ -155,7 +182,8 @@ class _Plan: n = sum(1 for x in self.lost if (x["갈래"], x["이름"]) == (kind, name)) one = {"id": base if not n else f"{base}#{n}", "갈래": kind, "이름": name, "규격": "", "단위": "", "수량": _num(float(f"{qty:.10g}")), "글": text, "후보": []} # fmt: skip - self.lost.append({**one, **more}) + one = {**one, **more} + self.lost.append({**one, "후보": elem.lost(one, self.prices.get(name))}) def link(self, picks: list[dict[str, Any]]) -> None: """사용자 잇기 — 이은 줄 = 더한줄(엑셀 수량 × 배) · 뺌 = 놓음 · 나머지 못옮김 그대로.""" @@ -191,6 +219,7 @@ class _Plan: for t in sorted(set(excel) | {x["이름"] for x in mine if x["품"]} | set(extra)): a, rows = excel.get(t, 0.0), [x for x in mine if x["이름"] == t] b, f = sum(x["품"] for x in rows), extra.get(t, 0.0) + self.note("인력", t, a, b + f, 단위="인") if a and _near(a, b + f): continue want = a - f @@ -224,10 +253,11 @@ class _Plan: and _near(h, x["품"])), None) # fmt: skip if hit is not None: used.add(hit["cid"]) + self._mnote(m, h, hit["품"]) continue at = next((i for i, (a, q) in enumerate(fixed) if a & kinds and _near(h, q)), None) if at is not None: - fixed.pop(at) + self._mnote(m, h, fixed.pop(at)[1]) continue rest.append(m) for m in rest: @@ -236,15 +266,23 @@ class _Plan: same.sort(key=lambda x: not (sp and sp & x["규격"])) if same: used.add(same[0]["cid"]) + self._mnote(m, m["시간"], same[0]["품"]) self.cover(same[0]["cid"], qty=m["시간"] * self.tb) else: + self._mnote(m, m["시간"], None) self._add_machine(m, line) for x in mine: if x["cid"] not in used: + self._mnote({"갈래": sorted(x["종류"]), "규격": sorted(x["규격"])}, 0.0, x["품"]) self.drop(x["cid"]) for a, q in fixed: + self._mnote({"갈래": sorted(a)}, 0.0, q) self.miss("기계", "·".join(sorted(a)), q, "우리만 장비 — 더한 기초 안", 단위="시간") + def _mnote(self, m: dict[str, Any], excel: float, mine: float | None) -> None: + spec = " ".join(f"{x:g}" for x in sorted(m.get("규격") or [])) + self.note("장비", "·".join(sorted(m["갈래"])), excel, mine, 규격=spec, 단위="시간") + def _add_machine(self, m: dict[str, Any], line: dict[str, Any]) -> None: """엑셀만 장비 → 기계경비 로직 줄(기계 = 그 갈래 · 규격 옵션 거꾸로 찾기).""" fp = finger.empty(line) @@ -267,11 +305,14 @@ class _Plan: for m in excel: words = option.mat_words(m["이름"]) rows = [x for x in mine if option._named(words, x["이름"])] + unit = next((x["단위"] for x in rows if x.get("단위")), "") if rows and all(x["품"] is None for x in rows): # 우리 = 별도계상 · 엑셀 = 블록 안 + self.note("자재", m["이름"], m["품"], None, 단위=unit, 꼴=LOOKS[1]) self.doc["자재표시"][rows[0]["cid"]] = {"별도계상": "직접계산"} self.cover(rows[0]["cid"], qty=m["품"] * self.tb) continue rows = [x for x in rows if x["품"] is not None] + self.note("자재", m["이름"], m["품"], sum(x["품"] for x in rows) or None, 단위=unit) if rows and _near(m["품"], sum(x["품"] for x in rows)): continue if rows: @@ -309,11 +350,29 @@ def _need(code: str, unit: str, whole: Any) -> dict[str, Any] | None: return None if swap["배"] is not None else {"가": got[0], "나": unit, "갈래": swap["계수"]} -def _wait(entry: dict, whole: Any, unit: str, why: str | None = None) -> dict[str, Any]: +def compare( + entry: dict, block: dict | None, line: dict, whole: Any, code: str, efp: dict | None = None +) -> dict | None: + """고른 기초 `code` 로 견준 줄비교 `{줄, 수, 못옮김, 환산?}`(만들지 않음) · 견줌 못함 = None.""" + got = plan(entry, block, line, whole, {"로직": code}, efp) + if got["갈래"] == WAIT: + return None + rows = got["줄비교"] + out = {"줄": rows, "수": {k: sum(x["꼴"] == k for x in rows) for k in LOOKS}} + out["못옮김"] = got["못옮김"] + return out | ({"환산": got["환산"]} if got.get("환산") else {}) + + +def _wait( + entry: dict, whole: Any, unit: str, why: str | None = None, at: tuple | None = None +) -> dict[str, Any]: + """고름 대기 — `at` = (맞춤셈, 블록, 줄 · 사용자 고름 없을 때) 이면 앞 셋에 줄비교.""" keep = ("로직", "이름", "단위", "판정", "글") cands = [{k: c.get(k) for k in keep} for c in (entry.get("후보") or [])[: fit.TOP_OPT]] - for c in cands: + for i, c in enumerate(cands): c["계수"] = _need(str(c.get("로직") or ""), unit, whole) + if at and i < COMPARE and c.get("로직"): + c["줄비교"] = compare(*at[:3], whole, str(c["로직"]), *at[3:]) if why is None: why = "맞는 기초 없음 — " + ((entry.get("판정") or {}).get("글") or "후보 없음") return {"갈래": WAIT, "까닭": why, "후보": cands} @@ -346,13 +405,14 @@ def plan( line: dict[str, Any], whole: Any, pick: dict | None = None, + efp: dict | None = None, ) -> dict[str, Any]: """블록 한 칸 → `{갈래 기초|SK|고름 대기, 바탕, 입력값, 환산?, 덮개, 자재표시, 더한줄, 뺀줄, 못옮김, 놓음, 엑셀품, 후보?}` · `pick` = 사용자 `{로직?, 입력값?, 환산?, 잇기?}` — 로직 = 고른 기초(옵션 없으면 거꾸로 찾음 · 늘 견줌) · 환산 = SK `환산` 꼴 · 잇기 = 못옮김 잇기(`_Plan.link` · 틀림 `LinkError`).""" entry, pick = entry or {}, pick or {} state = (entry.get("판정") or {}).get("상태") - efp = finger.excel(block, line) + efp = efp or finger.excel(block, line) # 줄비교 = 한 번 푼 지문 unit = str(line.get("단위") or "").strip() or "식" if pick.get("로직"): code = str(pick["로직"]) @@ -363,7 +423,7 @@ def plan( code = entry["차례"][0] given = ((entry.get("옵션") or {}).get(code) or {}).get("입력") or {} else: - return _wait(entry, whole, unit) + return _wait(entry, whole, unit, at=(entry, block, line, efp)) doc = {"키": "SK-000000", "이름": "견줌", "단위": unit, "바탕": {"로직": code}, "입력값": dict(given), "덮개": {}, "뺀줄": [], "자재표시": {}} # fmt: skip if pick.get("환산"): @@ -386,7 +446,8 @@ def plan( if code not in [c.get("로직") for c in cands]: cands = [{"로직": code, "이름": row.get("이름")}, *cands] why = f"{UNIT_WHY} — {str(e).split(' · ', 1)[-1]}" - return _wait({"후보": cands}, whole, unit, why) + at = None if pick else (entry, block, line, efp) + return _wait({"후보": cands}, whole, unit, why, at) doc["환산"] = {"계수": coef} tb = float(calc.ratio_of(doc, row, whole)) doc["더한줄"] = extras(tb) @@ -396,11 +457,12 @@ def plan( base = {**dict.fromkeys(KEYS[:2], {}), **dict.fromkeys(KEYS[2:], []), "놓음": []} return {**head, "갈래": BASE, **base} work = _Plan(doc, whole) + work.prices = elem.prices(block) work.labor({t: x["품"] for t, x in efp["인력"].items() if x.get("품")}) work.machines([m for m in efp["장비"] if m.get("시간")], line) work.materials([m for m in efp["자재"] if m.get("품")]) work.link(pick.get("잇기") or []) out = {k: doc[k] for k in KEYS[:4]} changed = any(out.values()) or bool(work.lost) - kept = {"못옮김": work.lost, "놓음": doc.get("놓음") or []} + kept = {"못옮김": work.lost, "놓음": doc.get("놓음") or [], "줄비교": work.rows} return {**head, **out, "갈래": SK if changed else BASE, **kept} diff --git a/M02_MasterTemplete/M02_Hopyo_Store.py b/M02_MasterTemplete/M02_Hopyo_Store.py index 8fd3e0add..53ef5ead8 100644 --- a/M02_MasterTemplete/M02_Hopyo_Store.py +++ b/M02_MasterTemplete/M02_Hopyo_Store.py @@ -4,9 +4,9 @@ 파일 = 읽은 결과만(원본 엑셀 안 둠) `{키, 파일, 올린때, 올린이, 시트, 호표, 검산}` · 키 `HP-######` (층마다 다음 번호) · 맞춤 기억 = `{줄: {줄 열쇠: {로직?|자재?|빼기?, 입력값, 환산, 확정}}}`. 층 종류(`layers.KINDS`) 밖 폴더 — 양식 목록 · 복사 · 프로젝트 씨앗에 안 섞임 · 권한은 길 몫. -한시 불러오기(718-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있는 것(작업 중)만 · 옛 HP 는 -파일 그대로 목록에서만 숨김 · 끝낸 기록 `실무자료/불러옴.json` -`{번, 지문 {지문: {파일, 키, 끝낸때, 만든}}}` · 번 = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀). +한시 불러오기(718-1 · 743-1) — 파일에 `지문`(올린 엑셀 sha256) · 목록 = 지문 있고 하루 안 지난 것 +(작업 중)만 · 옛 HP · 하루 지난 HP 는 목록에서 숨김(지움 = `M02_Hopyo_Forget`) · +`실무자료/불러옴.json` `{번}` = 낸 키 가장 큰 번(지운 뒤에도 키를 다시 안 씀 · 옛 `지문` 안 읽음). """ from __future__ import annotations @@ -15,6 +15,7 @@ import hashlib import json import re import threading +from datetime import datetime, timedelta, timezone from pathlib import Path from typing import Any @@ -27,6 +28,7 @@ MEMORY = "맞춤" GRID = "격자" DONE = "불러옴" NO_GRID = "격자 없음 — 다시 올리면 보임" +EXPIRE = timedelta(days=1) # 작업 중 HP 보관 — 올린 뒤 하루 _KEY = re.compile(r"^HP-(\d{6})$") # ponytail: 프로세스 안 잠금 — 서버를 여럿 띄우면 파일 잠금으로 _LOCK = threading.Lock() @@ -68,18 +70,27 @@ def fingerprint(data: bytes) -> str: return hashlib.sha256(data).hexdigest() +def stale(doc: dict[str, Any], now: datetime | None = None) -> bool: + """하루 지난 HP — 올린때 기준 · 못 읽는 때 = 지난 것.""" + try: + when = datetime.fromisoformat(str(doc.get("올린때") or "").replace("Z", "+00:00")) + except ValueError: + return True + return (now or datetime.now(timezone.utc)) - when > EXPIRE + + def rows(folder: str | Path) -> list[dict[str, Any]]: - """층 실무자료 목록(키 차례) — 작업 중(지문 있음)만 · 옛 HP 는 숨김.""" + """층 실무자료 목록(키 차례) — 작업 중(지문 있음 · 하루 안)만 · 옛 HP · 지난 HP 는 숨김.""" out = [] for path in sorted(_dir(folder).glob("HP-*.json")): doc = _load(path) - if isinstance(doc, dict) and _KEY.match(path.stem) and doc.get("지문"): + if isinstance(doc, dict) and _KEY.match(path.stem) and doc.get("지문") and not stale(doc): out.append({**brief(doc), "지문": doc["지문"]}) return out 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("지문") @@ -137,22 +148,12 @@ def grid(folder: str | Path, key: str) -> dict[str, Any]: return doc -def delete(folder: str | Path, key: str, made: list[str] | None = None) -> None: - """HP · 격자 지움 · 만든 것(`made` SC 키)이 있으면 지문을 끝낸 기록에 남김(다시 올림 막음).""" +def delete(folder: str | Path, key: str) -> None: + """HP · 격자 지움(끝낸 기록 없음 · 같은 엑셀 다시 올림 됨 · 743-1).""" path = _path(folder, key) with _LOCK: - doc = _load(path) - if not isinstance(doc, dict): + if not isinstance(_load(path), dict): raise store.StoreError(404, f"없는 실무자료 「{key}」") - if made and doc.get("지문"): - log = done(folder) - log["지문"][doc["지문"]] = { - "파일": doc.get("파일"), - "키": key, - "끝낸때": utc_now_text(), - "만든": made, - } - _put_done(folder, log) path.unlink() _grid_path(folder, key).unlink(missing_ok=True) diff --git a/M02_MasterTemplete/M02_Labor_Patch.py b/M02_MasterTemplete/M02_Labor_Patch.py index aa0b3db09..87cd6a61a 100644 --- a/M02_MasterTemplete/M02_Labor_Patch.py +++ b/M02_MasterTemplete/M02_Labor_Patch.py @@ -15,7 +15,8 @@ from typing import Any from M02_MasterTemplete import M02_Sangeun_Doc as sd FIELD = "패치" -KEEP = ("덮개", "뺀줄", "더한줄") +CALC = ("덮개", "뺀줄", "더한줄") # 셈에 드는 칸(`as_doc` · 화면 짝 꼴) +KEEP = (*CALC, "뺀더한줄") # 뺀더한줄 = [되살림] 기억(744-1) TEMP = "SK-000000" # 이름 없는 줄 단가산출 — 저장 안 함 @@ -41,7 +42,9 @@ def clean(one: dict, where: str, whole: Any, row: dict | None, opened: list | No ) except sd.DocError as e: raise _bad(f"{where} · {e}") from e - out = {k: got[k] for k in KEEP if got[k]} + out = {k: got[k] for k in KEEP if got.get(k)} + for add in out.get("더한줄") or []: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 + add.setdefault("처음수량", add["수량"]) return {FIELD: out} if out else {} @@ -71,7 +74,7 @@ def _keyed(value: Any, ids: list[str]) -> dict: def as_doc(one: dict, whole: Any, name: str = "줄", unit: str = "식") -> dict[str, Any]: """일위대가 줄 → SK 문서(바탕 = 그 로직 · 그 SK) — 고름 · 자재표시는 cid 로.""" - body = {k: (one.get(FIELD) or {}).get(k) or ([] if k != "덮개" else {}) for k in KEEP} + body = {k: (one.get(FIELD) or {}).get(k) or ([] if k != "덮개" else {}) for k in CALC} head = {"키": TEMP, "이름": name, "단위": unit, **body} if "참조" in one: return {**head, "바탕": {"참조": one["참조"]}} diff --git a/M02_MasterTemplete/M02_Labor_Ref.py b/M02_MasterTemplete/M02_Labor_Ref.py index 6a3e39c10..27d54f149 100644 --- a/M02_MasterTemplete/M02_Labor_Ref.py +++ b/M02_MasterTemplete/M02_Labor_Ref.py @@ -42,6 +42,7 @@ _OWNER = {"company": re.compile(r"^\d+$"), "personal": re.compile(r"^\d+/\d+$")} Ref = dict[str, Any] Here = tuple[str, str | None] +COPY = "사본" # 740-1 하위 호표 사본 블록 — 참조 꼴 {층: 사본, 주인: 몸 지문, 키: 본 SC, 몸} def _bad(text: str, status: int = 400) -> store.StoreError: @@ -103,7 +104,28 @@ def ref_path(ref: Ref) -> Path: return folder_of(ref["층"], ref.get("주인")) / kind_of(ref["키"]) / f"{ref['키']}.json" +def is_copy(ref: Any) -> bool: + """사본 블록(740-1) — 일위대가 안 일위대가 몸을 줄 안에 담음(원본 연결 없음 · 키 = 출처).""" + return isinstance(ref, dict) and ref.get("층") == COPY and isinstance(ref.get("몸"), dict) + + +def copy_ref(body: dict[str, Any], key: str) -> Ref: + """사본 블록 참조 — 몸(종류 · 이름 · 단위 · 담은로직 · 자재 · 본뜬) · 주인 = 몸 지문.""" + import hashlib + + keep = {k: body[k] for k in ("종류", "이름", "단위", "담은로직", "자재", "본뜬") if body.get(k)} + raw = json.dumps(keep, ensure_ascii=False, sort_keys=True, default=str) + return { + "층": COPY, + "주인": hashlib.sha256(raw.encode()).hexdigest()[:12], + "키": key, + "몸": keep, + } + + def read_ref(ref: Ref) -> dict[str, Any] | None: + if is_copy(ref): + return ref["몸"] try: got = json.loads(ref_path(ref).read_bytes()) except (OSError, ValueError): @@ -114,6 +136,8 @@ def read_ref(ref: Ref) -> dict[str, Any] | None: def readable(at: Here, ref: Ref) -> bool: """`at` 층이 `ref` 를 가리켜도 되나 — 위 층만(프로젝트는 아무것도 · 굳힌 사본만 씀).""" layer, owner = at + if ref.get("층") == COPY: # 사본 블록 = 줄 안 몸(어느 층도 읽음) + return True if layer == "project": return False if ref["층"] == "system": @@ -127,6 +151,8 @@ def check_ref(raw: Any, at: str, here_: Here) -> Ref: """참조 꼴 · 위 층만 · 있는 문서 — 아니면 400.""" if not isinstance(raw, dict): raise _bad(f"{at} · 참조는 {{층, 주인, 키}}") + if raw.get("층") == COPY: + return _check_copy(raw, at) layer, owner, key = raw.get("층"), raw.get("주인"), str(raw.get("키") or "") if layer == "system": owner = None @@ -142,6 +168,20 @@ def check_ref(raw: Any, at: str, here_: Here) -> Ref: return ref +def _check_copy(raw: Ref, at: str) -> Ref: + """사본 블록 검사 — 키 = SC · 몸 줄 · 자재 = 일위대가 검사 그대로 · 지문 다시 셈.""" + from M02_MasterTemplete import M02_Labor_Doc as labor + + body, key = raw.get("몸"), str(raw.get("키") or "") + if not isinstance(body, dict) or not _KEY.match(key) or kind_of(key) != "precombo": + raise _bad(f"{at} · 사본 블록은 {{층: 사본, 키: SC-…, 몸}}") + try: + labor.clean({"담은로직": body.get("담은로직") or [], "자재": body.get("자재") or []}) + except store.StoreError as e: + raise _bad(f"{at} · 사본 블록 · {e.detail}") from e + return copy_ref(body, key) + + # ── 서고 문서 정리 ───────────────────────────────────────────────────── def check_key(kind: str, name: str) -> None: found = _KEY.match(name) @@ -158,7 +198,7 @@ def clean_doc(kind: str, doc: Any) -> dict[str, Any]: if here()[0] != "project": # 740-1 — M02 참조 줄 = M01 키 줄로 펼침(못 펼친 줄은 그대로) from M02_MasterTemplete import M02_Library_Flat as flat - doc = flat.flat_doc(kind, doc) + doc = flat.flat_doc(kind, doc, me={"층": here()[0], "주인": here()[1], "키": key}) name, unit = str(doc.get("이름") or "").strip(), str(doc.get("단위") or "").strip() if kind == "sangeun": from M02_MasterTemplete import M02_Sangeun_Calc as calc diff --git a/M02_MasterTemplete/M02_Labor_Router.py b/M02_MasterTemplete/M02_Labor_Router.py index dc113d411..8705b2a01 100644 --- a/M02_MasterTemplete/M02_Labor_Router.py +++ b/M02_MasterTemplete/M02_Labor_Router.py @@ -8,8 +8,8 @@ 일위대가 실무자료(324 · `M02_Hopyo_*` · 올리기 · 지우기 = 층 쓰기 · 목록 · 읽기 = 층 읽기) · 338 = 확인한 줄만 만들기(몸 없음 400 · 옛 즉시 확정 길 없앰) · 별칭 장부 보기 · 고치기 · 올린 뒤 맞춤 뒤 셈(`M02_Hopyo_Fit.ensure`) · 시동 때 우리 지문 데움(`M02_Hopyo_Ours.warm`) · -718-1 한시 불러오기 = 올림 지문(끝낸 같은 엑셀 409 · 작업 중 같은 엑셀 = 그 파일 `이어서`) · -지우기 = [끝내기](HP · 격자 · 맞춤셈 캐시 지움 · 만든 일위대가가 있으면 지문 기록 · 별칭 장부 남음). +718-1 한시 불러오기 = 올림 지문(작업 중 같은 엑셀 = 그 파일 `이어서` · 끝낸 것 = 새로 · 743-1) · +지우기 = [끝내기](`M02_Hopyo_Forget.finish` · 올림 때 하루 지난 HP 도 끝냄). 층 권한 = `Router_Items._root`(`M02_Layer_Access` 한 벌). ⚠ 등록은 `main.py`(로그인만). """ @@ -27,6 +27,7 @@ from pydantic import BaseModel, ConfigDict, Field from common_util.common_util_auth import verify_session from M02_MasterTemplete import M02_Hopyo_Build as hopyo_build from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel +from M02_MasterTemplete import M02_Hopyo_Forget as hopyo_forget from M02_MasterTemplete import M02_Hopyo_Grid as hopyo_grid from M02_MasterTemplete import M02_Hopyo_Item as hopyo_item from M02_MasterTemplete import M02_Hopyo_Ledger as hopyo_ledger @@ -229,14 +230,7 @@ def _who(session: Session) -> dict[str, Any]: def _upload(name: str, data: bytes, who: dict[str, Any]) -> dict[str, Any]: mark = hopyo_store.fingerprint(data) - if old := hopyo_store.done(store.root())["지문"].get(mark): - made = len(old.get("만든") or []) - when = str(old.get("끝낸때") or "")[:10] - raise store.StoreError( - 409, - f"이미 불러온 엑셀 「{old.get('파일')}」({when} · 만든 일위대가 · 단가산출 {made})" - " — 다시 만들지 않음", - ) + hopyo_forget.sweep(store.root()) # 하루 지난 작업 중 HP 끝냄(743-1) if same := next((r for r in hopyo_store.rows(store.root()) if r.get("지문") == mark), None): return {**same, "이어서": True} try: @@ -502,29 +496,10 @@ def hopyo_ledger_write( def hopyo_delete( layer: Layer, key: str, owner: str | None = None, session: Session = Depends(verify_session) ) -> dict: - """실무자료 지우기 = 불러오기 [끝내기](718-1) — HP · 격자 · 맞춤셈 캐시 지움 · 만든 일위대가 - (이 층 확인된 본뜬 「키 제N호표」)는 그대로 · 있으면 지문 기록(같은 엑셀 다시 올림 막음) · - 별칭 장부 그대로 → `{지움, 만든}`.""" + """실무자료 지우기 = [끝내기](718-1 · 743-1 · 화면 떠남도) — HP · 격자 · 맞춤셈 캐시 지움 · + 만든 일위대가 · 단가산출은 엑셀 사본만 걷고 남음 · 별칭 장부 그대로 → `{지움, 만든}`.""" folder = _root(session, layer, owner, write=True) - return _call(folder, _finish, folder, key) - - -def _finish(folder: Path, key: str) -> dict[str, Any]: - head = f"{key} 제" - made = sorted( - {sc for mark, sc in hopyo_build.confirmed(folder).items() if mark.startswith(head)} - ) - made += sorted(hopyo_sangeun.made(folder, key).values()) # 단가산출(SK) - if (cache_path := _later("M02_Hopyo_Fit", "cache_path")) is not None: - try: - got = cache_path(folder, key) - except (OSError, store.StoreError): - got = None - # ponytail: 뒤 셈이 도는 중이면 끝낸 뒤 캐시를 다시 쓸 수 있음 — tmp 캐시라 둠 - for old in got.parent.glob(f"{'_'.join(got.name.split('_')[:2])}_*.json") if got else []: - old.unlink(missing_ok=True) - hopyo_store.delete(folder, key, made) - return {"지움": key, "만든": len(made)} + return _call(folder, hopyo_forget.finish, folder, key) class SangeunBody(_Strict): diff --git a/M02_MasterTemplete/M02_Library_Flat.py b/M02_MasterTemplete/M02_Library_Flat.py index f8afd86a2..69ccc2b45 100644 --- a/M02_MasterTemplete/M02_Library_Flat.py +++ b/M02_MasterTemplete/M02_Library_Flat.py @@ -10,15 +10,17 @@ 수량 = 넣은 수 × 줄 수량(저장 `수량.손` › 실무수량 › 1 · 742-1) ÷ 배(물량 알약 배) SC 에 SK 로직 줄 하나 + 패치(= SK 몸) · 별칭 = SK 이름 · 같은 자리(안 줄 알약 키 그대로) · 바탕 없는 SK · 단위 환산 SK = 못 넣음(값 단위가 달라짐) - SC 에 SC 찾아 넣기 길만 — 그 자리에 안 줄 · 자재를 펴 넣음 · 줄 수량 · 본뜬 실무수량 = - 바깥 × 안 · 같은 기초 · 고정 · 자재가 겹치면 못 넣음(일위대가 줄 짝 = 로직 키) · - 저장 · 읽기 · 옮기기는 하위 호표 참조 그대로(엑셀 하위 호표 끝수 · B09 하위 대가) + SC 에 SC 사본 블록 — 안쪽 SC 몸 통째(M01 키 줄 + 덮개 · 실무수량)를 그 줄 참조 꼴 + `{층: 사본, 주인: 몸 지문, 키: 본 SC, 몸}` 에 담음(`M02_Labor_Ref.copy_ref` · 원본 + 연결 없음 · 하위 호표 끝수 단계 · B09 하위 대가 블록 그대로 · 같은 기초 겹침도 + 블록 안) 바탕 SK 참조 · 패치 있는 SK 참조 줄 = 위 덮개를 아래 덮개에 겹쳐 한 벌(`compose`) 못 펼친 줄 = 저장 · 읽기 · 옮기기에선 옛 참조 그대로(값 그대로) · 넣기 길(`strict`)에선 400 까닭. -초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸까지) · 항목 · 수량 · 입력값 · 고름 · -자재표시 · 켜쌓기율 · 고정 줄 · 기본정보 남김 → 값 = 연결된 M01 키 값. +초기화(`reset`) = 덮개 · 뺀줄 · 더한줄 단가 걷음(안쪽 넣은 몸 · 사본 블록까지) · 이음 기계 고정 줄 +단가 = M01 기계 한 시간 값 다시 받음(736-3) · 항목 · 수량 · 입력값 · 고름 · 자재표시 · 켜쌓기율 · +기본정보 남김 → 값 = 연결된 M01 키 값. 옮기기(`migrate`) = 층 문서 펼쳐 다시 씀 — 전후 1 단위 금액 같을 때만(안 줄 수량 모두 1 로 대조) · -쓰는 구조물 조합이 있는 SC 펼쳐 넣기(차례 바뀜)는 안 옮김 · 공유 storage 는 브레인이 돌림. +공유 storage 는 브레인이 돌림. """ from __future__ import annotations @@ -193,6 +195,9 @@ def sc_adds(z: dict, q: Decimal, whole: Any, tag: dict) -> list[dict]: "이름": one["고정"].get("이름") or "", "수량": sd.plain(n), } + elif refs.is_copy(one.get("참조")): # 하위 호표 사본 블록 = 그 줄들도 더한줄로 + out += sc_adds(one["참조"]["몸"], n, whole, tag) + continue else: raise sd.DocError("비율 고정 줄 · 참조 줄은 단가산출에 못 담음") out.append({**entry, "본뜬": tag}) @@ -346,19 +351,13 @@ def _twice(doc: dict) -> str | None: def flat_sc(doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool = True) -> dict: - """SC 문서 → M01 키만 — SK 참조 = 로직 줄 · SC 참조 = 안 줄 펴 넣음(`strict` 만 · 넣기 길) · - `strict` False(저장 · 읽기 · 옮기기) = SC 참조 그대로(하위 호표 · 엑셀 끝수 단계) · 못 펼친 - 줄 그대로.""" - hands = (doc.get("본뜬") or {}).get("실무수량") - old_q = dict((hands or {}).get("줄") or {}) - new_q, mat_q = {}, dict((hands or {}).get("자재") or {}) - lines, mats = [], list(doc.get("자재") or []) + """SC 문서 → M01 키만 — SK 참조 = 로직 줄 + 패치(같은 자리) · SC 참조 = 사본 블록(같은 자리) · + `strict` False = 못 펼친 줄 그대로(겹침 · 바탕 없음 · 환산 · 없는 참조).""" + lines = [] for at, one in enumerate(doc.get("담은로직") or []): ref = one.get("참조") if isinstance(one, dict) else None kind = refs.kind_of(ref.get("키")) if isinstance(ref, dict) else None - here_q = old_q.get(str(at)) - if kind != "sangeun" and not (strict and kind == "precombo"): # 하위 호표 = 참조 그대로 - new_q |= {str(len(lines)): here_q} if here_q is not None else {} + if kind not in ("sangeun", "precombo") or refs.is_copy(ref): lines.append(one) continue try: @@ -366,80 +365,39 @@ def flat_sc(doc: dict, read: Read, whole: Any, trail: tuple = (), strict: bool = tag = mark(ref, src) if kind == "sangeun": y = flat_sk(sd.clean(src, None, whole), read, whole, path) - put, put_m = [sk_line(y, one, whole, tag)], [] - put_q = {"0": here_q} if here_q is not None else {} + put = sk_line(y, one, whole, tag) else: - z = flat_sc(src, read, whole, path) - put, put_q, put_m = _spread(z, one, here_q, tag) + body = flat_sc(src, read, whole, path) + put = {**one, "참조": refs.copy_ref(body, ref["키"]), "본뜬": tag} rest = (doc.get("담은로직") or [])[at + 1 :] - trial = {"담은로직": [*lines, *put, *rest], "자재": [*mats, *put_m]} + trial = {"담은로직": [*lines, put, *rest], "자재": doc.get("자재") or []} if twice := _twice(trial): raise sd.DocError(f"같은 줄이 겹침 「{twice}」 — 펼쳐 넣지 못함") except FAIL as e: if strict: raise sd.DocError(f"「{ref.get('키')}」 · {e}") from e - new_q |= {str(len(lines)): here_q} if here_q is not None else {} - lines.append(one) - continue - new_q |= {str(len(lines) + int(n)): v for n, v in put_q.items()} - mat_q |= {m["코드"]: m.pop("_q") for m in put_m if "_q" in m} - lines, mats = [*lines, *put], [*mats, *put_m] - out = {**doc, "담은로직": lines, "자재": mats} - if hands is not None: - out["본뜬"] = {**doc["본뜬"], "실무수량": {**hands, "줄": new_q, "자재": mat_q}} - return out - - -def _spread(z: dict, one: dict, here_q: Any, tag: dict) -> tuple[list, dict, list]: - """안 SC 줄 · 자재 펴기 — 실무수량 = 바깥 × 안(둘 다 있을 때만) · 비율 고정 줄 있으면 못 폄 - (밑 = 그 SC 합 → 바깥 합으로 바뀜).""" - if any(refs.is_rate(x) for x in z.get("담은로직") or []): - raise sd.DocError("비율 고정 줄이 있는 일위대가는 펴 넣지 못함(밑 합이 바뀜)") - hands = (z.get("본뜬") or {}).get("실무수량") or {} - inner, inner_m = hands.get("줄") or {}, hands.get("자재") or {} - outer = (one.get("수량") or {}).get("손") if isinstance(one.get("수량"), dict) else None - - def times( - x: dict, - ) -> Any: # 줄 수량(742-1) = 바깥 × 안 · 둘 중 하나라도 없으면 쓰는 쪽 몫(null) - inner = (x.get("수량") or {}).get("손") if isinstance(x.get("수량"), dict) else None - both = outer not in EMPTY and inner not in EMPTY - return {"손": sd.plain(_d(outer) * _d(inner))} if both else None - - lines = [{**x, "수량": times(x), "본뜬": tag} for x in z.get("담은로직") or []] - if len(lines) == 1 and one.get("별칭"): - lines[0]["별칭"] = one["별칭"] - both = here_q is not None - qty = { - str(n): sd.plain(_d(here_q) * _d(inner[str(n)])) - for n in range(len(lines)) - if both and inner.get(str(n)) is not None - } - mats = [] - for m in z.get("자재") or []: - extra = ( - {"_q": sd.plain(_d(here_q) * _d(inner_m[m["코드"]]))} - if both and m.get("코드") in inner_m - else {} - ) - mats.append({**m, "본뜬": tag, **extra}) - return lines, qty, mats + put = one + lines.append(put) + return {**doc, "담은로직": lines} # ── 문 ──────────────────────────────────────────────────────────────── -def flat_doc(kind: str, doc: Any, read: Read = refs.read_ref, strict: bool = False) -> Any: - """층 문서 하나 펼침(저장 · 읽기 · 복사 · 옮기기) — 참조 없으면 받은 그대로.""" +def flat_doc( + kind: str, doc: Any, read: Read = refs.read_ref, strict: bool = False, me: Any = None +) -> Any: + """층 문서 하나 펼침(저장 · 읽기 · 복사 · 옮기기) — 참조 없으면 받은 그대로 · `me` = 이 문서 + 참조(자기 자신을 담은 줄 = 안 펼침 → 저장 검사가 422).""" if not isinstance(doc, dict) or kind not in refs.PREFIX or not refs.refs_in(doc): return doc - whole = _whole() + whole, trail = _whole(), (refs.ref_id(me),) if isinstance(me, dict) else () if kind == "sangeun": - return flat_sk(doc, read, whole, (), strict) - return flat_sc(doc, read, whole, (), strict) + return flat_sk(doc, read, whole, trail, strict) + return flat_sc(doc, read, whole, trail, strict) def flat_lines(kind: str, ref: Any, qty: Any = 1, doc: Any = None) -> dict[str, Any]: """찾아 넣기(`-flat` 길) — `kind` 문서에 `ref` 를 넣을 줄 · 못 펼침 = StoreError 400 · - SC = 지금 화면 문서 `doc` 과 겹치면 400.""" + SC = 로직 줄(SK) · 사본 블록 줄(SC) 하나 · 지금 화면 문서 `doc` 과 겹치면 400.""" from M02_MasterTemplete import M02_MasterTemplete_Store as store at = refs.here() @@ -450,15 +408,27 @@ def flat_lines(kind: str, ref: Any, qty: Any = 1, doc: Any = None) -> dict[str, return {"더한줄": into_sk(ref, qty if qty not in EMPTY else 1, refs.read_ref, whole)} got = flat_sc({"담은로직": [{"참조": ref, "수량": None}]}, refs.read_ref, whole) host = doc if isinstance(doc, dict) else {} - trial = {k: [*(host.get(k) or []), *got[k]] for k in ("담은로직", "자재")} - if twice := _twice(trial): + trial = {"담은로직": [*(host.get("담은로직") or []), *got["담은로직"]]} + if twice := _twice({**trial, "자재": host.get("자재") or []}): raise sd.DocError(f"이미 담은 줄과 겹침 「{twice}」") - return {"담은로직": got["담은로직"], "자재": got["자재"]} + return {"담은로직": got["담은로직"], "자재": []} except FAIL as e: raise store.StoreError(getattr(e, "status", 400), str(e)) from e # ── 초기화 ──────────────────────────────────────────────────────────── +def _reprice(fx: dict) -> tuple[dict, int]: + """이음 기계 고정 줄(736-3) 단가 = M01 기계 한 시간 값 다시 받음 — (줄, 바뀐 수).""" + from M02_MasterTemplete import M02_Machine_Hourly as machine + + key = (fx.get("이음") or {}).get("기계") + got = machine.hourly(str(key)) if key else {} + if not got.get("ok"): + return fx, 0 + price = {k: got[k] for k in sd.PARTS.values()} + return {**fx, "단가": price}, int(price != fx.get("단가")) + + def _reset_adds(adds: list) -> tuple[list, int]: out, n = [], 0 for one in adds or []: @@ -474,31 +444,50 @@ def _reset_adds(adds: list) -> tuple[list, int]: if one.get("더한줄"): one["더한줄"], k = _reset_adds(one["더한줄"]) n += k + if isinstance(one.get("고정"), dict): + one["고정"], k = _reprice(one["고정"]) + n += k out.append(one) return out, n -def reset(kind: str, doc: dict) -> tuple[dict, int]: - """[초기화] — (걷은 문서, 걷힌 고침 수) · 먼저 펼침(옛 참조 줄도 M01 키로).""" +def _reset_sc(doc: dict) -> tuple[dict, int]: + """일위대가 초기화 — 줄 패치 · 사본 블록 몸 · 이음 기계 고정 줄.""" from M02_MasterTemplete import M02_Labor_Patch as patch + lines, n = [], 0 + for one in doc.get("담은로직") or []: + if not isinstance(one, dict): + lines.append(one) + continue + ref, body = one.get("참조"), one.get(patch.FIELD) + if refs.is_copy(ref): + inner, k = _reset_sc(ref["몸"]) + n += k + one = {**one, "참조": refs.copy_ref(inner, ref["키"])} + elif isinstance(one.get("고정"), dict): + fx, k = _reprice(one["고정"]) + n += k + one = {**one, "고정": fx} + elif body: + adds, k = _reset_adds(body.get("더한줄") or []) + n += k + len(body.get("덮개") or {}) + len(body.get("뺀줄") or []) + keep = {x: v for x, v in body.items() if x not in ("덮개", "뺀줄", "더한줄")} + rest = {**keep, **({"더한줄": adds} if adds else {})} + one = {x: v for x, v in one.items() if x != patch.FIELD} + one = {**one, **({patch.FIELD: rest} if rest else {})} + lines.append(one) + return {**doc, "담은로직": lines}, n + + +def reset(kind: str, doc: dict) -> tuple[dict, int]: + """[초기화] — (걷은 문서, 걷힌 고침 수) · 먼저 펼침(옛 참조 줄도 M01 키로).""" doc = flat_doc(kind, doc) if kind == "sangeun": adds, n = _reset_adds(doc.get("더한줄") or []) n += len(doc.get("덮개") or {}) + len(doc.get("뺀줄") or []) return {**doc, "덮개": {}, "뺀줄": [], "더한줄": adds}, n - lines, n = [], 0 - for one in doc.get("담은로직") or []: - body = one.get(patch.FIELD) if isinstance(one, dict) else None - if not body: - lines.append(one) - continue - adds, k = _reset_adds(body.get("더한줄") or []) - n += k + len(body.get("덮개") or {}) + len(body.get("뺀줄") or []) - rest = {**({"더한줄": adds} if adds else {})} - line = {x: v for x, v in one.items() if x != patch.FIELD} - lines.append({**line, **({patch.FIELD: rest} if rest else {})}) - return {**doc, "담은로직": lines}, n + return _reset_sc(doc) def reset_doc(kind: str, key: str | None, doc: Any, look: bool, version: str | None) -> dict: @@ -550,7 +539,9 @@ def migrate(apply: bool = False) -> list[dict[str, Any]]: ref = {"층": layer, "주인": owner, "키": path.stem} got = flat_doc(kind, doc) left = [ - r.get("키") for r in refs.refs_in(got) if refs.kind_of(r.get("키")) != "promote" + r.get("키") + for r in refs.refs_in(got) + if refs.kind_of(r.get("키")) != "promote" and not refs.is_copy(r) ] row = { "어디": where_, @@ -565,10 +556,7 @@ def migrate(apply: bool = False) -> list[dict[str, Any]]: row["전"], row["후"] = _value(ref, refs.read_ref, whole), _value(ref, mine, whole) row["같음"] = row["전"] == row["후"] - used = kind == "precombo" and len(got["담은로직"]) != len(doc.get("담은로직") or []) - if used and refs.users(ref): - row["까닭"] = "쓰는 곳 있는 일위대가 — 안 줄 차례가 바뀌어 안 옮김" - elif not row["같음"]: + if not row["같음"]: row["까닭"] = "전후 금액 다름 — 안 옮김" elif apply and got != doc: with store.at(path.parent.parent): diff --git a/M02_MasterTemplete/M02_Library_Same.py b/M02_MasterTemplete/M02_Library_Same.py index 744ea5814..42f4f795c 100644 --- a/M02_MasterTemplete/M02_Library_Same.py +++ b/M02_MasterTemplete/M02_Library_Same.py @@ -24,7 +24,7 @@ from common_util.common_util_derived_store import derived_key from M02_MasterTemplete import M02_Labor_Ref as refs DROP = {"키", "이름", "구분", "상세구분", "본뜬", "메모", "별칭", "바탕판", "원값", "계산값", "열"} -DROP |= {"일위대가번", "종류", "수정일", "출처"} +DROP |= {"일위대가번", "종류", "수정일", "출처", "처음수량", "뺀더한줄"} # 744-1 되돌림 기억 UNIT = {"m3": "㎥", "m2": "㎡", "m³": "㎥", "m²": "㎡"} EMPTY = (None, "", [], {}) diff --git a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts index 9d1194a9b..9a21c40fe 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts @@ -216,6 +216,17 @@ export const checkLibraryDelete = ( method: "POST", body: JSON.stringify({ 대상: picks }), }); +/** [초기화](740-2) — 미리 보기(`미리보기` true) = 걷힐 고침 수 · 아니면 그 층 문서에 씀(`판` 이 다르면 409) */ +export const resetLibrary = ( + kind: LibraryKind, + layer: Layer, + owner: string | null, + body: { 키: string; 미리보기: boolean; 판?: string }, +): Promise<{ 걷힘: number; 문서: unknown }> => + call(owned(layer, `/layers/${layer}/${kind}-reset`, owner), { + method: "POST", + body: JSON.stringify(body), + }); /** 복사해 둔 문서 · 폴더 → 이 층 `dest` 아래 새 키(폴더는 안의 것까지 · 같은 폴더 이름 「(1)」) */ export const pasteLibraryTree = ( kind: LibraryKind, diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Api.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Api.ts index eb3b487db..187f3c533 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Api.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Api.ts @@ -110,6 +110,8 @@ export interface HopyoTarget { /** 묶음 표시(358-1 · 로직 후보만) — 품명 뜻 낱말 겹침 · 엑셀 출처 조항 같음(≥ 0.9) · 책(산림품셈 · 건설품셈) */ 뜻겹침?: boolean; 출처같음?: boolean; + /** 745-1 미리 고름 점 — 「다른 점」 1위 + 출처 같음(서버) · 자동 확정 아님 · 만들기는 사용자가 누름 */ + 미리?: boolean; 책?: string; } @@ -469,8 +471,9 @@ export const saveLedger = async ( }) ).줄; -export const deleteHopyo = (scope: HopyoScope, key: string): Promise => - call(at(scope, `/hopyo/${enc(key)}`), { method: "DELETE" }); +/** [끝내기] · 화면 떠남(743-1) — `keepalive` = 페이지를 닫아도 요청은 감 */ +export const deleteHopyo = (scope: HopyoScope, key: string, keepalive = false): Promise => + call(at(scope, `/hopyo/${enc(key)}`), { method: "DELETE", keepalive }); /** [확인하고 사전조합 만들기] — 확인한 줄만 · 직접 줄 호표 = `통째` → `target` 층 사전조합(파일 층 = `from`) */ export const buildHopyo = ( diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Choose.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Choose.ts index 0b299e0c1..a9db164a4 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Choose.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Choose.ts @@ -10,6 +10,7 @@ * 저장 안 함 — 고른 것은 부르는 쪽 캐시(확인 창)로만 감. * ========================================================================== */ +import { createBadge } from "@ui/ui_template_badge"; import { createButton, el } from "@ui/ui_template_elements"; import { openModal } from "@ui/ui_template_modal"; import type { @@ -30,6 +31,7 @@ const FOLD_TEXT: Record = { "지역 변형": "하나 고르면 그 지역 · 「전국」으로 되돌림은 위", 숫자: "이름 · 출처 안 닮음 · 숫자 지문만", }; +const PRE_TIP = "미리 고름 — 엑셀 인용 조항 = 1위 기초 조항 · 누르기는 사용자"; const note = (text: string): HTMLElement => el("span", { className: "ui-text ui-text--muted", text, attrs: { "data-text": "14" } }); const num = (v: number): string => String(Math.round(v * 10000) / 10000); @@ -270,8 +272,12 @@ export function openHopyoChoose(opt: ChooseOptions): void { const tag = basisTag(c.근거); return el("div", { className: `m02-hopyo__cand${weakCand(c) ? " is-weak" : ""}`, - attrs: { "data-cand": c.로직 ?? c.자재 ?? (c.전국 ? "전국" : "") }, + attrs: { + "data-cand": c.로직 ?? c.자재 ?? (c.전국 ? "전국" : ""), + ...(c.미리 ? { "data-pre": "" } : {}), + }, children: [ + ...(c.미리 ? [createBadge(PRE_TIP, "accent", { kind: "dot" })] : []), box, createButton({ label: candText(c, twins), @@ -287,6 +293,7 @@ export function openHopyoChoose(opt: ChooseOptions): void { }), ] : []), + ...(c.미리 ? [note("미리 고름")] : []), ...(c.글 ? [note(c.글)] : []), ...(weakCand(c) ? [note("이름 뜻 안 겹침")] : []), ...(tag && c.근거 diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts index cd670718c..fe4456135 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Side.ts @@ -1,7 +1,7 @@ /* ============================================================================= * M02_MasterTemplete_Hopyo_Side.ts * 좌측 「일위대가 불러오기」 컨테이너(PLAN 324-4 · 718-1 한시) — [불러오기](구조물 조합 층 단추 꼴 `m02-layers__btn`) → - * 본 칸 마법사(`M02_MasterTemplete_Hopyo_Wizard` · 결과 층 고름 · 작업 중 이어서 · [끝내기] 때 올린 파일 지움) · + * 본 칸 마법사(`M02_MasterTemplete_Hopyo_Wizard` · 결과 층 고름 · 작업 중 이어서 · [끝내기] · 화면 떠남 때 올린 파일 지움) · * 옛 파일 목록 없음(옛 HP 는 서버 목록에서 숨김) · * 아래 [별칭 장부](338-3) → 본 칸 장부 화면(`M02_MasterTemplete_Hopyo_Ledger` · 층 = 구조물 조합 층). * ========================================================================== */ @@ -40,7 +40,8 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection { onClick: () => void showView(WIZARD), }); start.classList.add("m02-layers__btn"); - start.title = "다른 프로그램 일위대가 엑셀 → 우리 일위대가(한시 · 끝내면 올린 파일 지움)"; + start.title = + "다른 프로그램 일위대가 엑셀 → 우리 일위대가(한시 · 끝내거나 떠나면 올린 파일 지움)"; start.dataset.hopyoWizardOpen = ""; const ledger = el("button", { className: "m02-side__item ui-sidebar-row", @@ -52,7 +53,7 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection { className: "m02-hopyo-side", children: [el("div", { className: "m02-side__row", children: [start] }), ledger], }); - let open: { key: string; view: HTMLElement } | null = null; + let open: { key: string; view: HTMLElement; leave?: () => void } | null = null; const paintList = (): void => { ledger.classList.toggle("is-active", open?.key === LEDGER_TITLE); @@ -61,18 +62,18 @@ export function buildHopyoSection(opt: HopyoSectionOptions): HopyoSection { async function showView(key: string): Promise { if (open?.key === key && open.view.isConnected) return; if (!(await opt.confirmLeave())) return; - const view = - key === WIZARD - ? buildHopyoWizard() - : buildHopyoLedger({ scope: pageScope(), canWrite: opt.canWrite() }); + open?.leave?.(); // 마법사 떠남 = 올린 파일 지움(743-1) + const wiz = key === WIZARD ? buildHopyoWizard() : null; + const view = wiz?.root ?? buildHopyoLedger({ scope: pageScope(), canWrite: opt.canWrite() }); opt.show(key === WIZARD ? title : `${title} — ${LEDGER_TITLE}`, view); opt.onOpen(); - open = { key, view }; + open = { key, view, ...(wiz ? { leave: wiz.leave } : {}) }; paintList(); } const paint = (): void => { if (open && !open.view.isConnected) { + open.leave?.(); // 다른 화면으로 = 마법사 떠남 open = null; paintList(); } diff --git a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Wizard.ts b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Wizard.ts index d93bc1087..019a69dac 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Wizard.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Hopyo_Wizard.ts @@ -2,14 +2,15 @@ * M02_MasterTemplete_Hopyo_Wizard.ts * 일위대가 불러오기 = 한시 마법사(PLAN 718-1 · 요구서 내역12 4장 22) — 본 칸 한 화면 · 걸음 셋: * ① 결과 층(쓸 수 있는 층만 · 기본 개인) · 결과(일위대가 늘 · 단가산출 체크) · 엑셀 고르기 → 올림 - * (그 층에 둠 · 같은 엑셀 작업 중 = 그 파일 이어서 · 끝낸 같은 엑셀 = 서버 409 안내) · 작업 중 파일 이어서 + * (그 층에 둠 · 같은 엑셀 작업 중 = 그 파일 이어서 · 끝낸 같은 엑셀 = 새로 올림) · 작업 중 파일 이어서 * ② 보기 · 확인 · 만들기 = 엑셀 보기 창(`Hopyo_Sheet` — [모두 고정으로 들여오기] · 호표 [수정] → * 확인 창 만들기 · [구조물 조합으로] 그대로) · 만들 층 = 고른 층 · * 단가산출 체크면 단가산출 칸(`Hopyo_WizardSk` — 기초 · SK · 고름 대기 기초 고름 · 729-3) · * 안 이은 줄 띠(`Hopyo_Left` — 안 만든 호표의 남은 줄 · [고르기] = 줄마다 이을 것 · 729-3) * ③ [끝내기] = 남은 줄 다시 셈 → 있으면 막음(띠 · 남은 수 · 표) · 없으면 물음 → 서버가 이번 HP · 격자 · 맞춤셈 캐시 지움 · - * 만든 일위대가 · 단가산출 · 별칭 장부 남음 · 지문 기록 - * 작업 중 = 서버에 보관(떠났다 와도 ① 목록에서 이어서) · 옛 HP(지문 없음)는 서버 목록에서 숨김. + * 만든 일위대가 · 단가산출(엑셀 사본 걷고 출처만) · 별칭 장부 남음 + * 작업 중 = 이 화면 동안만(743-1) — 화면 떠남(`leave` · 페이지 닫음) = 이 화면에서 올리거나 이은 파일 지움 · + * 하루 지난 것은 서버가 지움 · 엑셀 자료는 보관하지 않음(필요하면 다시 올림). * ========================================================================== */ import { createButton, el, showConfirmDialog, showToast } from "@ui/ui_template_elements"; @@ -61,7 +62,13 @@ export async function writableLayers(): Promise { return LAYERS.map((x) => x.layer).filter((layer) => accessFor(layer, null, user).canWrite); } -export function buildHopyoWizard(): HTMLElement { +export interface HopyoWizard { + root: HTMLElement; + /** 화면 떠남 — 이 화면에서 올리거나 이은 파일 지움(743-1) */ + leave: () => void; +} + +export function buildHopyoWizard(): HopyoWizard { const steps = createSegment({ options: STEPS.map((s) => ({ ...s, disabled: true })), value: "1", @@ -73,7 +80,7 @@ export function buildHopyoWizard(): HTMLElement { attrs: { "data-hopyo-wizard": "" }, children: [ createText( - "한시 — 다른 프로그램 일위대가 엑셀을 우리 일위대가로 옮김 · 끝내면 올린 파일 지움 · 별칭 장부는 남음", + "한시 — 다른 프로그램 일위대가 엑셀을 우리 일위대가로 옮김 · 끝내거나 화면을 떠나면 올린 파일 지움 · 별칭 장부는 남음", "hint", ), el("div", { className: "ui-toolbar", children: [steps.root] }), @@ -84,6 +91,16 @@ export function buildHopyoWizard(): HTMLElement { let pick: ManageLayer = "personal"; let wantSangeun = false; // 결과 「단가산출」 체크 const scopeOf = (layer: ManageLayer): HopyoScope => ({ layer, owner: null }); + const held = new Map(); // 이 화면이 쥔 파일 「층|키」 → 층 + const hold = (layer: ManageLayer, key: string): void => + void held.set(`${layer}|${key}`, scopeOf(layer)); + const drop = (layer: ManageLayer, key: string): void => void held.delete(`${layer}|${key}`); + const leave = (): void => { + window.removeEventListener("pagehide", leave); + for (const [id, scope] of held) void deleteHopyo(scope, id.split("|")[1], true).catch(() => {}); + held.clear(); + }; + window.addEventListener("pagehide", leave); async function first(): Promise { steps.set("1"); @@ -166,6 +183,7 @@ export function buildHopyoWizard(): HTMLElement { function second(layer: ManageLayer, file: HopyoFile): void { steps.set("2"); + hold(layer, file.키); const scope = scopeOf(layer); const view = createButton({ label: "엑셀 보기 · 확인 · 만들기", @@ -179,7 +197,10 @@ export function buildHopyoWizard(): HTMLElement { 파일: file.파일, target: scope, canWrite: true, - onDeleted: () => void first(), + onDeleted: () => { + drop(layer, file.키); + void first(); + }, }), ) .catch((error: unknown) => showToast(why(error), "error")), @@ -265,13 +286,14 @@ export function buildHopyoWizard(): HTMLElement { (x) => !x.one.호표.만든?.확인 && hasDraft(draftKey(scope, file.키, x.one.호표.번)), ).length; const ok = await showConfirmDialog( - `「${file.파일}」 불러오기를 끝냄 — 올린 파일(엑셀 결과 · 격자 · 맞춤 캐시)을 지움 · 만든 일위대가 · 단가산출과 별칭 장부는 남음 · 하나라도 만들었으면 같은 엑셀은 다시 올리지 못함` + + `「${file.파일}」 불러오기를 끝냄 — 올린 파일(엑셀 결과 · 격자 · 맞춤 캐시)을 지움 · 만든 일위대가 · 단가산출(출처만 남김)과 별칭 장부는 남음 · 같은 엑셀은 필요하면 다시 올림` + (loose ? ` · ${L("M02_LeftLoose").replace("{n}", String(loose))}` : ""), "끝내기", ); if (!ok) return steps.set("2"); try { const got = (await deleteHopyo(scope, file.키)) as { 만든?: number }; + drop(layer, file.키); showToast(`끝냄 — 만든 일위대가 · 단가산출 ${got.만든 ?? 0} · 올린 파일 지움`, "success"); } catch (error) { showToast(why(error), "error"); @@ -282,5 +304,5 @@ export function buildHopyoWizard(): HTMLElement { } void first(); - return root; + return { root, leave }; } diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor.css b/M02_MasterTemplete/M02_MasterTemplete_Labor.css index 4dd499c3d..08eafe004 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor.css +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor.css @@ -35,6 +35,13 @@ white-space: nowrap; } +/* 740-2 넣어 펼친 줄 출처 꼬리표 — 이름 글 끝에 이어 붙음(줄 높이 그대로 · 넘치면 말줄임) */ +.m02-labrow__born { + color: var(--color-text-secondary); + font-size: var(--text-caption); + font-weight: var(--font-weight-regular, 400); +} + .m02-labrow__key, .m02-labrow__note { color: var(--color-text-secondary); diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts index 6a2519765..02350b538 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts @@ -111,6 +111,8 @@ export interface LaborRow { 고정?: LaborFixed; /** 그 줄 덮개(715-3 · 717-3 단가산출 모달) — 로직 줄 · SK 참조 줄 · 서버가 검사 */ 패치?: LinePatch; + /** 넣어 펼친 줄 출처(740-1 · 740-2 꼬리표) — {층, 주인, 키, 이름, 때} · 셈에 안 씀 */ + 본뜬?: Record; } /** 자재 세 칸(148-4 · 서버 `M02_Labor_Doc.MARKS` 와 같음) — 빈 칸 = 읽을 때 기본값 · 금액 무관 */ export const MAT_MARKS = { @@ -127,6 +129,9 @@ export type NationalMat = MatMarks & { 단위: string; 수량: { 손: number }; }; +/** 본뜬 곳 글 — 「층 키」 · 끝낸 실무자료 = 「실무자료 파일」 · 없으면 null */ +export const originText = (o: LaborDoc["본뜬"]): string | null => + o?.키 || o?.파일 ? `${o.층} ${o.키 ?? o.파일}` : null; /** 읽을 때 기본값(162-1 · 서버 `MARK_DEFAULT` 와 같음) — 저장은 비움 */ export const MAT_MARK_DEFAULT: Required = { 자재구분: "사급", @@ -151,6 +156,8 @@ function cleanShown(v: unknown): { 자재표시?: Record } { return Object.keys(out).length ? { 자재표시: out } : {}; } export interface LaborMat extends MatMarks { + /** 넣어 펼친 자재 출처(740-2) */ + 본뜬?: Record; 코드: string; 이름: string | null; 규격: string | null; @@ -163,7 +170,14 @@ export interface LaborDoc { 열: string; 일위대가번?: string; 단위: string | null; - 본뜬?: { 층: string; 주인: string | null; 키: string; 전국자재?: NationalMat[] } | null; + /** 실무자료 끝낸 뒤(743-1) = 키 없이 `파일 · 때 · 누가` 출처만 */ + 본뜬?: { + 층: string; + 주인?: string | null; + 키?: string; + 파일?: string; + 전국자재?: NationalMat[]; + } | null; 담은로직: LaborRow[]; 자재: LaborMat[]; 계산값?: unknown; @@ -192,6 +206,7 @@ export function normalizeLabor(doc: unknown, column: string): LaborDoc { ...(r.참조 || r.고정 ? {} : cleanShown(r.자재표시)), ...(r.고정 ? { 고정: r.고정 } : {}), // 705-1 — 읽을 때 떨구면 [저장]에서 줄이 사라짐 ...(r.패치 ? { 패치: r.패치 } : {}), // 717-3 — 떨구면 [저장]에서 줄 덮개가 사라짐 + ...(r.본뜬 ? { 본뜬: r.본뜬 } : {}), // 740-2 — 출처 꼬리표 })), 자재: (d.자재 ?? []).map((m) => ({ 코드: m.코드, @@ -199,6 +214,7 @@ export function normalizeLabor(doc: unknown, column: string): LaborDoc { 규격: m.규격 ?? null, 단위: m.단위 ?? null, 수량: m.수량 ?? null, + ...(m.본뜬 ? { 본뜬: m.본뜬 } : {}), // 740-2 ...cleanMarks(m), })), }; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Born.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Born.ts new file mode 100644 index 000000000..660024a55 --- /dev/null +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Born.ts @@ -0,0 +1,37 @@ +/* ============================================================================= + * M02_MasterTemplete_Labor_Born.ts + * 일위대가 상세 출처 꼬리표(740-2) — 넣어 펼친 줄 · 자재의 `본뜬` 을 짧은 글로(풍선 = 키 · 이름 · 층 · 때). + * 일위대가표 격자 = 비고 칸 글 `bornNote` + 풍선 `tipBorn`(칸 폭 · 줄 높이 안 바뀜) + * 줄 표(`Labor_Rows` · `Labor_MatTable`) = 이름 글 끝 `bornSpan`(같은 줄 · 넘치면 말줄임) + * 색 단추 아님 · 셈에 안 씀. + * ========================================================================== */ + +import { el } from "@ui/ui_template_elements"; +import { bornText } from "./logic/M02_Born_Tag"; + +const SPLIT = "\n"; // 글 첫 줄 = 보임 · 나머지 = 풍선 + +/** 일위대가표 격자 비고 칸 풍선 — `at` = 격자 줄 → 일위대가 줄 번호(담은 로직 뒤 자재) */ +export function tipBorn( + root: HTMLElement, + at: (row: number) => number | null, + born: (n: number) => unknown, +): void { + root.querySelectorAll("tr[data-i]").forEach((tr) => { + const n = at(Number(tr.dataset.i)); + const [, ...tip] = n === null ? [] : bornText(born(n)).split(SPLIT); + if (tip.length) + tr.querySelector("td:nth-last-child(2)")?.setAttribute("title", tip.join(" ")); + }); +} + +/** 줄 표 이름 끝 꼬리표 — `본뜬` 이 없으면 null */ +export function bornSpan(born: unknown): HTMLElement | null { + const [shown, ...tip] = bornText(born).split(SPLIT); + if (!shown) return null; + return el("span", { + className: "m02-labrow__born", + text: ` ${shown}`, + attrs: { title: tip.join(" "), "data-born": "" }, + }); +} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts index a0315acaa..bfb4b5a62 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Detail.ts @@ -44,6 +44,7 @@ import { type LaborQty, type LaborRow, type MatMarkKey, + originText, } from "./M02_MasterTemplete_Labor_Api"; import { buildLaborDiagram, @@ -567,7 +568,7 @@ export function mountLaborDetail( ); drawUnit(); const origin = createInputField({ type: "text", label: tc("Labor_Origin") }); - origin.input.value = cur.본뜬?.키 ? `${cur.본뜬.층} ${cur.본뜬.키}` : tc("Origin_Self"); + origin.input.value = originText(cur.본뜬) ?? tc("Origin_Self"); origin.input.readOnly = true; const section = (title: string, button: HTMLElement | null, body: HTMLElement): HTMLElement => diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts index 78070cdfa..260c6ad08 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts @@ -19,6 +19,7 @@ import { } from "@ui/ui_template_hopyo_grid"; import type { ItemLogic } from "./M02_MasterTemplete_Api_Fetch"; import type { LaborCalc, LaborCost, LaborDoc } from "./M02_MasterTemplete_Labor_Api"; +import { bornNote } from "./logic/M02_Born_Tag"; import { lineId } from "./M02_MasterTemplete_Labor_Calc"; import { tc } from "./M02_MasterTemplete_Labor_Text"; import { valueLine } from "./M02_Labor_Values_Model"; @@ -79,7 +80,8 @@ export function laborBlock( amounts: money(line?.반영), note: line?.까닭 ?? - (calc && qty === null ? tc("Grid_NoQty") : row.참조 ? layerWord(row.참조.층) : row.로직), + (bornNote(row.본뜬) || // 740-2 넣은 줄 = 출처 글 + (calc && qty === null ? tc("Grid_NoQty") : row.참조 ? layerWord(row.참조.층) : row.로직)), tag: HOPYO_TAG.pum, }; }); @@ -101,7 +103,7 @@ export function laborBlock( ? tc("Grid_NoQty") : mat.별도계상 !== "직접계산" ? tc("Grid_Apart") // 짝 `settle` 의 aside 와 같은 규칙 - : mat.코드), + : bornNote(mat.본뜬) || mat.코드), }; }); const lines = [...logicLines, ...matLines]; diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts index e4f785c45..7c6be0e7d 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_MatTable.ts @@ -13,6 +13,7 @@ import type { LaborCalcMat, LaborMat, } from "./M02_MasterTemplete_Labor_Api"; +import { bornSpan } from "./M02_MasterTemplete_Labor_Born"; import { markCells, markHeads } from "./M02_MasterTemplete_Labor_MatMarks"; import { moneyCell, @@ -66,7 +67,10 @@ export function matTable(data: MatTableData, on?: Omit): HT el("td", { className: "m02-labrow__name", children: [ - el("strong", { text: mat.이름 ?? "" }), + el("strong", { + text: mat.이름 ?? "", + children: [bornSpan(mat.본뜬)].filter((x): x is HTMLElement => !!x), + }), ...(line?.까닭 ? [el("small", { className: "ui-text ui-text--error", text: line.까닭 })] : []), diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts index eb0cceb42..ac137bf38 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Rows.ts @@ -24,6 +24,7 @@ import type { LaborRow, MatMarkKey, } from "./M02_MasterTemplete_Labor_Api"; +import { bornSpan } from "./M02_MasterTemplete_Labor_Born"; import { lineId } from "./M02_MasterTemplete_Labor_Calc"; import { attachRowDrag } from "./M02_MasterTemplete_Labor_RowDrag"; import { tc } from "./M02_MasterTemplete_Labor_Text"; @@ -414,6 +415,7 @@ export function logicTable(data: LogicTableData, on?: RowHandlers): HTMLElement }), el("strong", { text: fx?.이름 ?? (row.참조 ? line?.이름 : logic?.이름) ?? row.참조?.키 ?? row.로직, + children: [bornSpan(row.본뜬)].filter((x): x is HTMLElement => !!x), }), ...(values.empty ? [ diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts index 7bbbb4138..13418b1eb 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Table.ts @@ -30,9 +30,11 @@ import { type LaborCalc, type LaborDoc, type LaborRow, + originText, } from "./M02_MasterTemplete_Labor_Api"; import type { LaborDetailHandle, LaborDetailOptions } from "./M02_MasterTemplete_Labor_Detail"; import { laborBlock } from "./M02_MasterTemplete_Labor_Grid"; +import { tipBorn } from "./M02_MasterTemplete_Labor_Born"; import { unlinkedBar } from "./M02_MasterTemplete_Labor_Unlinked"; import { pasteInto } from "./M02_MasterTemplete_Labor_Paste"; import { openLogicPicker, withHopyo } from "./M02_MasterTemplete_Labor_Pick"; @@ -187,6 +189,7 @@ export function mountLaborTable( // 칸 초점이 표를 밀면(scroll) 메뉴가 바로 닫힘 — 밀림이 끝난 다음 그림에 엶 requestAnimationFrame(() => requestAnimationFrame(() => openTreeMenu(ev, menuAt(n)))); }); + tipBorn(grid.root, at, (n) => (body.담은로직[n] ?? body.자재[n - body.담은로직.length])?.본뜬); // 740-2 const bar = unlinkedBar(cur, edit && ((qtyOnly) => changed(qtyOnly))); // 729-3 안 이은 줄 띠 gridHost.replaceChildren(...(bar ? [bar] : []), grid.root); showSource(); @@ -429,7 +432,7 @@ export function mountLaborTable( ); drawUnit(); const origin = createInputField({ type: "text", label: tc("Labor_Origin") }); - origin.input.value = cur.본뜬?.키 ? `${cur.본뜬.층} ${cur.본뜬.키}` : tc("Origin_Self"); + origin.input.value = originText(cur.본뜬) ?? tc("Origin_Self"); origin.input.readOnly = true; host.replaceChildren( diff --git a/M02_MasterTemplete/M02_MasterTemplete_Main_Actions.ts b/M02_MasterTemplete/M02_MasterTemplete_Main_Actions.ts new file mode 100644 index 000000000..4f02b668f --- /dev/null +++ b/M02_MasterTemplete/M02_MasterTemplete_Main_Actions.ts @@ -0,0 +1,156 @@ +/* ============================================================================= + * M02_MasterTemplete_Main_Actions.ts + * 단가산출 · 일위대가 상세 머리 단추 [초기화] [삭제](740-2 · 738-2 · 요구 579-3 · 581) — 차례 … [초기화] [삭제] [저장]. + * [삭제] = 735 경고 창(쓰는 곳 표 · 키) → 나무 지우기 → 목록으로 · 쓰는 곳 없으면 한 줄 물음. + * [초기화] = 서버 `-reset` 미리 보기(걷힐 고침 수) → 물음 → 그 층에 씀 → 다시 읽음. + * 덮개 · 뺀줄 · 더한줄 단가를 M01 키 값으로 되돌림 · 옵션(입력값) · 기본정보는 그대로(서버 740-1). + * 둘 다 쓰기 권한이 있는 층에서만 보임(`update`) · 상세에 저장 안 한 고침이 있으면 먼저 물음. + * ========================================================================== */ + +import { createButton, showToast } from "@ui/ui_template_elements"; +import { currentLanguageIndex } from "@ui/ui_template_locale"; +import { askConfirm } from "@ui/ui_template_modal"; +import { + editPrecomboTree, + fetchPrecomboTree, + resetLibrary, + type LibraryKind, +} from "./M02_MasterTemplete_Api_Fetch"; +import { askLibraryDelete } from "./M02_MasterTemplete_Library_Delete"; +import { precomboList } from "./M02_MasterTemplete_UI_Side_Precombo"; +import { sangeunList } from "./M02_MasterTemplete_UI_Side_Sangeun"; +import type { Selection } from "./M02_MasterTemplete_UI_Main"; + +const TEXT = { + Reset: ["초기화", "Reset"], + ResetTip: [ + "고친 값을 연결된 M01 키 값으로 되돌림 — 옵션 · 기본정보는 그대로", + "Revert edited values to their linked M01 key values — options and basic info stay", + ], + Delete: ["삭제", "Delete"], + DeleteTip: [ + "이 항목을 지움 — 쓰는 곳이 있으면 먼저 알림", + "Delete this item — warns first if used", + ], + ResetAsk: [ + "고친 값 {n} 개를 M01 값으로 되돌림{k} — 옵션 · 기본정보는 그대로", + "Revert {n} edited value(s) to M01 values{k} — options and basic info stay", + ], + Restored: [" (빼 둔 줄 {k} 개 되살림)", " ({k} removed line(s) restored)"], + Nothing: ["되돌릴 고침이 없음", "Nothing to revert"], + Done: ["M01 값으로 되돌렸음", "Reverted to M01 values"], + DeleteAsk: ["「{name}」 을(를) 지울까?", "Delete 「{name}」?"], + Deleted: ["지웠음", "Deleted"], + Failed: ["못 했음 — {why}", "Failed — {why}"], +} as const; +const tx = (key: keyof typeof TEXT): string => + String(TEXT[key][currentLanguageIndex as 0 | 1] ?? TEXT[key][0]); +const fill = (text: string, vars: Record): string => + Object.entries(vars).reduce((s, [k, v]) => s.replace(`{${k}}`, String(v)), text); + +export interface MainActionsCtx { + sel: () => Selection | null; + /** 지금 읽은 문서의 판 */ + version: () => string; + /** 지금 읽은 문서(저장본) — 뺀 줄 수를 셈 */ + loaded: () => unknown; + confirmLeave: () => Promise; + open: (sel: Selection | null) => Promise; + /** 좌측 목록을 다시 읽음 */ + changed: () => void; +} + +/** 문서 안 모든 `뺀줄` 길이 합(단가산출 · 일위대가 줄 안 덮개까지) */ +function removedCount(node: unknown): number { + if (Array.isArray(node)) return node.reduce((n, x) => n + removedCount(x), 0); + if (!node || typeof node !== "object") return 0; + return Object.entries(node as Record).reduce( + (n, [k, v]) => n + (k === "뺀줄" && Array.isArray(v) ? v.length : removedCount(v)), + 0, + ); +} +const why = (error: unknown): string => (error instanceof Error ? error.message : ""); + +export function createMainActions(ctx: MainActionsCtx): { + reset: HTMLButtonElement; + del: HTMLButtonElement; + update: (writable: boolean) => void; +} { + const reset = createButton({ label: tx("Reset"), variant: "ghost" }); + const del = createButton({ label: tx("Delete"), variant: "danger-ghost" }); + reset.title = tx("ResetTip"); + del.title = tx("DeleteTip"); + reset.dataset.mainReset = ""; + del.dataset.mainDelete = ""; + + const target = (): { at: Selection; kind: LibraryKind } | null => { + const at = ctx.sel(); + const kind = at?.kind; + return at && at.name && (kind === "sangeun" || kind === "precombo") ? { at, kind } : null; + }; + + reset.addEventListener("click", async () => { + const got = target(); + if (!got || !(await ctx.confirmLeave())) return; + const { at, kind } = got; + try { + const look = await resetLibrary(kind, at.layer, at.owner ?? null, { + 키: at.name, + 미리보기: true, + }); + if (!look.걷힘) return void showToast(tx("Nothing"), "success"); + const k = removedCount(ctx.loaded()); + const message = fill(tx("ResetAsk"), { + n: look.걷힘, + k: k ? fill(tx("Restored"), { k }) : "", + }); + if (!(await askConfirm({ message, okLabel: tx("Reset"), danger: true }))) return; + await resetLibrary(kind, at.layer, at.owner ?? null, { + 키: at.name, + 미리보기: false, + 판: ctx.version(), + }); + await ctx.open(at); // 다시 그림 + ctx.changed(); + showToast(tx("Done"), "success"); + } catch (error) { + showToast(fill(tx("Failed"), { why: why(error) }), "error"); + } + }); + + del.addEventListener("click", async () => { + const got = target(); + if (!got || !(await ctx.confirmLeave())) return; + const { at, kind } = got; + const owner = at.owner ?? null; + try { + const tree = await fetchPrecomboTree(at.layer, owner, kind); + const pick = { 경로: tree.자리?.[at.name] ?? [], 키: at.name }; + const ask = fill(tx("DeleteAsk"), { name: at.label ?? at.name }); + const ans = await askLibraryDelete(kind, at.layer, owner, [pick], ask, tx("Delete")); + if (!ans.ok) return; + await editPrecomboTree( + at.layer, + { op: "delete", 대상: [pick], ...(ans.sure ? { 확인: true } : {}) }, + tree.판, + owner, + kind, + ); + const scope = { layer: at.layer, owner, canWrite: true } as Parameters[0]; + await ctx.open(kind === "sangeun" ? sangeunList(scope) : precomboList(scope)); // 목록으로 + ctx.changed(); + showToast(tx("Deleted"), "success"); + } catch (error) { + showToast(fill(tx("Failed"), { why: why(error) }), "error"); + } + }); + + return { + reset, + del, + update: (writable) => { + const on = writable && !!target(); + reset.hidden = del.hidden = !on; + }, + }; +} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css b/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css index 8b20d7adc..88d5bf2f3 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun.css @@ -52,10 +52,26 @@ font-weight: var(--font-weight-bold); } +/* 740-2 이름 + 출처 꼬리표 한 줄 — 이름이 말줄임으로 줄고 꼬리표는 그대로 */ +.m02-sk .m01lab__namerow { + display: flex; + align-items: center; + gap: var(--spacing-4); + min-width: 0; +} + +.m02-sk .m01lab__namerow > span:first-child { + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + /* 727-2 기초 출처 꼬리표 — 칸 폭 고정 · 넘치면 말줄임(풍선 = 온 글) · 이름 칸 폭을 안 바꿈 */ .m02-sk .m01lab__src { display: inline-block; - max-width: 6em; + flex: none; + max-width: 9em; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; diff --git a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts index d68699dba..cde030267 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_UI_Main.ts @@ -39,6 +39,7 @@ import { isPrecombo } from "./M02_MasterTemplete_UI_Side_Precombo"; import type { SpreadsheetHandle } from "../A00_Common/spreadsheet/spreadsheet"; import type { LinkOptions } from "../A00_Common/spreadsheet/spreadsheet_links"; import { createEmpty } from "@ui/ui_template_empty"; +import { createMainActions } from "./M02_MasterTemplete_Main_Actions"; export interface Selection { layer: Layer; projectId: string | null; @@ -141,6 +142,15 @@ export function createMain( const title = el("h2", { className: "m02-main__title", text: L("M02_PickTemplate") }); const reload = createButton({ label: L("M02_Reload"), variant: "ghost" }); const save = createButton({ label: L("M02_Save"), variant: "filled" }); + // 단가산출 · 일위대가 상세 [초기화] [삭제](740-2 · 738-2) — 차례 … [초기화] [삭제] [저장] + const actions = createMainActions({ + sel: () => sel, + version: () => version, + loaded: () => loaded, + confirmLeave: () => confirmLeave(), + open: (at) => open(at), + changed: () => onSaved?.(), + }); // 구조물 도면 · 일위대가 · 면적산출 상세 화면 → 구조물집계표(그 열 고른 채) · 일반 단추(43-5 · 알약 · ghost 아님) const back = createButton({ label: L("M02_Back") }); const helpSlot = el("span", { className: "m02-main__help" }); // 상세 [?](49-7) — 제목 바로 옆 @@ -171,6 +181,8 @@ export function createMain( helpSlot, slot, reload, + actions.reset, + actions.del, save, ...(extras.newItem ? [extras.newItem] : []), ], @@ -256,6 +268,7 @@ export function createMain( const bar = (): void => { reload.hidden = !sel; save.hidden = !sel || !writable(sel); + actions.update(!!sel && writable(sel)); back.hidden = !sel || !(sel.kind in NUMBER_FIELD); nav.update(back.hidden ? null : sel); // 보임 조건 = 뒤로 단추와 같음 const kind = sel && sel.kind in HELP_TITLE ? (sel.kind as keyof typeof HELP_TITLE) : null; diff --git a/M02_MasterTemplete/M02_Sangeun_Calc.py b/M02_MasterTemplete/M02_Sangeun_Calc.py index 4bd2ae5fd..e94909b07 100644 --- a/M02_MasterTemplete/M02_Sangeun_Calc.py +++ b/M02_MasterTemplete/M02_Sangeun_Calc.py @@ -249,7 +249,8 @@ def tag_of(whole: Any, code: str) -> str: def _detail(one: dict, at: int, whole: Any) -> dict[str, Any]: - """둘째 기초 세부 줄(화면) — 수량 · 금액 · 비목 = 세부 × 더한줄 수량 · cid `add:#k/세부 cid` · + """둘째 기초 세부 줄(화면) — 수량 · 금액 · 비목 = 세부 × 더한줄 수량(상자 합 몫) · `원문` = + 그 기초 1 기준단위 몫(M01 원문 품 · 744-1 화면 품 칸) · cid `add:#k/세부 cid` · `바탕값` = 덮기 전 1 기준단위 품 · 단가 · `뺀세부` = 뺀 줄 이름.""" sub = sub_run(one, whole) plain = sub_run(one, whole, False) if sd.sub_patched(one) else sub @@ -272,6 +273,7 @@ def _detail(one: dict, at: int, whole: Any) -> dict[str, Any]: **scaled, "비목": parts, "cid": f"add:#{at}/{cid}", + "원문": {k: line.get(k) for k in ("수량", "금액", "비목")}, "바탕값": _was(was[cid]) if cid in was else None, **({"덮개": [k for k in sd.COVER_KEYS if k in mine]} if mine else {}), **({"원값": mine["원값"]} if "원값" in mine else {}), @@ -439,6 +441,8 @@ def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]: base = _base_of(rough, whole, refs.read_ref, ()) out = sd.clean(doc, base["줄"], whole) out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"] + for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량 + one.setdefault("처음수량", one["수량"]) if out["덮개"]: bare = run({**out, "덮개": {}}, whole) # 덮기 전 값 = 원값(그때 M01) was = {x["cid"]: x for x in bare.get("줄") or []} diff --git a/M02_MasterTemplete/M02_Sangeun_Doc.py b/M02_MasterTemplete/M02_Sangeun_Doc.py index 5cdf81fbc..890daff6b 100644 --- a/M02_MasterTemplete/M02_Sangeun_Doc.py +++ b/M02_MasterTemplete/M02_Sangeun_Doc.py @@ -196,9 +196,25 @@ def _added(raw: Any, where: str, whole: Any) -> dict: else: raise DocError(f"{where} · 종류는 인력 · 재료 · 기계 · 로직 · 참조 · 고정") mark = {"본뜬": raw["본뜬"]} if isinstance(raw.get("본뜬"), dict) else {} # 출처(740-1) + if raw.get("처음수량") is not None: # 넣을 때 수량(744-1 [되돌림] 값) + mark["처음수량"] = plain(_num(raw["처음수량"], f"{where} 처음수량")) return {**head, "이름": name, "단위": unit, "수량": qty, **mark} +def _gone_adds(raw: Any, whole: Any) -> list[dict]: + """뺀 더한줄 기억(744-1 · [되살림]) `[{차례, 줄}]` — 셈 안 함 · 못 읽는 줄은 버림.""" + out = [] + for one in raw if isinstance(raw, list) else []: + at = one.get("차례") if isinstance(one, dict) else None + if not isinstance(at, int) or isinstance(at, bool) or at < 0: + continue + try: + out.append({"차례": at, "줄": _added(one.get("줄"), "뺀 더한줄", whole)}) + except DocError: + continue + return out + + def _sub_patch(raw: dict, where: str) -> dict: """둘째 기초 세부 고침(727-2) — `덮개` {세부 cid: 덮개} · `뺀줄` [세부 cid] · 빈 칸은 안 둠 · `원값` · `바탕판` = 서버 몫(버림).""" @@ -327,6 +343,8 @@ def clean(doc: Any, base_row: dict | None = None, whole: Any = None) -> dict[str if len(set(drop)) != len(drop): raise DocError("뺀줄에 같은 줄 두 번") out["뺀줄"] = drop + if gone := _gone_adds(doc.get("뺀더한줄"), whole): + out["뺀더한줄"] = gone return out diff --git a/M02_MasterTemplete/logic/M02_Born_Tag.ts b/M02_MasterTemplete/logic/M02_Born_Tag.ts new file mode 100644 index 000000000..fb6021aae --- /dev/null +++ b/M02_MasterTemplete/logic/M02_Born_Tag.ts @@ -0,0 +1,53 @@ +/* ============================================================================= + * M02_Born_Tag.ts + * 넣은 줄 출처 꼬리표(740-2 · 요구 581) — 서버 `본뜬 {층, 주인, 키, 이름, 때}`(740-1) → 화면 글. + * 순수 계산 — 화면 · fetch 없음. 첫 줄 = 줄 옆에 보이는 짧은 글 · 둘째 줄 = 풍선(키 · 이름 · 층 · 때). + * 공용 상세 꼬리표 칸(`LogicLab_Ho` sourceTag)이 「\n」 앞만 보이고 전체를 풍선으로 씀. + * ========================================================================== */ + +export interface Born { + 층?: string | null; + 주인?: string | null; + 키?: string | null; + 이름?: string | null; + 때?: string | null; +} + +const LAYER: Record = { + system: "마스터", + company: "회사", + personal: "개인", + project: "프로젝트", +}; + +/** 서버 때(UTC) → 이 컴퓨터 시각 「2026-11-02 20:13」 · 읽을 수 없으면 "" */ +function localTime(at: unknown): string { + const d = new Date(String(at ?? "")); + if (Number.isNaN(d.getTime())) return ""; + const z = (n: number): string => String(n).padStart(2, "0"); + return `${d.getFullYear()}-${z(d.getMonth() + 1)}-${z(d.getDate())} ${z(d.getHours())}:${z(d.getMinutes())}`; +} + +/** `본뜬` 한 벌 → 꼬리표 글(없으면 ""). `before` = 이미 있는 꼬리표(기초 원문번호) — 앞에 둠 */ +export function bornText(born: unknown, before = ""): string { + const b = born && typeof born === "object" ? (born as Born) : null; + if (!b || (!b.키 && !b.이름)) return before; + const shown = `${before ? `${before} · ` : ""}본뜬 ${b.키 ?? b.이름}`; + const layer = LAYER[String(b.층 ?? "")] ?? String(b.층 ?? ""); + const tip = [`${b.키 ?? ""} ${b.이름 ?? ""}`.trim(), layer, localTime(b.때)] + .filter(Boolean) + .join(" · "); + return `${shown}\n${tip}`; +} + +/** 단가산출 줄 열쇠(`add:#k` · `add:#k/…`) → 그 더한줄의 꼬리표 글 */ +export function bornOfCid(cid: string, adds: readonly object[] | undefined, before = ""): string { + const hit = /^add:#(\d+)/.exec(cid); + return bornText( + hit ? (adds?.[Number(hit[1])] as { 본뜬?: unknown } | undefined)?.본뜬 : undefined, + before, + ); +} + +/** 격자 비고 칸 글 — 「본뜬 SK-000012」 · 없으면 "" (첫 줄만) */ +export const bornNote = (born: unknown): string => bornText(born).split("\n")[0]; diff --git a/M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts b/M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts index 9a871b294..de6ae19bd 100644 --- a/M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts +++ b/M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts @@ -13,6 +13,7 @@ * 화면 · fetch · sessionStorage 없음(`CLAUDE.md` 4장). * ========================================================================== */ +import { bornOfCid } from "./M02_Born_Tag"; import type { SheetGroup } from "../../A00_Common/calc_sheet"; export type CoverPart = "labor" | "material" | "expense"; @@ -470,7 +471,8 @@ export function hoView( const l = lineBy.get(cid); const name = l?.이름 ?? cid; const at = subOf(cid); - const tag = tags.has(cid) ? { 꼬리표: tags.get(cid) } : {}; + const born = bornOfCid(cid, doc.더한줄, tags.get(cid) ?? ""); // 넣은 줄 출처(740-2) — 기초 번호 뒤에 붙임 + const tag = born ? { 꼬리표: born } : {}; if ((at?.cid ?? cid).startsWith("pct:")) { extra.push([cid, { ...((known.get(cid) as HoExtra) ?? { 이름: name, 식: "" }), ...tag }]); continue; diff --git a/resources/master_data/scripts/master_unit.py b/resources/master_data/scripts/master_unit.py index 2a5fb2a4e..35c1ae1a4 100644 --- a/resources/master_data/scripts/master_unit.py +++ b/resources/master_data/scripts/master_unit.py @@ -5,7 +5,7 @@ 조합 알약 배(`M01_MasterData_Store_Combo`) · 엑셀 맞춤 배(`M02_Hopyo_Ours` · `_Match`) · 표 기준배(`master_basis`) · 계산서 줄 환산 근거(714-1). 서버 단독(③) — TS 는 서버가 준 글만 씀. - 단 SK 단위 바꿈 환산(`swap` · 728-1)은 짝(①) — `A00_Common/master_unit_swap.ts` · 거울 시험 `test_728_1_unit_swap.py`. -- 개수 묶음(개 · EA · 본 · 매) = 1 : 1 같은 성격 · 조 · 세트는 묶음 밖(한 조 = 여럿). +- 개수 묶음(개 · EA · 본 · 매 · 개소) = 1 : 1 같은 성격 · hr = 시간(별칭) · 조 · 세트는 묶음 밖(한 조 = 여럿). - 부피 ↔ 무게 = 단위중량 표 CC000337 에서 고른 줄(`unit_weight`)을 받을 때만 · 기본 줄 없음 (사용자 확인 거리) · 밀도(kg ↔ ℓ) · ㎾h 등은 환산 없이 경고 글만. """ @@ -17,7 +17,16 @@ import unicodedata from decimal import Decimal # 맞대기 꼴(`plain`) 별칭 — NFKC · 소문자 · 빈칸 없앤 뒤 -ALIAS = {"ea": "개", "ton": "톤", "t": "톤", "l": "ℓ", "리터": "ℓ", "set": "조", "세트": "조"} +ALIAS = { + "ea": "개", + "ton": "톤", + "t": "톤", + "l": "ℓ", + "리터": "ℓ", + "set": "조", + "세트": "조", + "hr": "시간", +} # 보이는 꼴(`shown`) 별칭 — 표 기준 · 결과단위 분모(원문 기호 ㎡ · ㎥ 그대로) SHOWN = {"ea": "개", "톤": "ton", "t": "ton", "㎞": "km", "hr": "시간", "min": "분", "㎏": "kg"} # 같은 성격 — {성격: {맞대기 단위: 기준 단위 몇 배}} @@ -26,7 +35,7 @@ UNITS = { "길이": {"mm": 1, "cm": 10, "m": 1000, "km": 1000000}, "넓이": {"cm2": 1, "m2": 10000}, "부피": {"cm3": 1, "ℓ": 1000, "m3": 1000000}, - "개수": {"개": 1, "본": 1, "매": 1}, + "개수": {"개": 1, "본": 1, "매": 1, "개소": 1}, } _SCALE = {u: (kind, n) for kind, group in UNITS.items() for u, n in group.items()} WEIGHT_TABLE = "CC000337" # 건설품셈 공통 1-2-4 재료의 단위중량(㎏/㎥) diff --git a/resources/tester/test_704_3_hopyo_grid.py b/resources/tester/test_704_3_hopyo_grid.py index 96bc0d304..fc847ea37 100644 --- a/resources/tester/test_704_3_hopyo_grid.py +++ b/resources/tester/test_704_3_hopyo_grid.py @@ -96,6 +96,7 @@ CALC = {"줄": [{"로직": "GF1", "분모": "㎡", "배": 10, "수량": 2.09, def test_M02_문서_calc_를_격자_줄로(): files = [GRID, "M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Spec.ts", + "M02_MasterTemplete/logic/M02_Born_Tag.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts"] # fmt: skip logics = [ ["GF1", {"이름": "돌쌓기 찰쌓기", "입력": [], "결과단위": "㎡"}], @@ -146,6 +147,7 @@ def test_세_곳_같은_부품(): def test_번호는_글에_안_냄_사람_글은_그대로(): files = [GRID, "M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Spec.ts", + "M02_MasterTemplete/logic/M02_Born_Tag.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts"] # fmt: skip ref = {"로직": "", "별칭": None, "입력값": {}, "수량": {"손": 1}, "참조": {"층": "personal", "주인": "1/3", "키": "SC-000002"}} # fmt: skip diff --git a/resources/tester/test_704_4_spec.py b/resources/tester/test_704_4_spec.py index 7d88c72a0..27471fdc1 100644 --- a/resources/tester/test_704_4_spec.py +++ b/resources/tester/test_704_4_spec.py @@ -176,6 +176,7 @@ def test_격자_규격_열_수량_칸_열마다(): files = [g.GRID, "M02_MasterTemplete/M02_MasterTemplete_Labor_Calc.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Spec.ts", + "M02_MasterTemplete/logic/M02_Born_Tag.ts", "M02_MasterTemplete/M02_MasterTemplete_Labor_Grid.ts"] # fmt: skip doc = {**g.DOC, "규격": {"이름": "H", "열": ["1.5", "2.0"], "기본": "2.0", "수량": {"GF1": {"1.5": 1.5, "2.0": 2.09}, "MT1": {"1.5": 4}}}} # fmt: skip diff --git a/resources/tester/test_705_2_hopyo_paste.py b/resources/tester/test_705_2_hopyo_paste.py index 62cacc2b0..b567d7af9 100644 --- a/resources/tester/test_705_2_hopyo_paste.py +++ b/resources/tester/test_705_2_hopyo_paste.py @@ -94,10 +94,9 @@ def test_실무_xlsx_넷_붙여넣기_만듦_합계_같음(client, tag): assert got["같음"] == FILES[tag][1] and all(abs(x["차이"]) <= 1 for x in got["다름"]) assert len(got["만듦"]) == got["호표"] and got["고정"] + got["호표참조"] == got["줄"] assert master_hash() == before - # 718-1 — 붙여넣기 실무자료 = 지문 없음 → 불러오기 목록엔 숨김 · 파일은 남음 + # 743-1 — 붙여넣기 실무자료 = 만든 뒤 지움(엑셀 보관 안 함) assert client.get("/api/m02/layers/personal/hopyo").json()["줄"] == [] - doc = client.get(f"/api/m02/layers/personal/hopyo/{got['키']}").json() - assert doc["파일"].startswith("붙여넣기") and doc["시트"] == "붙여넣기" + assert client.get(f"/api/m02/layers/personal/hopyo/{got['키']}").status_code == 404 def _block(rows, no): diff --git a/resources/tester/test_707_7_whole_import.py b/resources/tester/test_707_7_whole_import.py index 5c6ee1442..e6a988a0c 100644 --- a/resources/tester/test_707_7_whole_import.py +++ b/resources/tester/test_707_7_whole_import.py @@ -181,8 +181,8 @@ def test_내_자료집에_저장_하위_호표_같이_한_번(world, monkeypatch saved = {p.stem: json.loads(p.read_text("utf-8")) for p in (folder / "precombo").glob("*.json")} for key in keys: for one in saved[key]["담은로직"]: - if "참조" in one: - assert one["참조"]["층"] == "personal" and one["참조"]["키"] in saved + if "참조" in one: # 740-1 하위 호표 = 사본 블록(본뜬 = 같이 만든 개인 SC) + assert one["참조"]["층"] == "사본" and one["본뜬"]["키"] in saved copied = [d["본뜬"]["복사원본"] for d in saved.values() if "복사원본" in (d.get("본뜬") or {})] assert len(copied) == len({json.dumps(x, sort_keys=True) for x in copied}) # 같은 하위 한 번 for p in (folder / "precombo").glob("*.json"): # 다음 시험에 층 쓰기 안 남김 diff --git a/resources/tester/test_717_2b_sangeun_detail.py b/resources/tester/test_717_2b_sangeun_detail.py index cacc11c8f..c63c353a7 100644 --- a/resources/tester/test_717_2b_sangeun_detail.py +++ b/resources/tester/test_717_2b_sangeun_detail.py @@ -9,6 +9,7 @@ """ import json +import re import shutil import subprocess from decimal import Decimal @@ -32,7 +33,9 @@ def _text(p: Path) -> str: def _node(body: str) -> object: - src = _text(MODEL) + "\n" + body + born = _text(M02 / "logic" / "M02_Born_Tag.ts") # 740-2 — 모델이 쓰는 꼬리표 글(import 줄은 뺌) + model = re.sub(r"^import .*$", "", _text(MODEL), flags=re.M) + src = born + "\n" + model + "\n" + body out = subprocess.run( ["node", "--experimental-strip-types", "--no-warnings", "--input-type=module-typescript", "-e", src], diff --git a/resources/tester/test_718_1_hopyo_import.py b/resources/tester/test_718_1_hopyo_import.py index ed4b93a5a..044b1efe2 100644 --- a/resources/tester/test_718_1_hopyo_import.py +++ b/resources/tester/test_718_1_hopyo_import.py @@ -1,7 +1,7 @@ -"""일위대가 불러오기 한시(PLAN 718-1) — 올림 지문 · [끝내기] 지움 · 겹침 막음. +"""일위대가 불러오기 한시(PLAN 718-1 · 743-1) — 올림 지문 · [끝내기] 지움. 같은 엑셀 작업 중 다시 올림 = 그 파일 이어서(새 키 없음) · [끝내기] = HP · 격자 · 맞춤셈 캐시 0 · -만든 일위대가 · 별칭 장부 그대로 · 끝낸 같은 엑셀 다시 올림 409 · 만든 것 없이 지움 = 다시 올림 됨 · +만든 일위대가 · 별칭 장부 그대로 · 끝낸 같은 엑셀 다시 올림 = 새 키(743-1 · 409 걷음) · 옛 HP(지문 없음) = 파일 그대로 목록에서만 숨김 · 키 번 = 지운 뒤에도 다시 안 씀. 층 = 임시 폴더. """ @@ -44,9 +44,9 @@ def test_이어서_끝내기_지움_겹침_막음(client): assert hs.memory(folder) == {"장부 줄": {"갈래": "안 씀"}} assert sorted((folder / "precombo").glob("SC-*.json")) == sc_before # 만든 일위대가 그대로 - block = _post(client) # 끝낸 같은 엑셀 = 막음 · 안내 - assert block.status_code == 409 and "이미 불러온 엑셀" in block.json()["detail"] - assert f"단가산출 {n}" in block.json()["detail"] and _keys(client) == [] + again = _post(client) # 743-1 — 끝낸 같은 엑셀 = 다시 올림 됨(새 키) + assert again.status_code == 200 and again.json()["키"] == "HP-000002" + assert _keys(client) == ["HP-000002"] assert sorted((folder / "precombo").glob("SC-*.json")) == sc_before @@ -88,6 +88,6 @@ def test_결과_단가산출_산근_블록_기초_SK_고름대기_겹침_없음( again = client.post(url).json() # 다시 = 그대로(겹침 없음) assert again["만듦"] == [] and again["그대로"] == len(got["만듦"]) res = client.delete(URL.format("personal") + "/HP-000001").json() - assert res["만든"] == len(got["만듦"]) # 단가산출만 만들어도 지문 기록(블록마다) + assert res["만든"] == len(docs) # 같은 내용 SK 한 벌 — 사본 걷은 문서 수 assert len(list((folder / "sangeun").glob("SK-*.json"))) == len(docs) # 남음 - assert _post(client).status_code == 409 + assert _post(client).status_code == 200 # 743-1 — 다시 올림 됨 diff --git a/resources/tester/test_727_sk_base_add.py b/resources/tester/test_727_sk_base_add.py index 8b4fda491..ad29b9a54 100644 --- a/resources/tester/test_727_sk_base_add.py +++ b/resources/tester/test_727_sk_base_add.py @@ -206,7 +206,13 @@ def _model(ans, doc, script): f"\nconst ans = {json.dumps(ans, ensure_ascii=False)};" f"\nconst doc = {json.dumps(doc, ensure_ascii=False)};\n{script}" ) - return _node(["M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts"], body) + return _node( + [ + "M02_MasterTemplete/logic/M02_Born_Tag.ts", + "M02_MasterTemplete/logic/M02_Sangeun_Cover_Model.ts", + ], + body, + ) def test_727_2_화면_꼴_세부_줄_고침(world): # noqa: F811 diff --git a/resources/tester/test_728_1_unit_swap.py b/resources/tester/test_728_1_unit_swap.py index 37e787471..9d18146d7 100644 --- a/resources/tester/test_728_1_unit_swap.py +++ b/resources/tester/test_728_1_unit_swap.py @@ -40,6 +40,9 @@ CASES = [ ["톤", "㎥", 1600, None], ["10㎥", "kg", 2400, None], ["조", "개", None, None], + ["hr", "시간", None, None], # 746-1 별칭 + ["개소", "개", None, None], + ["10개소", "개", None, None], ] diff --git a/resources/tester/test_733_2_library_ask.py b/resources/tester/test_733_2_library_ask.py index 1b891f2d0..4d6e3b03e 100644 --- a/resources/tester/test_733_2_library_ask.py +++ b/resources/tester/test_733_2_library_ask.py @@ -93,23 +93,23 @@ def test_공유_승인_회사_같은_내용_409_씀_새로(world): def test_복사_딸림_같은_원본_재사용(world): + """구조물 조합 복사 딸림(733-2) = 같은 원본 사본 재사용 · 740-1 — 일위대가 안 일위대가는 + 넣을 때 사본 블록(딸림 없음).""" client = _client(world) _as(world) - mine = layers.personal_dir(7, 42) url = LIB.format("personal", "precombo") inner = client.post(url, json=_doc("안")).json()["이름"] ref = {"층": "personal", "주인": "7/42", "키": inner} outer = {"문서": {"이름": "밖", "단위": "㎡", "담은로직": [{"참조": ref}]}} top = client.post(url, json=outer).json()["이름"] - with store.at(mine): - doc = store.read("precombo", top)["문서"] - src = {"층": "personal", "주인": "7/42", "키": top} + with store.at(layers.personal_dir(7, 42)): + assert store.read("precombo", top)["문서"]["담은로직"][0]["참조"]["층"] == "사본" company = layers.company_dir(7) + combo = {"종류": "일위대가", "열": "rv", "담은로직": [{"참조": ref}], "자재": []} with store.at(company): - one = refs.create("precombo", refs.carry(refs.origin_mark(doc, src), ("personal", "7/42"))) - assert _count(company) == 2 # 밖 + 딸린 안 - two = refs.create("precombo", refs.carry(refs.origin_mark(doc, src), ("personal", "7/42"))) - assert _count(company) == 3 # 다시 복사 = 밖만 새로 · 딸린 안 = 앞 사본 재사용 - with store.at(company): - got = [store.read("precombo", m["이름"])["문서"]["담은로직"][0]["참조"] for m in (one, two)] + one = refs.carry(combo, ("personal", "7/42")) + assert _count(company) == 1 # 딸린 안 = 회사 새 키 + two = refs.carry(combo, ("personal", "7/42")) + assert _count(company) == 1 # 다시 복사 = 앞 사본 재사용 + got = [x["담은로직"][0]["참조"] for x in (one, two)] assert got[0] == got[1] and got[0]["층"] == "company" diff --git a/resources/tester/test_735_1_library_delete.py b/resources/tester/test_735_1_library_delete.py index b18e95d9f..583d2ffcb 100644 --- a/resources/tester/test_735_1_library_delete.py +++ b/resources/tester/test_735_1_library_delete.py @@ -136,7 +136,9 @@ def test_폴더_통째_한_기록_되돌림_자리까지_그새_고친_문서는 a = _sc(me, "가", [FIX]) b = _sc(me, "나", [FIX]) _labor(me, [{"참조": {**MINE, "키": a}, "수량": {"손": 1}}, FIX]) - other = _sc(me, "다른", [{"참조": {**MINE, "키": b}}, FIX]) + with store.at(me): # 쓰는 곳 = 구조물 조합(740-1 — 일위대가 안 일위대가는 사본 블록) + other = [{"참조": {**MINE, "키": b}, "수량": {"손": 1}}, FIX] + store.write("labor", "x2", "", {"열": "x2", "담은로직": other, "자재": []}) assert _tree(api, op="add-folder", 경로=[], 이름="묶음").status_code == 200 for key in (a, b): assert _tree(api, op="move", 키=key, 새경로=["묶음"]).status_code == 200 @@ -147,9 +149,10 @@ def test_폴더_통째_한_기록_되돌림_자리까지_그새_고친_문서는 assert res.status_code == 200, res.text name = res.json()["알림"]["기록"] assert [g["키"] for g in api.get(SAME).json()["합친것"]] == [name] - with store.at(me): # 그새 「다른」 을 고침 → 그 문서는 앞판으로 안 돌림 - have = store.read("precombo", other) - store.write("precombo", other, have["판"], {**have["문서"], "이름": "다른 고침"}) + with store.at(me): # 그새 x2 를 고침 → 그 문서는 앞판으로 안 돌림 + have = store.read("labor", "x2") + lines = [{**x, "메모": "고침"} for x in have["문서"]["담은로직"]] + store.write("labor", "x2", have["판"], {**have["문서"], "담은로직": lines}) back = api.post(SAME + "/undo", json={"키": name}).json() assert back["되돌린곳수"] == 1 and "그새 고침" in back["못한곳"][0] assert (me / "precombo" / f"{a}.json").is_file() and (me / "precombo" / f"{b}.json").is_file() diff --git a/resources/tester/test_740_1_library_flat.py b/resources/tester/test_740_1_library_flat.py index 4eb4bb1ea..e7b9ceb9c 100644 --- a/resources/tester/test_740_1_library_flat.py +++ b/resources/tester/test_740_1_library_flat.py @@ -140,7 +140,8 @@ def test_SC_에_SK_패치_겹침_E1_원본_고쳐도_그대로(world): doc = _read(me, "precombo", host) assert doc["담은로직"][0]["로직"] == PCT and doc["담은로직"][0]["본뜬"]["키"] == sk assert doc["담은로직"][0]["패치"]["덮개"] == {"labor:LB000036#0": {"qty": 0.5}} - assert doc["담은로직"][1]["참조"]["키"] == inner # 하위 호표(SC 안 SC) = 참조 그대로 + assert doc["담은로직"][1]["참조"]["층"] == "사본" # 하위 호표(SC 안 SC) = 사본 블록 + assert doc["담은로직"][1]["본뜬"]["키"] == inner assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) with store.at(me): # E1 — 원본 SK 의 덮지 않은 줄 품 2 now = store.read("sangeun", sk) @@ -151,33 +152,28 @@ def test_SC_에_SK_패치_겹침_E1_원본_고쳐도_그대로(world): assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 펼친 것 = 그대로 -def test_SC_에_SC_펴넣기_실무수량_겹침_넣기_400(world): +def test_SC_에_SC_사본_블록_실무수량_겹침_원본_지워도(world): + """하위 호표(SC 안 SC) = 사본 블록 — 원본 연결 없음 · 금액 같음 · 같은 기초 겹침도 블록 안.""" me = world["personal"] hands = {"층": "실무자료", "실무수량": {"줄": {"0": 3}, "자재": {}}} inner = _make(me, "precombo", 이름="안", 담은로직=[{"로직": PCT}], 본뜬=hands) - outer_hands = {"층": "실무자료", "실무수량": {"줄": {"0": 2, "1": 5}, "자재": {}}} - lines = [{"로직": GF}, {"참조": {**MINE, "키": inner}, "별칭": "안쪽"}] - old = _raw(me, "precombo", 이름="옛", 담은로직=lines, 본뜬=outer_hands) - assert flat.flat_doc("precombo", _read(me, "precombo", old))["담은로직"][1][ - "참조" - ] # 저장 · 읽기 - got = flat.flat_sc(_read(me, "precombo", old), refs.read_ref, _whole()) # 넣기 길 = 펴 넣음 - assert [x["로직"] for x in got["담은로직"]] == [GF, PCT] and got["담은로직"][1][ - "별칭" - ] == "안쪽" - assert got["본뜬"]["실무수량"]["줄"] == {"0": 2, "1": 15} # 바깥 5 × 안 3 - - def mine(r): - return got if r["키"] == old else refs.read_ref(r) - - assert _sc_value(me, old, mine) == pytest.approx(_sc_value(me, old), rel=1e-9) - # 같은 기초가 겹침 — 넣기 길 = 400 - dup = [{"로직": PCT}, {"참조": {**MINE, "키": inner}}] - kept = _make(me, "precombo", 이름="겹침", 담은로직=dup) - assert _read(me, "precombo", kept)["담은로직"][1]["참조"]["키"] == inner - with store.at(me), pytest.raises(store.StoreError) as e: - flat.flat_lines("precombo", {**MINE, "키": inner}, None, {"담은로직": [{"로직": PCT}]}) - assert e.value.status == 400 and "겹침" in str(e.value.detail) + lines = [{"로직": PCT}, {"참조": {**MINE, "키": inner}, "별칭": "안쪽"}] # 같은 기초 겹침 + old = _raw(me, "precombo", 이름="옛", 담은로직=lines) + before = _sc_value(me, old) + host = _make(me, "precombo", 이름="밖", 담은로직=lines) + line = _read(me, "precombo", host)["담은로직"][1] + block = line["참조"] + assert block["층"] == "사본" and block["키"] == inner and line["본뜬"]["키"] == inner + assert block["몸"]["담은로직"][0]["로직"] == PCT and line["별칭"] == "안쪽" + assert block["몸"]["본뜬"]["실무수량"]["줄"] == {"0": 3} # 엑셀 대조 · 하위 호표 끝수 + assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) + with store.at(me): + got = flat.flat_lines("precombo", {**MINE, "키": old}, None, {"담은로직": [{"로직": GF}]}) + (me / "precombo" / f"{old}.json").unlink() # 옛 꼴 문서(참조) 치움 + assert refs.users({**MINE, "키": inner}) == [] + store.delete("precombo", inner) + assert _sc_value(me, host) == pytest.approx(before, rel=1e-9) # 원본 지워도 그대로 + assert got["담은로직"][0]["참조"]["층"] == "사본" # 넣기 길도 블록(겹침 없음) def test_SK_에_SC_줄마다_더한줄(world): @@ -192,10 +188,9 @@ def test_SK_에_SC_줄마다_더한줄(world): hand = flat.sc_adds({"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, Decimal(2), _whole(), {}) assert hand[0]["수량"] == 6 - lines, _, _ = flat._spread( - {"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, {"수량": {"손": 2}}, None, {} - ) - assert lines[0]["수량"] == {"손": 6} + block = {"참조": refs.copy_ref({"담은로직": [{"로직": GF, "수량": {"손": 3}}]}, "SC-000001")} + deep = flat.sc_adds({"담은로직": [{**block, "수량": {"손": 2}}]}, Decimal(1), _whole(), {}) + assert deep[0]["로직"] == GF and deep[0]["수량"] == 6 # 사본 블록 = 바깥 × 안 doc = {"키": "SK-000099", "이름": "x", "단위": "㎥", "바탕": None, "더한줄": got} one = float(labor.run_line(_whole(), GF, {})["기준"]["계"]) assert _sk_total(me, doc) == pytest.approx(2 * one, rel=1e-9) @@ -267,7 +262,20 @@ def test_초기화_SK_SC_M01_값_옵션_남음(world): with store.at(me): got = flat.reset_doc("precombo", sc, None, False, None) line = _read(me, "precombo", sc)["담은로직"][0] - assert got["걷힘"] == 2 and line["패치"] == {"더한줄": [{**ADD, "수량": 0.5}]} + assert got["걷힘"] == 2 and line["패치"] == {"더한줄": [{**ADD, "수량": 0.5, "처음수량": 0.5}]} + # 이음 기계 고정 줄(736-3) = M01 기계 한 시간 값 다시 받음 + from M02_MasterTemplete import M02_Machine_Hourly as machine + + hour = machine.hourly("EQ000019") + fx = {"이름": "굴착기", "단위": "시간", "단가": {"노무비": 1, "재료비": 1, "경비": 1}} + fx["이음"] = {"기계": "EQ000019"} + mc = _make(me, "precombo", 이름="기계", 담은로직=[{"고정": fx}]) + with store.at(me): + assert flat.reset_doc("precombo", mc, None, False, None)["걷힘"] == 1 + price = _read(me, "precombo", mc)["담은로직"][0]["고정"]["단가"] + assert price["노무비"] == pytest.approx(hour["노무비"]) and price["경비"] == pytest.approx( + hour["경비"] + ) def test_길_넣기_초기화_권한(world): @@ -289,7 +297,7 @@ def test_길_넣기_초기화_권한(world): assert firm.status_code == 403 # 일반 사용자 회사 층 쓰기 막힘 -def test_옮기기_함수_전후_같음_겹침_남김(world): +def test_옮기기_함수_전후_같음_사본_블록(world): me = world["personal"] y = _y(me) inner = _make(me, "precombo", 이름="안", 담은로직=[{"로직": GF}]) @@ -314,18 +322,18 @@ def test_옮기기_함수_전후_같음_겹침_남김(world): sk: _sk_total(me, _read(me, "sangeun", sk)) } look = {r["키"]: r for r in flat.migrate(False)} - assert look[sk]["같음"] and look[sc]["같음"] and not look[sc]["씀"] - assert look[sc]["남은참조"] == look[dup]["남은참조"] == [inner] # 하위 호표 = 그대로 + assert all(look[k]["같음"] and look[k]["펼침"] and not look[k]["씀"] for k in (sk, sc, dup)) rows = {r["키"]: r for r in flat.migrate(True)} - assert rows[sk]["씀"] and rows[sc]["씀"] and not rows[dup]["씀"] + assert all(rows[k]["씀"] for k in (sk, sc, dup)) assert not refs.refs_in(json.loads((me / "sangeun" / f"{sk}.json").read_bytes())) - left = refs.refs_in(json.loads((me / "precombo" / f"{sc}.json").read_bytes())) - assert [r["키"] for r in left] == [inner] + for key in (sc, dup): # 하위 호표 = 사본 블록만 남음(원본 연결 없음) + left = refs.refs_in(json.loads((me / "precombo" / f"{key}.json").read_bytes())) + assert [(r["층"], r["키"]) for r in left] == [("사본", inner)] assert _sk_total(me, _read(me, "sangeun", sk)) == pytest.approx(before[sk], rel=1e-9) assert _sc_value(me, sc) == pytest.approx(before[sc], rel=1e-9) assert _sc_value(me, dup) == pytest.approx(before[dup], rel=1e-9) - again = flat.migrate(False) # 두 번째 = 하위 호표 참조만 남음(바꿀 것 없음) - assert [r["키"] for r in again] == [sc, dup] and all(r["남은참조"] == [inner] for r in again) + again = flat.migrate(True) # 두 번째 = 바꿀 것 없음 + assert all(r["펼침"] and not r["씀"] for r in again) def test_733_지문_옛_참조_펼친_것_같음(world): diff --git a/resources/tester/test_740_2_reset_delete_born.py b/resources/tester/test_740_2_reset_delete_born.py new file mode 100644 index 000000000..eca187d26 --- /dev/null +++ b/resources/tester/test_740_2_reset_delete_born.py @@ -0,0 +1,93 @@ +"""740-2 · 738-2 상세 머리 [초기화] [삭제] · 출처 꼬리표 지킴 시험(서버 · 화면 없음).""" + +import json +import re +import subprocess +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +M02 = ROOT / "M02_MasterTemplete" +MAIN = (M02 / "M02_MasterTemplete_UI_Main.ts").read_text(encoding="utf-8") +ACTIONS = (M02 / "M02_MasterTemplete_Main_Actions.ts").read_text(encoding="utf-8") +HO = (ROOT / "M01_MasterData" / "M01_MasterData_UI_LogicLab_Ho.ts").read_text(encoding="utf-8") +COVER = (M02 / "logic" / "M02_Sangeun_Cover_Model.ts").read_text(encoding="utf-8") + + +def _born(expr: str): + """순수 TS(`logic/M02_Born_Tag.ts`)를 Node 로 돌려 JSON 답을 받음.""" + uri = (M02 / "logic" / "M02_Born_Tag.ts").as_uri() + code = ( + f"import {{ bornText, bornOfCid, bornNote }} from '{uri}';" + f"console.log(JSON.stringify({expr}));" + ) + out = subprocess.run( # noqa: S603 — 고정 실행 파일 + ["node", "--experimental-strip-types", "--no-warnings", "--input-type=module", "-e", code], + capture_output=True, + text=True, + check=True, + cwd=ROOT, + ) + return json.loads(out.stdout) + + +BORN = { + "층": "personal", + "주인": "u1", + "키": "SK-000012", + "이름": "강관비계", + "때": "2026-11-02T06:30:12Z", +} + + +def test_꼬리표_글_첫줄_짧게_둘째줄_풍선(): + shown, tip = _born(f"bornText({json.dumps(BORN, ensure_ascii=False)})").split("\n") + assert shown == "본뜬 SK-000012" + assert "SK-000012 강관비계" in tip and "개인" in tip + assert re.search(r"\d{4}-\d\d-\d\d \d\d:\d\d", tip) # 이 컴퓨터 시각 · 시간대 따라 값이 다름 + + +def test_꼬리표_없으면_빈칸_기초번호_뒤에_붙음(): + assert _born("bornText(null)") == "" + assert _born("bornText(undefined, 'A1')") == "A1" + got = _born(f"bornText({json.dumps(BORN, ensure_ascii=False)}, 'A1')") + assert got.split("\n")[0] == "A1 · 본뜬 SK-000012" + + +def test_줄_열쇠에서_그_더한줄_출처를_찾음(): + adds = json.dumps([{}, {"본뜬": BORN}], ensure_ascii=False) + assert _born(f"bornOfCid('add:#1', {adds})").startswith("본뜬 SK-000012") + assert _born(f"bornOfCid('add:#1/add:#0', {adds})").startswith("본뜬 SK-000012") # 펼침 세부 + assert _born(f"bornOfCid('add:#0', {adds})") == "" + assert _born(f"bornOfCid('hopyo:X#3', {adds})") == "" + + +def test_머리_단추_차례_초기화_삭제_저장(): + kids = MAIN[MAIN.index('className: "m02-main__head"') :] + kids = kids[: kids.index("]")] + order = [kids.index(w) for w in ("reload,", "actions.reset,", "actions.del,", "save,")] + assert order == sorted(order) + assert "actions.update(" in MAIN # 쓰기 권한 없는 층 = 안 보임 + + +def test_삭제는_735_경고_창을_그대로_씀(): + assert "askLibraryDelete(" in ACTIONS and '"delete"' in ACTIONS + assert "sure ? { 확인: true }" in ACTIONS.replace( + "ans.sure", "sure" + ) # 확인 몸 = 쓰는 곳 줄까지 + assert "sangeunList(" in ACTIONS and "precomboList(" in ACTIONS # 지운 뒤 목록으로 + + +def test_초기화는_미리보기_뒤_물음_뒤_씀(): + assert ACTIONS.index("미리보기: true") < ACTIONS.index("미리보기: false") + assert "ctx.confirmLeave()" in ACTIONS # 저장 안 한 고침 먼저 물음 + assert "옵션 · 기본정보는 그대로" in ACTIONS + + +def test_공용_꼬리표_칸은_첫줄만_보이고_풍선에_나머지(): + assert 'text.split("\\n")' in HO + assert "bornOfCid(" in COVER + + +def test_격자_비고_칸은_첫줄만(): + assert _born(f"bornNote({json.dumps(BORN, ensure_ascii=False)})") == "본뜬 SK-000012" + assert _born("bornNote(null)") == "" diff --git a/resources/tester/test_743_1_hopyo_forget.py b/resources/tester/test_743_1_hopyo_forget.py new file mode 100644 index 000000000..a8b6c63a0 --- /dev/null +++ b/resources/tester/test_743_1_hopyo_forget.py @@ -0,0 +1,157 @@ +"""불러오기 엑셀 보관 안 함(PLAN 743-1 · 요구 582-3 · 584-2 · `M02_Hopyo_Forget`). + +[끝내기] = 남는 파일 0 · 만든 일위대가 · 단가산출 = 출처(파일 · 때 · 누가)만 · 금액 그대로 · +엑셀 사본(본뜬 키 · 원본 · 확인 · 품셈 · 줄 메모 「실무 …」) 걷음 · +실무수량 = 저장 수량과 같을 때만 걷음 · SK 또 = 그 HP 몫만 · +하루 지난 HP = 목록 숨김 → 올림 때 지움 · 옛 파일 정리 미리 보기(쓰기 0) → 고침. +층 = 임시 폴더. +""" + +import json +from datetime import datetime, timedelta, timezone + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Hopyo_Fit as fit +from M02_MasterTemplete import M02_Hopyo_Forget as forget +from M02_MasterTemplete import M02_Hopyo_Store as hs +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Template_Layers as layers +from resources.tester.test_m02_hopyo_excel import URL, _post, client # noqa: F401 + +ALL = "/api/m02/layers/personal/hopyo-build-all" +SK_URL = URL.format("personal") + "/HP-000001/sangeun" + + +def _files(folder): + return sorted(p.name for p in (folder / hs.DIRNAME).rglob("HP-*.json")) + + +def _sums(folder): + """문서마다 1 단위 기준 계 — 끝내기 전후 같아야 함.""" + whole = refs.Expand(m01.loaded()[1]) + out = {} + with store.at(folder): + for kind in ("precombo", "sangeun"): + for p in sorted((folder / kind).glob("*.json")): + out[p.stem] = refs.summary(folder, kind, p.stem, whole).get("기준금액") + return out + + +def _docs(folder, kind): + return {p.stem: json.loads(p.read_bytes()) for p in sorted((folder / kind).glob("*.json"))} + + +# ── 순수 ────────────────────────────────────────────────────────────── +SURE = {"누가": {"id": 42, "이름": "갑"}, "때": "2026-11-02T00:00:00Z"} +HEAD = {"층": "실무자료", "주인": None, "키": "HP-000003 제2호표", "파일": "가.xls"} + + +def test_SC_사본_걷음_출처만_실무수량은_저장_수량과_같을_때만(): + lines = [ + {"로직": "L1", "메모": "실무 0.3㎥ × 1 · 규격", "수량": {"손": 0.3}, "별칭": "엑셀 품"}, + {"로직": "L2", "메모": "사용자 메모", "수량": {"손": 2}}, + ] + doc = { + "이름": "가", + "담은로직": lines, + "자재": [{"코드": "MT1", "수량": {"손": 5}}], + "본뜬": {**HEAD, "원본": ["personal", "7/42"], "확인": SURE, "품셈": [0], + "전국자재": [{"이름": "모래"}], "실무수량": {"줄": {"0": 0.3, "1": 2}, + "자재": {"MT1": 5}}}, + } # fmt: skip + got = forget.strip_sc(doc) + assert got["본뜬"] == { + "층": "실무자료", + "파일": "가.xls", + "전국자재": [{"이름": "모래"}], + "때": SURE["때"], + "누가": SURE["누가"], + } + assert "메모" not in got["담은로직"][0] and got["담은로직"][1]["메모"] == "사용자 메모" + assert got["담은로직"][0]["별칭"] == "엑셀 품" and got["담은로직"][0]["수량"] == {"손": 0.3} + assert got["자재"] == doc["자재"] + # 742 전 저장본(수량 null) = 실무수량이 셈 근거 → 남김 + old = {**doc, "담은로직": [{**x, "수량": None} for x in lines]} + assert forget.strip_sc(old)["본뜬"]["실무수량"] == doc["본뜬"]["실무수량"] + + +def test_SK_또_그_HP_몫만_걷음(): + other = {"키": "HP-000004 단산1", "원본": None, "갈래": "SK", "엑셀품": {}, "이름": "나"} + doc = {"본뜬": {**HEAD, "키": "HP-000003 단산1", "확인": SURE, "갈래": "기초", "엑셀품": {}, + "못옮김": [], "또": [other]}} # fmt: skip + got = forget.strip_sk(doc, lambda x: str(x.get("키")).startswith("HP-000003 ")) + assert got["본뜬"] == {**{"층": "실무자료", "파일": "가.xls"}, **SURE, "또": [other]} + both = forget.strip_sk(doc, lambda x: True) + assert "또" not in both["본뜬"] and "키" not in both["본뜬"] + + +# ── 길 ─────────────────────────────────────────────────────────────── +def test_끝내기_남는_파일_0_금액_그대로_출처만_다시_올림(client): + folder = layers.personal_dir(7, 42) + assert _post(client).json()["키"] == "HP-000001" + fit.run_job(folder, "HP-000001") + assert client.post(SK_URL).status_code == 200 + made = client.post(ALL, json={"층": "personal", "키": "HP-000001"}).json() + assert made["만듦"] + before = _sums(folder) # 모두 고정 = 메모 없음(메모 걷음은 순수 시험) + cache = fit.cache_path(folder, "HP-000001") + assert cache.is_file() + + res = client.delete(URL.format("personal") + "/HP-000001") + assert res.status_code == 200 + assert _files(folder) == [] and not cache.exists() # HP · 격자 · 맞춤셈 캐시 0 + assert _sums(folder) == before # 금액 그대로 + for kind in ("precombo", "sangeun"): + for key, doc in _docs(folder, kind).items(): + got = doc["본뜬"] + assert got["층"] == "실무자료" and got["파일"] and got["때"], key + assert not {"키", "원본", "확인", "품셈", "갈래", "엑셀품", "못옮김", "또"} & set(got) + lines = doc.get("담은로직") or [] + assert not any(str(x.get("메모", "")).startswith("실무 ") for x in lines) + assert hs.done(folder)["지문"] == {} # 끝낸 기록 없음 + again = _post(client) # 같은 엑셀 다시 올림 = 새 키(409 없음) + assert again.status_code == 200 and again.json()["키"] == "HP-000002" + + +def test_하루_지난_HP_목록_숨김_올림_때_지움(client): + folder = layers.personal_dir(7, 42) + assert _post(client).json()["키"] == "HP-000001" + path = folder / hs.DIRNAME / "HP-000001.json" + doc = json.loads(path.read_bytes()) + old = datetime.now(timezone.utc) - timedelta(days=1, minutes=1) + doc["올린때"] = old.replace(microsecond=0).isoformat().replace("+00:00", "Z") + path.write_text(json.dumps(doc, ensure_ascii=False), encoding="utf-8") + assert client.get(URL.format("personal")).json()["줄"] == [] # 숨김 + assert forget.expired(folder) == ["HP-000001"] + got = _post(client).json() # 같은 엑셀이어도 지난 것 = 지우고 새로(이어서 아님) + assert got["키"] == "HP-000002" and not got.get("이어서") + assert _files(folder) == ["HP-000002.json", "HP-000002.json"] # 이번 것 + 격자 + + +def test_옛_파일_정리_미리_보기_쓰기_0_고침(client): + folder = layers.personal_dir(7, 42) + assert _post(client).json()["키"] == "HP-000001" # 작업 중 — 그대로 + home = folder / hs.DIRNAME + (home / "HP-000007.json").write_text(json.dumps({"키": "HP-000007", "호표": []}), "utf-8") + hs._put_done(folder, {"번": 7, "지문": {"ab": {"파일": "옛.xls", "만든": ["SC-000001"]}}}) + (folder / "precombo").mkdir(exist_ok=True) + gone = {"이름": "옛", "단위": "개", "담은로직": [{"로직": "L", "메모": "실무 1개 × 1"}], + "본뜬": {**HEAD, "키": "HP-000005 제1호표", "확인": SURE}} # fmt: skip + live = {**gone, "본뜬": {**HEAD, "키": "HP-000001 제1호표", "확인": SURE}} + for key, doc in (("SC-000001", gone), ("SC-000002", live)): + text = json.dumps(doc, ensure_ascii=False) + (folder / "precombo" / f"{key}.json").write_text(text, "utf-8") + snap = {p: p.read_bytes() for p in folder.rglob("*.json")} + + rows = forget.tidy(folder) + assert [r["대상"] for r in rows] == ["실무자료/HP-000007", "불러옴.json", "SC-000001"] + assert {p: p.read_bytes() for p in folder.rglob("*.json")} == snap # 미리 보기 = 쓰기 0 + + assert forget.tidy(folder, apply=True) == rows + assert _files(folder) == ["HP-000001.json", "HP-000001.json"] + assert hs.done(folder) == {"번": 7, "지문": {}} + docs = _docs(folder, "precombo") + assert "키" not in docs["SC-000001"]["본뜬"] and "메모" not in docs["SC-000001"]["담은로직"][0] + assert docs["SC-000002"] == live # 작업 중 HP 것 그대로 + assert forget.tidy(folder) == [] # 두 번째 = 할 일 없음 diff --git a/resources/tester/test_744_1_sk_detail_undo.py b/resources/tester/test_744_1_sk_detail_undo.py new file mode 100644 index 000000000..9da898dbf --- /dev/null +++ b/resources/tester/test_744_1_sk_detail_undo.py @@ -0,0 +1,89 @@ +# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 +"""744-1 서버 — 둘째 기초 세부 품 원문 · 되돌리기 기억(임시 storage · M01 읽기만). + +- 둘째 기초 `펼침` 줄 `원문` = 그 기초 1 기준단위 몫(GF000316 품 그대로) · 줄 수량 · 금액 = 머리 + 수량 곱한 몫(상자 합) 그대로 · 머리 수량 = 더한줄 수량 +- 더한줄 `처음수량` = 넣을 때 수량(없으면 저장 때 지금 수량) · 셈 · 지문 안 듦 +- `뺀더한줄 [{차례, 줄}]` = [기초 빼기] · 더한 항목 빼기 기억 · 셈 · 지문 안 듦 · 못 읽는 줄 버림 · + 일위대가 줄 패치도 같음 +""" + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Labor_Doc as labor +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_Library_Same as same +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sangeun_Calc as calc +from resources.tester.test_m02_labor_ref import world # noqa: F401 + +GF = "GF000099" # 원/㎥ +BIG = "GF000316" # 기준단위 100㎥ — ㎥ 바탕에서 처음 수량 0.01 +PCT = "GC001109" +MAN = {"종류": "인력", "요소": "LB000002", "수량": 1} + + +def _sk(folder, **doc): + with store.at(folder): + made = refs.create("sangeun", {"이름": "744", "단위": "㎥", "더한줄": [], **doc}) + return store.read("sangeun", made["이름"])["문서"] + + +def _calc(folder, doc): + with store.at(folder): + return calc.calc_doc(doc) + + +def test_둘째_기초_세부_원문_품_머리_수량(world): + doc = _sk( + world["personal"], 바탕={"로직": GF}, 더한줄=[{"종류": "로직", "로직": BIG, "수량": 0.01}] + ) + got = _calc(world["personal"], doc) + head = next(x for x in got["줄"] if x["cid"] == "add:#0") + m01_lines = labor.run_line(m01.loaded()[1], BIG, {})["줄"] + assert head["수량"] == pytest.approx(0.01) + for row, line in zip(head["펼침"], m01_lines): + assert row["원문"]["수량"] == pytest.approx(float(line["수량"]), rel=1e-9) # 원문 그대로 + assert row["수량"] == pytest.approx(float(line["수량"]) * 0.01, rel=1e-9) # 상자 몫 + assert sum(x["금액"] for x in head["펼침"]) == pytest.approx(head["금액"], rel=1e-9) + assert sum(x["원문"]["금액"] for x in head["펼침"]) * 0.01 == pytest.approx(head["금액"]) + + +def test_처음수량_넣을때_값_셈_지문_안_듦(world): + me = world["personal"] + plain = _sk(me, 바탕={"로직": PCT}, 단위="㎡", 더한줄=[{**MAN, "수량": 3}]) + assert plain["더한줄"][0]["처음수량"] == 3 # 없으면 저장 때 지금 수량 + kept = _sk(me, 바탕={"로직": PCT}, 단위="㎡", 더한줄=[{**MAN, "수량": 3, "처음수량": 1}]) + assert kept["더한줄"][0]["처음수량"] == 1 + assert _calc(me, kept)["기준"]["계"] == _calc(me, plain)["기준"]["계"] + assert same.finger("sangeun", kept) == same.finger("sangeun", plain) + + +def test_뺀더한줄_기억_셈_지문_안_듦_못읽는_줄_버림(world): + me = world["personal"] + gone = [ + {"차례": 0, "줄": {"종류": "로직", "로직": BIG, "수량": 0.01, "덮개": {}}}, + {"차례": 1, "줄": MAN}, + {"차례": -1, "줄": MAN}, # 차례 틀림 + {"차례": 2, "줄": {"종류": "로직", "로직": "GX999999", "수량": 1}}, # 없는 기초 + {"차례": 3}, # 줄 없음 + ] + doc = _sk(me, 바탕={"로직": GF}, 뺀더한줄=gone) + assert [x["차례"] for x in doc["뺀더한줄"]] == [0, 1] + assert doc["뺀더한줄"][1]["줄"]["요소"] == "LB000002" + bare = _sk(me, 바탕={"로직": GF}) + assert _calc(me, doc)["기준"]["계"] == _calc(me, bare)["기준"]["계"] + assert same.finger("sangeun", doc) == same.finger("sangeun", bare) + + +def test_일위대가_줄_패치_기억_처음수량(world): + me = world["personal"] + patch = {"더한줄": [{**MAN, "수량": 2}], "뺀더한줄": [{"차례": 0, "줄": MAN}]} + with store.at(me): + sc = refs.create( + "precombo", {"이름": "744", "단위": "㎡", "담은로직": [{"로직": PCT, "패치": patch}]} + ) + line = store.read("precombo", sc["이름"])["문서"]["담은로직"][0] + assert line["패치"]["더한줄"][0]["처음수량"] == 2 + assert line["패치"]["뺀더한줄"][0]["줄"]["요소"] == "LB000002" diff --git a/resources/tester/test_746_1_hopyo_compare.py b/resources/tester/test_746_1_hopyo_compare.py new file mode 100644 index 000000000..8afc00ccb --- /dev/null +++ b/resources/tester/test_746_1_hopyo_compare.py @@ -0,0 +1,104 @@ +"""746-1 지킴 — 불러오기 고름 대기 후보 블록 줄비교 · 못옮김 · 기계 줄 M01 요소 후보 · 단위 별칭(요구 585). + +고름 대기 블록(북부청 임도 실물 엑셀 · 읽기만) = 판정 · 후보 차례 그대로 + 앞 셋 `줄비교`(같음 · 품다름 · 엑셀만 · +기초만 · 엑셀 품 = 엑셀 지문 품) · 그 기초로 고르면 만드는 SK 와 같은 셈(더한줄 · 뺀줄 수) · 요소 후보 셋 · +hr = 시간 · 개소 = 개(같은 성격). 쓰기 없음 · master_data 원본 그대로. +""" + +from __future__ import annotations + +import sys +from pathlib import Path + +import pytest + +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Hopyo_Elem as elem +from M02_MasterTemplete import M02_Hopyo_Finger as finger +from M02_MasterTemplete import M02_Hopyo_Match as hm +from M02_MasterTemplete import M02_Hopyo_Ours as ours +from M02_MasterTemplete import M02_Hopyo_Sangeun as sg +from M02_MasterTemplete import M02_Hopyo_SkLink as sklink +from M02_MasterTemplete import M02_Hopyo_SkPatch as skp +from M02_MasterTemplete import M02_Hopyo_Verdict as verdict +from resources.tester import helper_m02_hopyo_golden as golden +from resources.tester.test_m02_hopyo_excel import master_hash + +sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "resources/master_data/scripts")) +import master_unit as mu # noqa: E402 + +FILE, BLOCK = "북부청임도", 38 # 고름 대기 · 1위와 견줌 되는 블록 + + +@pytest.fixture(scope="module") +def wait(): + before = master_hash() + if not ours.ready(): + ours.build() + blocks, first = sg.calls(golden.read(FILE)) + block, line = blocks[BLOCK], first[BLOCK] + entry = verdict.block(block, line, hm.targets()) + got = skp.plan(entry, block, line, m01.loaded()[1]) + yield {"entry": entry, "block": block, "line": line, "plan": got} + assert master_hash() == before + + +def test_판정_후보_차례_그대로_앞_셋_줄비교(wait): + got, entry = wait["plan"], wait["entry"] + assert got["갈래"] == skp.WAIT + assert [c["로직"] for c in got["후보"]] == [c["로직"] for c in entry["후보"][: len(got["후보"])]] + assert all("줄비교" in c for c in got["후보"][: skp.COMPARE]) + assert all("줄비교" not in c for c in got["후보"][skp.COMPARE :]) + first = got["후보"][0]["줄비교"] + assert first and first["줄"] + assert sum(first["수"].values()) == len(first["줄"]) + assert {x["꼴"] for x in first["줄"]} <= set(skp.LOOKS) + + +def test_줄비교_엑셀_품_지문_그대로_고르면_같은_셈(wait): + first = wait["plan"]["후보"][0] + rows = first["줄비교"]["줄"] + efp = finger.excel(wait["block"], wait["line"]) + labor = {t: x["품"] for t, x in efp["인력"].items() if x.get("품")} + for x in rows: + if x["갈래"] == "인력": + assert x["엑셀"] == pytest.approx(labor.get(x["이름"]) or None), x + assert x["단위"] == "인" + if x["꼴"] == "같음": + assert x["엑셀"] == pytest.approx(x["기초"], rel=0.01), x + if x["꼴"] == "엑셀만": + assert x["엑셀"] and not x["기초"] + if x["꼴"] == "기초만": + assert x["기초"] and not x["엑셀"] + made = skp.plan( + wait["entry"], wait["block"], wait["line"], m01.loaded()[1], {"로직": first["로직"]} + ) + gone = sum(1 for x in rows if x["꼴"] == "기초만" and x["갈래"] != "자재") + assert len(made["뺀줄"]) == gone + assert made["못옮김"] == first["줄비교"]["못옮김"] + + +def test_요소_후보_셋(): + got = elem.labor("작업반장") + assert 0 < len(got) <= elem.TOP and {x["이름"] for x in got[:2]} == {"작업반장"} + assert all(x["키"].startswith("LB") and x["단가"] for x in got) + got = elem.machines("굴착기 0.7㎥") + assert got and all(x["키"].startswith("EQ") and "굴착기" in x["이름"] for x in got) + got = elem.materials("시멘트", "kg") + assert got and all(x["키"].startswith("MT") for x in got) and len(got) <= elem.TOP + lost = {"갈래": "기계", "이름": "굴착기", "규격": "0.7"} + assert elem.lost(lost)[0]["키"].startswith("EQ") + + +def test_안_이은_기계_줄_EQ_후보(): + line = {"차례": 0, "이름": "굴착기(타이어)", "규격": "0.7㎥", "단위": "hr", "갈래": "기계"} + got = sklink.left(line, None) + assert got["까닭"] == sklink.WHY["기계"] + assert got["후보"] and all(x["키"].startswith("EQ") for x in got["후보"]) + + +def test_단위_별칭_hr_시간_개소_개(): + assert mu.plain("hr") == mu.plain("시간") and mu.plain("HR") == "시간" + assert mu.same_kind("개소", "개") and mu.swap("개소", "개")["배"] == 1 + assert mu.swap("10개소", "개")["배"] == 10 and mu.swap("hr", "시간")["계수"] is None + assert mu.swap("조", "개소")["계수"] == "사용자" # 조는 묶음 밖 그대로 diff --git a/resources/tester/test_m02_hopyo_build.py b/resources/tester/test_m02_hopyo_build.py index d3f4f6293..807dbaf59 100644 --- a/resources/tester/test_m02_hopyo_build.py +++ b/resources/tester/test_m02_hopyo_build.py @@ -250,7 +250,9 @@ def test_하위_호표_먼저_확인_퍼센트_빠짐_통째(client): mine = layers.personal_dir(7, 42) made = _doc(mine, got["참조"]["키"]) line = made["담은로직"][0] - assert line["참조"] == child["참조"] and line["별칭"] == "고화매트재료비" + # 740-1 하위 호표 = 사본 블록(원본 연결 없음 · 키 = 출처) + assert line["참조"]["층"] == "사본" and line["참조"]["키"] == child["참조"]["키"] + assert line["본뜬"]["키"] == child["참조"]["키"] and line["별칭"] == "고화매트재료비" assert line["수량"] is None and made["본뜬"]["실무수량"]["줄"]["0"] == 2.3 # 723-1 assert "고화매트재료비||m2" not in _book(mine) # 호표 참조 줄 = 장부 안 씀 whole = _build(client, 3, 통째={"대상": [{"로직": "GF000101", "배": 1}]}) diff --git a/resources/tester/test_m02_hopyo_match.py b/resources/tester/test_m02_hopyo_match.py index dfc80ec41..e2cc9988c 100644 --- a/resources/tester/test_m02_hopyo_match.py +++ b/resources/tester/test_m02_hopyo_match.py @@ -433,3 +433,15 @@ def test_목록_열_때_뒤_셈_예약(client, monkeypatch): monkeypatch.setattr(fit, "ensure", lambda folder, key: asked.append(key) or {"끝": False}) rows = client.get(URL.format("personal")).json()["줄"] assert [r["키"] for r in rows] == asked == ["HP-000001"] + + +def test_미리_고름_점은_다른_점_1위_출처같음만(client): # 745-1 · 584-3 + _ready(client) + got = _hopyo(client, 3) + for name in ("구조물터파기(인력100%)", "구조물되메우기(인력100%)"): # 다른 점 + 출처 같음 + cands = got[name]["후보"] + assert got[name]["상태"] == "다른 점" and cands[0]["미리"] is True + assert not any("미리" in c for c in cands[1:]) # 1위만 + assert all("미리" not in c for c in got["잔토처리(인력100%)"]["후보"]) # 후보 줄 = 점 없음 + ok = _hopyo(client, 1)["레미콘타설(장비사용)"] # 맞음 줄도 점 없음(이미 체크) + assert ok["상태"] == "맞음" and all("미리" not in c for c in ok["후보"]) diff --git a/resources/tester/test_m02_hopyo_screen.py b/resources/tester/test_m02_hopyo_screen.py index 429ecb39a..a6710daec 100644 --- a/resources/tester/test_m02_hopyo_screen.py +++ b/resources/tester/test_m02_hopyo_screen.py @@ -538,8 +538,12 @@ def test_명사형_단추와_별칭_장부_풀이_359(): def test_372_2_저장은_개인_층에_삭제는_화면_층_권한(): - """718-1 — 만들 층 = 마법사에서 고른 층(올린 층과 같음) · [삭제] = 끝내기 → 처음 걸음.""" + """718-1 — 만들 층 = 마법사에서 고른 층(올린 층과 같음) · [삭제] = 끝내기 → 처음 걸음 · + 743-1 — 지운 파일은 떠남 지움 목록에서 뺌 · 떠남(화면 바뀜 · 페이지 닫음) = 쥔 파일 지움.""" side = _text("M02_MasterTemplete_Hopyo_Wizard.ts") open_ = side.split("m.openHopyoSheet({")[1].split("}),")[0] assert "target: scope," in open_ and "canWrite: true," in open_ - assert "onDeleted: () => void first()," in open_ + assert "drop(layer, file.키);" in open_ and "void first();" in open_ + assert 'addEventListener("pagehide", leave)' in side and "return { root, leave };" in side + panel = _text("M02_MasterTemplete_Hopyo_Side.ts") + assert panel.count("open?.leave?.()") == 1 and panel.count("open.leave?.()") == 1 diff --git a/resources/tester/test_m02_labor_ref.py b/resources/tester/test_m02_labor_ref.py index b3534e2ef..45c5e0dce 100644 --- a/resources/tester/test_m02_labor_ref.py +++ b/resources/tester/test_m02_labor_ref.py @@ -179,18 +179,18 @@ def test_사전조합_틀린_줄_400_순환_422(world): with pytest.raises(store.StoreError) as e: _combo(world["system"], lines) assert e.value.status == 400 + # 740-1 — 사전조합에 사전조합 = 사본 블록(원본 연결 없음) · 되돌려 담아도 순환 없음 a = _combo(world["system"], [one], "가") b = _combo(world["system"], [{"참조": {**SYS, "키": a}}], "나") with store.at(world["system"]): + line = store.read("precombo", b)["문서"]["담은로직"][0] + assert line["참조"]["층"] == "사본" and line["본뜬"]["키"] == a + assert line["참조"]["몸"]["담은로직"][0]["참조"] == one["참조"] have = store.read("precombo", a) - with pytest.raises(store.StoreError) as e: - store.write( - "precombo", - a, - have["판"], - {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]}, - ) - assert e.value.status == 422 and f"{a} → {b} → {a}" in e.value.detail + store.write( + "precombo", a, have["판"], {**have["문서"], "담은로직": [{"참조": {**SYS, "키": b}}]} + ) + assert store.read("precombo", a)["문서"]["담은로직"][0]["참조"]["층"] == "사본" def test_층_규칙은_위_층만(world): @@ -329,11 +329,12 @@ def test_복사는_못_읽는_참조를_같이_복사_본뜬(world): ) got = _read(world["company"], "precombo", made["이름"]) assert got["본뜬"] == {**MINE, "키": sc} - assert [one["참조"] for one in got["담은로직"]] == [ - {**COMPANY, "키": "SC-000001"}, # 회사가 못 읽는 개인 사전조합 → 회사 층 새 키 - {**SYS, "키": sys_sp}, # 마스터는 그대로(옛 승격도) - ] - assert _read(world["company"], "precombo", "SC-000001")["본뜬"] == {**MINE, "키": inner} + # 740-1 — 개인 사전조합은 넣을 때 사본 블록(본뜬) → 회사로 따로 복사 안 함 · + # 마스터 옛 승격 그대로 + block = got["담은로직"][0] + assert block["참조"]["층"] == "사본" and block["본뜬"]["키"] == inner + assert got["담은로직"][1]["참조"] == {**SYS, "키": sys_sp} + assert made["이름"] == "SC-000001" # 딸림 복사 없음 # 못 읽는 옛 개인 승격은 따라 복사 안 함(134-2 · 승격 서고 없음) mine_sp = _promote(world["personal"]) with store.at(world["company"]), pytest.raises(store.StoreError) as e: diff --git a/resources/tester/test_m02_precombo_scope.py b/resources/tester/test_m02_precombo_scope.py index f3233f657..bd96219af 100644 --- a/resources/tester/test_m02_precombo_scope.py +++ b/resources/tester/test_m02_precombo_scope.py @@ -119,7 +119,9 @@ def test_분류_고정_폴더_지움_자유_폴더_메뉴_끌어_옮기기(): assert 'item(L("M02_Delete"), () => void remove([target]))' in menu assert 'opt.scope().canWrite ? undefined : tc("ReadOnly")' in menu # 읽기만 층 = 흐림 remove = side.split("const remove = async (")[1].split("\n };")[0] - assert "showConfirmDialog(ask" in remove and 'op: "delete", 대상:' in remove # 안에 든 것째 + assert ( + "askLibraryDelete(kind," in remove and 'op: "delete", 대상:' in remove + ) # 735 쓰는 곳 경고 뒤 그 줄째 assert 'newHere: tc("Lib_NewHere")' in pre_side assert '({ 이름: name, 구분: "", 상세구분: "", 단위: null, 담은로직: [] })' in pre_side make = side.split("const make = (path: string[]): void => {")[1].split("\n };")[0]