fix(848-10): M01 기초 고침이 M02 단가산출로 빠짐없이 — 옵션 기본 · 따로 문서 옵션 · 글 · 굳힌 사본 · 되살림 제 그룹
- 파생 문서 = 기초 문서 옵션 기본 위에 내가 고른 값만(옛 로직 줄 자동값이 기초 고침을 안 이김) · 층바탕 위 = 같은 기초 문서 - 따로 문서 · 끊음 — 기초가 옵션 기본 · 글만 바꿈 = 다시 복사 없음 · 안 고른 옵션 · 안 고친 줄 글 따라옴 · 고른 옵션 = 내 값 지킴 + 알림([확인] 까지) - 손고침 기초 · 굳히기 = `수식.바탕문서` 사본 → 굳힌 사본이 굳힐 때 단가산출 금액 · 프로젝트 층 = 굳은 뒤 기초 고침 안 받음(옛 칸 줄 고친 SK 빼고) - M01 옵션 가로 = 고칠 권한이면 기초 옵션 기본값(읽기 = 미리 보기 값) - 기초가 그룹째 뺀 줄 되살림 = 제 그룹(제목) · 제 자리 - 새 시험 test_848_10_upper_down(결과 — 새 · 있던 SK · 지킴 알림 · 글 · 굳힘 · 손고침 빌더 · 층바탕 · 되살림) - 옛 로직 줄 자동값 ≠ 기초 옵션 기본 200 장(금액 다름 109) = 새 SK 가 M01 기초와 같은 금액 · 저장된 SK 해당 0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -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 시간당 식 줄이 안 읽게 된 옵션 · 값은 그대로)
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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))
|
||||
|
||||
|
||||
|
||||
@@ -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]:
|
||||
|
||||
@@ -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 = {}
|
||||
|
||||
@@ -259,7 +259,8 @@ function setValue(d: StackDoc, id: string, was: ReturnType<typeof valueAt>): 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;
|
||||
}
|
||||
|
||||
@@ -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]["빠짐"] == {}
|
||||
Reference in New Issue
Block a user