diff --git a/A00_Common/formula_doc_options.ts b/A00_Common/formula_doc_options.ts index 61385c60c..836e057fc 100644 --- a/A00_Common/formula_doc_options.ts +++ b/A00_Common/formula_doc_options.ts @@ -1,7 +1,7 @@ /* ============================================================================= * formula_doc_options.ts * 수식 문서 옵션 가로(PLAN 802-3 · 802-4b-2 · 요구 655 「옵션 선택은 상단에 수평」) — 선택 · 입력 기호마다 칸 하나 - * 값 = 화면 값(`given`) › 문서 값 · 고침은 부른 쪽 `set`(M01 = 화면 값만 · M02 사본 = 문서 값) · `lock` = 읽기만 + * 값 = 화면 값(`given`) › 문서 값 · 고침은 부른 쪽 `set`(M01 = 고칠 권한 = 문서 기본값 · 읽기 = 화면 값만 · M02 사본 = 문서 값 · 848-10) · `lock` = 읽기만 * 목록이 모두 기계 원문번호(`0101-0007`)면 글 = 「이름 규격 (원문번호)」(요구 692-2 · 값은 그대로 · 이름은 한 번 받아 둠) * `view` 있음 + 기계 목록 = 곁에 [조회](827-1 · 기계 창 읽기 전용 · 고른 기계) * `hide` = 안 그릴 기호(847-1 시간당 식 줄이 안 읽게 된 옵션 · 값은 그대로) diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index a71402e4d..0cff7c587 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -329,7 +329,8 @@ export function createStackScreen(opt: StackScreenOptions) { } const setOption = (k: string, v: DocVar, x: unknown): void => { const at = doc?.변수?.indexOf(v) ?? -1; - if (cp) return change((d) => at >= 0 && (d.변수![at].연결 = { ...v.연결!, 값: x })); + // 848-10 M01 기초 = 고칠 권한이면 옵션 기본값(M02 새 단가산출이 이 값으로 시작) · 읽기 = 화면 값만 + if (cp || edit()) return change((d) => at >= 0 && (d.변수![at].연결 = { ...v.연결!, 값: x })); given[k] = x; recalc(); draw(); diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 628874cac..d1786ff5d 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -14,6 +14,9 @@ SK 금액(기준 · 1 단위 = 기준 ÷ 배) = 문서 셈 — 일위대가 · 위 층 덮음(848-1) = `수식.위덮음`(① · 기초 문서 `기계덮음` 사본 · 문서 `기계덮음` = ② 내 고침만) — 프로젝트 층 밖 = 셈마다 지금 기초 것(`upper`) · [저장] 때 굳음 · 프로젝트 층 · 가져온 식 = 저장본 · 파생 문서(`derive`)는 기초 문서의 `기계덮음` 을 떼고 복사(② 와 안 섞임). +기초 문서(848-10) = 프로젝트 층 밖 = 지금 M01 문서 그대로(옵션 기본 포함 · 옛 로직 줄 + 자동값 안 씀 · 내가 고른 값만 얹음) · 굳힌 사본 · 프로젝트 층 = `수식.바탕문서`(굳힐 때 · + 손고침 기초를 저장할 때 사본) › 옛 길(옛 사본 금액 그대로). """ from __future__ import annotations @@ -36,6 +39,9 @@ import master_doc_cover as mcv # noqa: E402 — scripts 길 = dc KEY = dc.KEY UPPER = mcv.UPPER +BASE_DOC = ( + "바탕문서" # `수식` 칸(848-10) — 기초 문서 사본(손고침 기초 · 굳힌 사본) · 프로젝트 셈의 기초 +) OLD_FIELDS = ( "바탕", "입력값", "열린입력", "덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침", "고름", "자재표시", "켜쌓기율", @@ -78,27 +84,61 @@ def _set_values(doc: dict, given: dict) -> None: link["값"] = given[var["열쇠"]] +def base_doc(sk: dict, whole: Any, key: str) -> tuple[dict | None, bool]: + """기초 문서(848-10) → (문서, 옵션 기본을 문서에서 읽음) — 프로젝트 층 밖 = 지금 M01 문서 · + 그 밖(굳힌 사본 · 프로젝트 층) = 굳힐 때 사본 `바탕문서` › 손고침 기초 = 빌더 문서 + (굳은 뒤 고침 안 받음) › 지금 문서 · 문서에서 안 읽음 = 옛 로직 줄 자동값 + (옛 사본 금액 그대로).""" + live = dc.folder().get(key) + if renew.on() and live is not None: + return dc.doc_of(whole, key), True + kept = (sk.get(KEY) or {}).get(BASE_DOC) if isinstance(sk.get(KEY), dict) else None + if kept: + return cp.deepcopy(kept), True + if live is not None and live.get(mcv.HAND): + from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 + + return m01.built(key), False + return dc.doc_of(whole, key), False + + +_PATCH = ("덮개", "뺀줄", "더한줄", "뺀더한줄", "상수덮개", "표값덮개", "수식고침") + + +def patched(sk: dict) -> bool: + """옛 칸이 기초 줄을 고친 SK — 파생 문서 = 고친 줄 변환(기초 문서 사본 `바탕문서` 안 씀).""" + return any(sk.get(k) not in (None, {}, []) for k in _PATCH) + + +def _bare_doc(doc: dict) -> dict: + return {k: v for k, v in doc.items() if k not in (mcv.COVER, mcv.HAND)} + + def derive(sk: dict, ctx: tuple) -> dict: """옛 칸이 낸 고친 줄(`ctx` = run 이 엔진에 넣은 (색인, 키, 입력, 바탕 답)) → 이 SK 문서. - 덮개 없는 바탕(고친 줄 = 바탕 줄) = 그 M01 문서 사본 · 아니면 고친 줄 변환.""" + 덮개 없는 바탕(고친 줄 = 바탕 줄) = 기초 문서(`base_doc`) 사본 · 아니면 고친 줄 변환 · + 옵션 = 기초 문서 기본 위에 내가 고른 값(848-10 · 옛 로직 줄 자동값이 기초 고침을 안 이김).""" whole, key, values, got, mats = ctx row = whole.logic(key) given = dc.given_of(whole, key, values) + mine = {k: v for k, v in given.items() if k in (values or {})} # 내가 고른 값 base_key = str((sk.get("바탕") or {}).get("로직") or "") - plain = None + plain, real = None, False if base_key: try: frozen = whole.logic(base_key) same = {**row, "키": base_key} == frozen except dc._ERR: same = False - plain = dc.doc_of(whole, base_key) if same else None + plain, real = base_doc(sk, whole, base_key) if same else (None, False) if plain is not None: - doc = cp.deepcopy({k: v for k, v in plain.items() if k != mcv.COVER}) # ① = `위덮음`(848-1) - _set_values(doc, given) + doc = cp.deepcopy(_bare_doc(plain)) # ① = `위덮음`(848-1) + _set_values(doc, mine if real else given) elif not (row.get("호표") or row.get("덧줄") or row.get("결과")): doc = dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or "")) else: + live = dc.folder().get(base_key) if base_key and renew.on() else None + given = {**given, **renew._opts(live), **mine} if live else given doc = dc.cv.convert(whole, row, given)[0] apart = dc.apart_of(got.get("자재표시"), mats) doc = dc.line_doc(doc, got.get("켜쌓기율"), got.get("고름") or None, apart) @@ -118,13 +158,18 @@ def seed(sk: dict) -> dict | None: return {**empty, "문서": dc.md.blank(str(sk.get("키") or ""), str(sk.get("이름") or ""))} -def with_upper(sk: dict, got: dict) -> dict: - """① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · 기초 문서 없음 = 그대로 · - ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함.""" +def with_upper(sk: dict, got: dict, keep: bool = False) -> dict: + """① 위 층 덮음을 지금 기초(`바탕.로직`) 문서 `기계덮음` 으로(848-1) — 없으면 칸 뺌 · + 기초 문서 없음 = 그대로 · ① 이 부르는 시간당 작업량 식 = 부름 닫힌 묶음에 더함 · + 기초 문서 사본 `바탕문서`(848-10) = 손고침 기초 · `keep`(굳히기) = 늘 · 옛 칸이 줄을 고친 SK 빼고 — + 프로젝트 사본이 굳힐 때 기초 문서로 셈(`base_doc`).""" key = str((sk.get("바탕") or {}).get("로직") or "") live = dc.folder().get(key) if key else None if live is None: return got + got = {k: v for k, v in got.items() if k != BASE_DOC} + if (keep or live.get(mcv.HAND)) and not patched(sk): + got[BASE_DOC] = norm(_bare_doc(live)) # JSON 꼴(굳힌 사본 · 저장 파일) cover = mcv.cover_of(live) if not cover: return {k: v for k, v in got.items() if k != UPPER} if UPPER in got else got diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 572ccaa34..9d5f1ebfc 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -104,8 +104,9 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: def layers(copy: dict, sk: dict) -> dict[str, Any]: """848-8 바뀐 자리 바탕 — {위: 위 층 문서, 빌더?: 기초가 손고침이면 빌더 문서} · 모름 = 빈 묶음. - 위 층 = 그 기초 문서(지금 · 덮음 · 손고침 표지 뺌 · 옵션 값 = 파생과 같게 옛 로직 줄 기본) · - 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) · 읽기만(파일 안 씀).""" + 위 층 = 파생과 같은 기초 문서(`dsk.base_doc` · 덮음 · 손고침 표지 뺌 · 옵션 값 = 그 문서 기본 · + 옛 길 = 옛 로직 줄 기본) · 가져온 식 = 불러올 때 문서(따로 = `처음` · 아니면 지금 파생) · + 읽기만(파일 안 씀).""" if dim.is_imported(sk): up = copy.get(renew.FIRST) if copy.get("따로") else copy.get("문서") out = {"위": up} if up else {} @@ -114,16 +115,20 @@ def layers(copy: dict, sk: dict) -> dict[str, Any]: live = dc.folder().get(key) if key else None if live is None: return {} - out = {"위": {k: v for k, v in live.items() if k not in (mcv.COVER, mcv.HAND)}} - if live.get(mcv.HAND): + top, real = dsk.base_doc({**sk, dsk.KEY: copy}, dc.over(copy), key) + if top is None: + return {} + out = {"위": dsk._bare_doc(top)} + if live.get(mcv.HAND) and renew.on(): from M01_MasterData import M01_MasterData_Doc as m01 # M02 가 M01 을 부름 — 늦게 - if (top := m01.built(key)) is not None: - out["빌더"] = top + if (built := m01.built(key)) is not None: + out["빌더"] = built out = json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) # 사본 - auto = dc.given_of(skc.whole_(), key, {}) # `derive` 와 같은 옵션 값 - for doc in out.values(): - dsk._set_values(doc, auto) + if not real: # 옛 길 — `derive` 와 같은 옵션 값 + auto = dc.given_of(skc.whole_(), key, {}) + for doc in out.values(): + dsk._set_values(doc, auto) return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) diff --git a/M02_MasterTemplete/M02_Item_Sangeun.py b/M02_MasterTemplete/M02_Item_Sangeun.py index 9d5b7e2d1..30dd1820c 100644 --- a/M02_MasterTemplete/M02_Item_Sangeun.py +++ b/M02_MasterTemplete/M02_Item_Sangeun.py @@ -98,7 +98,7 @@ def _upper(doc: dict) -> dict: from M02_MasterTemplete import M02_Doc_Import as dim from M02_MasterTemplete import M02_Doc_Sk as dsk - return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"]) + return doc["수식"] if dim.is_imported(doc) else dsk.with_upper(doc, doc["수식"], keep=True) def _patched(doc: Any) -> list[int]: diff --git a/M02_MasterTemplete/M02_Sk_AutoRenew.py b/M02_MasterTemplete/M02_Sk_AutoRenew.py index eeff3a3ca..b6d597cf3 100644 --- a/M02_MasterTemplete/M02_Sk_AutoRenew.py +++ b/M02_MasterTemplete/M02_Sk_AutoRenew.py @@ -171,6 +171,67 @@ def _replay(mine: dict, first: Any, live: Any) -> tuple[dict, list[str], list[st return put, [f"{k} {v}" for k, v in put.items()], lost +LABEL = dc.LABEL # 변수 · 식 · 금액 줄 글 칸 — 위가 바꾸면 안 고친 줄은 따라옴(848-10) +_ROWS = (("변수", dc.md.var_id), ("식", lambda x: str(x.get("기호") or ""))) + + +def _relabel(mine: dict, first: dict, live: dict) -> None: + """글만 바뀐 줄 = 안 고친 줄(원본 줄 그대로)만 새 글로 — `mine` · `first` 제자리. + 금액 = 차례(셈 같음 = 같은 차례) · 변수 = 기호 · 식 = 기호.""" + pairs: list[tuple[dict, dict]] = [] + a, b = first.get("금액") or [], live.get("금액") or [] + pairs += list(zip(a, b)) if len(a) == len(b) else [] + for part, key in _ROWS: + now = {key(x): x for x in live.get(part) or []} + pairs += [(x, now[key(x)]) for x in first.get(part) or [] if key(x) in now] + for old, new in pairs: + if all(old.get(k) == new.get(k) for k in LABEL): + continue + fresh = { + **{k: v for k, v in old.items() if k not in LABEL}, + **{k: new[k] for k in LABEL if k in new}, + } + for part in ("금액", "변수", "식"): + rows = mine.get(part) or [] + for n, x in enumerate(rows): + if x == old: + rows[n] = cp.deepcopy(fresh) + old.clear() + old.update(fresh) + + +def _soft(mine: dict, first: dict, live: dict, held: set, opts: bool, confirm: bool): + """따로 문서 — 위 기초가 옵션 기본 · 글만 바꿈(848-10) → (새 문서, 새 원본, + 지킨 옵션 [(열쇠, 전, 후, 내값)]) · 계산 구조가 바뀜 = None(다시 복사). + 옵션: 안 고른 열쇠 = 새 기본 따라옴(원본도) · 고른 열쇠 = 내 값 지킴 + 알림(원본 그대로 = + [확인] 까지 · 옛 칸 `입력값` 고름 = 알림 없이 지킴) · 글: 안 고친 줄만 새 글 · + `opts` 거짓 = 계산 내용 그대로(글만 봄).""" + was, have, now = _opts(first), _opts(mine), _opts(live) + if opts and dc.doc_fp(put_opts(live, was)) != dc.doc_fp(first): + return None + mine, first = cp.deepcopy(mine), cp.deepcopy(first) + _relabel(mine, first, live) + follow, kept, ack = {}, [], {} + for k, v in now.items() if opts else (): + if k not in was or mcv._canon(v) == mcv._canon(was[k]): + continue + if k in held or (k in have and mcv._canon(have[k]) != mcv._canon(was[k])): + kept += [] if k in held else [(k, was[k], v, have.get(k))] + ack[k] = v + else: + follow[k] = v + mine, first = put_opts(mine, follow), put_opts(first, {**follow, **(ack if confirm else {})}) + return mine, first, [] if confirm else kept + + +def _opt_note(key: str, doc: dict, kept: list) -> dict: + return { + "키": key, "이름": str(doc.get("이름") or key), "갈래": "문서", "처리": "지킴", + "M01": [f"{k} {_txt(a)} → {_txt(b)}" for k, a, b, _ in kept], + "내고침": [f"{k} {_txt(m)}" for k, _, _, m in kept], "다시얹음": [], + } # fmt: skip + + def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any: """수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) · 계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) · @@ -190,10 +251,20 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> calls[k] = cp.deepcopy(live[k]) redo = {k for k in moved if dc.doc_fp((got.get("부름") or {}).get(k)) != dc.doc_fp(live[k])} cut = dict(out.get("끊음") or {}) - for k in sorted(redo & set(cut)): - mine, was = cut.pop(k), (got.get("부름") or {}).get(k) - if dc.doc_fp(mine) == dc.doc_fp(was): + for k in sorted(moved & set(cut)): + was = (got.get("부름") or {}).get(k) + if k in redo and dc.doc_fp(cut[k]) == dc.doc_fp(was): + cut.pop(k) continue # 안 고친 끊음 = 조용히 따라옴 + soft = _soft(cut[k], was, live[k], set(), k in redo, False) if was else None + if soft is not None: # 옵션 기본 · 글만 바뀜 = 끊음 지킴 · 고른 옵션 알림(848-10) + cut[k] = soft[0] + if soft[2] and notes is not None: + notes.append(_opt_note(k, live[k], soft[2])) + continue + if k not in redo: + continue + mine = cut.pop(k) put, again, lost = _replay(mine, was, live[k]) if put: cut[k] = put_opts(cp.deepcopy(live[k]), put) @@ -202,7 +273,19 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> out |= {"부름": calls, "끊음": cut} base = out.get("원본") or {} key = str(base.get("키") or "") - if out.get("따로") and key in live and not dc.same_origin(base, live[key]): + moved_doc = out.get("따로") and key in live and not dc.same_origin(base, live[key]) + if out.get("따로") and key in live and out.get(FIRST) is not None: + held = set((sk.get("입력값") or {}) if isinstance(sk.get("입력값"), dict) else ()) + soft = _soft(out["문서"], out[FIRST], live[key], held, bool(moved_doc), confirm) + if soft is not None: # 옵션 기본 · 글만 바뀜 = 다시 복사 없이 얹음(848-10) + mine, first, kept = soft + out |= {"문서": mine, FIRST: first} + if moved_doc and (confirm or not kept): + out["원본"] = {**base, "판": dc.doc_fp(live[key])} + if kept and notes is not None: + notes.append(_opt_note(key, mine, kept)) + moved_doc = False + if moved_doc: first = out.get(FIRST) mine = out.get("문서") or {} put: dict = {} diff --git a/common_util/common_util_line_stack_diff.ts b/common_util/common_util_line_stack_diff.ts index de9cfa9b6..6b096f9e8 100644 --- a/common_util/common_util_line_stack_diff.ts +++ b/common_util/common_util_line_stack_diff.ts @@ -259,7 +259,8 @@ function setValue(d: StackDoc, id: string, was: ReturnType): voi if (was?.식 !== undefined) d.식.push({ 기호: id, 식: was.식 }); } -/** 빠진 줄 되살림 — `src` 금액 줄 `at` 을 항목 `k` 에(앞 짝 줄 뒤) · 그 줄이 부르는 기호 중 없는 것도 */ +/** 빠진 줄 되살림 — `src` 금액 줄 `at` 을 제 그룹(`home` · 그룹째 빠졌으면 제목째 새로 · 제목 없음 = 항목 `k`)에 + * (앞 짝 줄 뒤) · 그 줄이 부르는 기호 중 없는 것도 */ export function restoreLines( d: StackDoc, items: StackItem[], @@ -280,6 +281,8 @@ export function restoreLines( (uses.get(id) ?? []).forEach(pull); }; const match = matchLines(d.금액 ?? [], src.금액 ?? []); + const srcItems = stackOf(src); + const srcOf = itemOfLine(srcItems); for (const b of [...at].sort((x, y) => x - y)) { const line = clone((src.금액 ?? [])[b]); if (!line) continue; @@ -289,10 +292,26 @@ export function restoreLines( } const n = (d.금액 ??= []).push(line) - 1; match[n] = b; + const into = home(items, srcItems, srcOf.get(b) ?? -1) ?? it; let p = 0; // 앞 짝 줄 뒤 - it.줄.forEach((l, j) => { + into.줄.forEach((l, j) => { if (l.꼴 === "금액" && match[l.i] >= 0 && match[l.i] < b) p = j + 1; }); - it.줄.splice(p, 0, { 꼴: "금액", i: n }); + into.줄.splice(p, 0, { 꼴: "금액", i: n }); } } + +/** 되살릴 줄의 제 그룹(848-10) — `src` 그룹 제목이 있으면 그 제목 항목 › 없으면 새 항목 + * (`src` 차례에서 앞 그룹들 뒤) · 제목 없음 = undefined(누른 항목) */ +function home(items: StackItem[], src: StackItem[], si: number): StackItem | undefined { + const title = src[si]?.제목 ?? ""; + if (!title) return undefined; + const have = items.find((x) => x.제목 === title); + if (have) return have; + const before = new Set(src.slice(0, si).map((x) => x.제목)); + let at = 0; + items.forEach((x, j) => before.has(x.제목) && (at = j + 1)); + const it: StackItem = { 제목: title, 줄: [] }; + items.splice(at, 0, it); + return it; +} diff --git a/resources/tester/test_848_10_upper_down.py b/resources/tester/test_848_10_upper_down.py new file mode 100644 index 000000000..b5f726ef9 --- /dev/null +++ b/resources/tester/test_848_10_upper_down.py @@ -0,0 +1,244 @@ +# ruff: noqa: F811 — 임시 층 · 임시 수식 문서 폴더 fixture 를 다른 시험에서 받아 씀 +"""848-10 M01 기초 고침이 M02 단가산출로 내려감(요구 887 · 889 · 요구서_889 1 · 3 절). + +㉡ 새 단가산출 = 고친 기초 그 상태(옵션 기본 · 입력 기본 · 줄 수량 · 줄 뺌 · 기계 고침 · 작업량 방식) — + 문서 = 기초 문서 · 위덮음 = 기초 기계덮음 · 금액 = 기초 금액. +㉢ 있던 단가산출 — 안 고친 것 = 따라옴 · 다른 옵션을 고른 것 = 내 값 지킴 + 나머지 따라옴 · + 같은 옵션을 고른 것 = 내 값 지킴 + 알림 → [확인] 뒤 알림 없음 · 줄을 고친 것 + 옵션 기본 바뀜 = 줄 고침 지킴 + (다시 복사 아님) · 기초 줄 이름만 바뀜 = 안 고친 줄 이름 따라옴. +㉣ 프로젝트 사본 — 고치기 전 굳힌 것 = 그대로 · 고친 뒤 굳힌 것 = 그때 단가산출 금액(손고침 기초 사본). +㉤ 손고침 기초 = 빌더가 안 덮음(그 로직 파일 글 = 저장본) · SK 층바탕 = {위: 기초, 빌더} → 기초에서 바꾼 옵션 = 위(주황). +㉥ 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목)으로 · 처음 문서 차례. +정본 파일 안 고침 — 수식 문서 폴더 = 임시 사본 · 층 = 임시 storage. +""" + +from __future__ import annotations + +import copy as cp +import importlib +import json +import shutil + +import pytest + +from M01_MasterData import M01_MasterData_Doc as m01doc +from M01_MasterData import M01_MasterData_Store as m01 +from M02_MasterTemplete import M02_Doc_Copy as dc +from M02_MasterTemplete import M02_Doc_Sk_Path as path +from M02_MasterTemplete import M02_Item_Prices as item_prices +from M02_MasterTemplete import M02_Item_Source as source +from M02_MasterTemplete import M02_Labor_Ref as refs +from M02_MasterTemplete import M02_MasterTemplete_Store as store +from M02_MasterTemplete import M02_Sk_AutoRenew as renew +from resources.tester.test_848_1_cover_layers import docs_tmp # noqa: F401 +from resources.tester.test_848_8_diff import _node +from resources.tester.test_m02_labor_ref import world # noqa: F401 + +ml = importlib.import_module("master_doc_link") +mcv = importlib.import_module("master_doc_cover") +cv = importlib.import_module("master_doc_convert") +build = importlib.import_module("build_수식문서_802_2") + +CON = "GC000198" # 레디믹스트콘크리트 타설 — 선택 · 입력 옵션 · 인력 둘 · 굴착기 · 공구손료 +CUT = "GC000088" # 터파기(기계) — 옵션 Type 이 굴착기를 고름 +NO, SYM = "0201-0100", "P_굴착기무한궤" + + +def _j(v): + return json.loads(json.dumps(ml._norm(v), ensure_ascii=False, default=str)) + + +def _at(folder, fn, *a): + with store.at(folder): + return fn(*a) + + +def _sk(me, base: str) -> str: + body = {"이름": "sub2임시 848-10", "단위": "㎥", "더한줄": [], "바탕": {"로직": base}} + return _at(me, lambda: refs.create("sangeun", body)["이름"]) + + +def _read(folder, key): + return _at(folder, path.read, key) + + +def _edit_sk(me, key, fn) -> None: + got = _read(me, key) + doc = cp.deepcopy(got["문서"]) + fn(doc) + _at(me, path.save, key, {"문서": doc, "판": got["판"]}) + + +def _m01(key, fn) -> dict: + doc = _j(m01doc.read(key)["문서"]) + fn(doc) + return m01doc.save(doc) + + +def _opt(key, val): + def fn(d): + next(v for v in d["변수"] if v.get("열쇠") == key)["연결"]["값"] = val + + return fn + + +def _val(doc, key): + return renew._opts(doc).get(key) + + +def _bare(doc) -> str: + drop = ("키", "이름", mcv.COVER, mcv.HAND, "쌓기", "판", "꼴") + return dc.fp(_j({k: v for k, v in (doc or {}).items() if k not in drop})) + + +def _is_base(got, key) -> bool: + """단가산출 = 그 기초 그대로(문서 · 위덮음 · 금액).""" + live = dc.folder()[key] + return ( + _bare(got["문서"]) == _bare(live) + and _j(got.get("위덮음") or {}) == _j(mcv.cover_of(live)) + and got["셈"]["계"] == m01doc.read(key)["셈"]["계"] + ) + + +def _drop_line(d): + del d["금액"][1] + + +def _cover(entry): + return lambda d: d.update({mcv.COVER: entry}) + + +EDITS = { + "옵션 선택": (CON, _opt("구조물", "철근구조물")), + "옵션 입력": (CON, _opt("소량감률", "20")), + "옵션 기계": (CUT, _opt("Type", "TypeⅢ")), + "줄 수량": (CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1")), + "줄 뺌": (CON, _drop_line), + "기계 값": (CUT, _cover({NO: {"값": {"가격": 200000}}})), + "작업량 방식": (CUT, _cover({SYM: {"작업량": {"방식": "시간당", "식": "GC001147"}}})), +} + + +@pytest.mark.parametrize("name", list(EDITS)) +def test_새_단가산출_있던_단가산출_따라옴(world, docs_tmp, name): + key, fn = EDITS[name] + me = world["personal"] + old = _sk(me, key) + was = m01doc.read(key)["셈"]["계"] + assert _is_base(_read(me, old), key) + _m01(key, fn) + assert m01doc.read(key)["셈"]["계"] != was # ㉠ 기초 셈이 바뀜 + assert _is_base(_read(me, _sk(me, key)), key) # ㉡ 새 단가산출 + assert _is_base(_read(me, old), key) # ㉢ 안 고친 단가산출 + + +def test_옵션_고름_지킴_알림_확인(world, docs_tmp): + me = world["personal"] + other, same, line = _sk(me, CON), _sk(me, CON), _sk(me, CON) + _edit_sk(me, other, _opt("타설방법", "장비사용타설")) + _edit_sk(me, same, _opt("지역", "서울")) + _edit_sk(me, line, lambda d: d["금액"][0].update(수량="(Q_콘크리트공) × 2")) + _m01(CON, _opt("지역", "경기")) + got = _read(me, other) # 다른 옵션을 고름 = 내 값 지킴 · 기초 옵션 따라옴 · 알림 없음 + assert (_val(got["문서"], "타설방법"), _val(got["문서"], "지역")) == ("장비사용타설", "경기") + assert got["사본"]["따로"] and got["사본"]["갱신"] == [] + got = _read(me, same) # 같은 옵션을 고름 = 내 값 지킴 + 알림 + assert _val(got["문서"], "지역") == "서울" + [note] = got["사본"]["갱신"] + assert (note["갈래"], note["처리"]) == ("문서", "지킴") + assert note["M01"] == ["지역 전국평균 → 경기"] and note["내고침"] == ["지역 서울"] + _at(me, path.save, same, {"할일": renew.CONFIRM, "판": got["판"]}) + after = _read(me, same) + assert after["사본"]["갱신"] == [] and _val(after["문서"], "지역") == "서울" + assert after["셈"]["계"] == got["셈"]["계"] + got = _read(me, line) # 줄 고침 + 옵션 기본 바뀜 = 줄 고침 지킴(다시 복사 아님) · 옵션 따라옴 + assert got["문서"]["금액"][0]["수량"] == "(Q_콘크리트공) × 2" + assert _val(got["문서"], "지역") == "경기" and got["사본"]["갱신"] == [] + + +def test_기초_줄_이름_따라옴(world, docs_tmp): + me = world["personal"] + key = _sk(me, CON) + _edit_sk(me, key, lambda d: d["금액"][1].update(수량="(Q_보통인부) × 2")) + _m01(CON, lambda d: [d["금액"][i].update(이름=f"848-10 이름 {i}") for i in (0, 1)]) + lines = _read(me, key)["문서"]["금액"] + assert lines[0]["이름"] == "848-10 이름 0" # 안 고친 줄 = 따라옴 + assert ( + lines[1]["이름"] == "보통인부" and lines[1]["수량"] == "(Q_보통인부) × 2" + ) # 고친 줄 = 내 것 + + +def _freeze(me, key): + with store.at(me): + here = refs.here() + ref = {"층": here[0], "주인": here[1], "키": key} + rows = source.labor_doc_rows( + {"이름": "t", "단위": "m", "담은로직": [{"참조": ref, "수량": {"손": 1}}]} + ) + bundle = source.price_bundle(rows, me) + return lambda: float(item_prices.calc(rows, bundle, {}, {})["반영합"]["계"]) + + +def test_프로젝트_사본(world, docs_tmp): + me = world["personal"] + key = _sk(me, CON) + before = _freeze(me, key) + was = before() + proj = me.parent / "p84810" / "templates" + (proj / "sangeun").mkdir(parents=True) + shutil.copy(me / "sangeun" / f"{key}.json", proj / "sangeun" / f"{key}.json") + in_proj = _read(proj, key) + _m01(CON, lambda d: d["금액"][0].update(수량="Q_콘크리트공 × 1.1")) + now = float(_read(me, key)["셈"]["계"]) + assert now != was + assert before() == was # 고치기 전 굳힌 것 = 그대로 + p = _read(proj, key) # 프로젝트 층 = 그대로 + assert p["셈"]["계"] == in_proj["셈"]["계"] and _bare(p["문서"]) == _bare(in_proj["문서"]) + assert _freeze(me, key)() == now # 고친 뒤 굳힘 = 그때 단가산출 금액 + + +def test_손고침_빌더_층바탕(world, docs_tmp): + _m01(CUT, _opt("Type", "TypeⅢ")) + saved = ml.load_all()[CUT] + assert saved.get(mcv.HAND) + files, whole = m01.loaded() + name = next( + n + for n, d in files.items() + if d.get("그룹") == "로직" and any(str(r.get("키")) == CUT for r in d.get("줄") or []) + ) + rows = files[name]["줄"] + keys = [str(r["키"]) for r in rows] + result = { + "문서": {str(r["키"]): cv.convert(whole, r)[0] for r in rows}, + "파일": {name: keys}, + "저장": set(keys) & build.saved_keys(), + "저장본": build.carried(), + } + file = ml.FOLDER / ml.file_of(name) + assert build.files_of(result)[ml.file_of(name)] == file.read_text(encoding="utf-8") + assert CUT in build.hand_kept(result) + me = world["personal"] + got = _read(me, _sk(me, CUT)) + assert _val(got["문서"], "Type") == "TypeⅢ" and set(got["층바탕"]) == {"위", "빌더"} + shown = _node( + {"문서": got["문서"], "위": got["층바탕"]["위"], "빌더": got["층바탕"]["빌더"], "고침": []} + )[0] + [(where, (kind, was, back))] = shown["표시"].items() # 기초에서 바꾼 옵션 = 위(주황) + assert (where, kind, was["연결"]["값"], back) == ("v:Type", "upper", "TypeⅠ", False) + assert shown["빠짐"] == {} and shown["줄틀"] == {} + + +def test_그룹째_뺀_줄_되살림_제_그룹(): + top = _j(ml.load_all()["GC000994"]) # 인력 · 크롤러드릴 · 공기압축기 · 크레인 그룹 + up = cp.deepcopy(top) + del up["금액"][4] # 공기압축기 그룹째 + got = _node({"문서": up, "위": up, "빌더": top, "고침": [{"꼴": "되살림", "항목": 2}]}) + doc = got[0]["문서"] + assert [x["이름"] for x in doc["금액"]] == [x["이름"] for x in top["금액"]] + heads = [(x.get("제목"), [y.get("이름") for y in x["줄"] if "금액" in y]) for x in doc["쌓기"]] + assert heads[2] == ("공기압축기 21㎥/min", ["공기압축기 21㎥/min"]) # 제 그룹 · 제 자리 + titles = ["인력", "크롤러드릴(공기식) 17㎥/min", "공기압축기 21㎥/min", "크레인"] + assert [h[0] for h in heads] == titles + assert got[0]["빠짐"] == {}