Merge commit '3e0888610476700d939624ec4de36a2d1b78c540' into main_laptop_1
This commit is contained in:
@@ -13,7 +13,8 @@
|
||||
* M02 사본(`copy`) — 저장 몸 {문서, 끊음(받은 그대로), 판} · 판 바뀜(409)은 문서가 그대로면 새 판으로 한 번 더
|
||||
* 기계 줄 · 옵션 가로 기계 = 기계 창(827-1 · 836-1 찾기 · 바꾸기만) · 기계 내부 값 = 왼쪽 기계 제어 구역(836-1 ·
|
||||
* `line_stack_machine_ctl` — 문서 칸 `기계덮음` · 캐시 · [저장] 때 서버가 다시 셈)
|
||||
* 저장 전 문서(`memory` · 836-5 · 불러오기 미리 보기) = 빈 키 + 서버에 문서째(`본`) 읽음 · 왼쪽 줄 쌓기는 보기만(inert) · 디스크 쓰기 0
|
||||
* 저장 전 문서(`memory` · 836-5 · 불러오기 미리 보기) = 빈 키 + 서버에 문서째(`본`) 읽음 · 왼쪽 줄 쌓기는 보기만(inert) · 디스크 쓰기 0 ·
|
||||
* `memorySave` 있음(860-2 일위대가 초안 SK) = 고침 켬 · [저장] = 서버가 정본으로 다시 셈한 새 몸(`본`)을 부른 쪽에 · 디스크 쓰기 0
|
||||
* 층(848-3) — SK 읽기 · 미리 셈 답 `위덮음`(① 기초 고침) 을 셈 · 산출근거 · 제어 구역에 얹음(`layeredCover` · 화면 셈 = 서버 셈) ·
|
||||
* M01 기초 = 시스템 관리자에게 제어 구역 엶 · 머리 [초기화] = 그 기초 기계 고침 전부 걷고 저장(확인창 목록)
|
||||
* 바뀐 자리(848-8) — 읽기 답 `층바탕`(위 층 · 빌더 문서)과 칸 단위로 맞대 테두리 · 칸 · 줄 되돌림(`line_stack_diff.ts`)
|
||||
@@ -84,6 +85,8 @@ export interface StackScreenOptions {
|
||||
tools?: HTMLElement;
|
||||
/** 저장 전 SK 문서(836-5 · 불러오기 미리 보기) — 빈 키일 때 이 문서를 서버가 읽어 줌(파일 안 읽음 · 안 씀) */
|
||||
memory?: () => Record<string, unknown> | null;
|
||||
/** 860-2 저장 전 문서 고침 — [저장] 답 `본`(서버가 다시 셈한 새 몸)을 받음 · 없으면 저장 전 문서 = 보기만 */
|
||||
memorySave?: (doc: Record<string, unknown>) => void;
|
||||
/** 856-4 찾아 넣기 창(M01 · M02 = M02 `openFindPicker`) — 공용 화면은 M02 를 부르지 않음 */
|
||||
find: StackFind;
|
||||
/** 856-2 그릴 때마다 · 못 읽음 — 셈 답 · 사본 표지(M02 단가산출 머리 띠) */
|
||||
@@ -113,6 +116,8 @@ interface Loaded {
|
||||
위덮음?: Cover;
|
||||
/** 848-8 바뀐 자리 바탕 — 위 층 문서 · 빌더 문서(기초 손고침) */
|
||||
층바탕?: { 위?: StackDoc; 빌더?: StackDoc };
|
||||
/** 860-2 저장 전 문서 저장 답 — 새 몸 */
|
||||
본?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
|
||||
@@ -159,6 +164,7 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
const blocks = new Set<string>(); // 풀린 공식 묶음
|
||||
|
||||
const mem = (): Record<string, unknown> | null => (cp && !key ? (opt.memory?.() ?? null) : null);
|
||||
const frozen = (): boolean => !!mem() && !opt.memorySave; // 저장 전 문서 = 보기만(860-2 초안 = 고침)
|
||||
const call = async <T>(path: string, body?: unknown, signal?: AbortSignal): Promise<T> => {
|
||||
const saved = mem(); // 저장 전 문서 = 길 키 「-」 · 몸 `본`
|
||||
const r = await fetch(
|
||||
@@ -324,7 +330,7 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
: undefined;
|
||||
|
||||
// ── 그림 ──
|
||||
const edit = (): boolean => opt.admin && (!!key || !cp);
|
||||
const edit = (): boolean => opt.admin && (!!key || !cp || (!!mem() && !frozen()));
|
||||
/** 827-1 기계 창(찾기 · 바꾸기) — M01 기초 = M01 기계만 · 사본 줄 = 수식 길 `/machine` */
|
||||
const machineCtx = (): MachineCtx => ({
|
||||
scope: cp && opt.scope ? opt.scope : null,
|
||||
@@ -443,9 +449,9 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
]
|
||||
: []),
|
||||
);
|
||||
left.inert = !!mem(); // 저장 전 문서 = 보기만(고침은 저장 뒤)
|
||||
left.inert = frozen(); // 저장 전 문서 = 보기만(고침은 저장 뒤 · 860-2 초안 = 고침)
|
||||
if (layer?.위)
|
||||
applyDiff({ head, left, doc, items, up: layer.위, top: layer.빌더, edit: edit() && !mem(), change, name: (k) => cache.names.get(k) ?? "" }); // prettier-ignore
|
||||
applyDiff({ head, left, doc, items, up: layer.위, top: layer.빌더, edit: edit() && !frozen(), change, name: (k) => cache.names.get(k) ?? "" }); // prettier-ignore
|
||||
right.replaceChildren(
|
||||
items.length || doc.결과
|
||||
? buildOut(doc, answer, {
|
||||
@@ -545,6 +551,7 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
keep();
|
||||
recalc();
|
||||
draw();
|
||||
if (got.본 && mem()) opt.memorySave?.(got.본); // 860-2 초안 = 새 몸
|
||||
if (cp && got.판) cp.onSaved?.(got.판);
|
||||
if (done) showToast(done, "success");
|
||||
return true;
|
||||
|
||||
@@ -9,7 +9,9 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서}
|
||||
읽기 답 `사본.따라옴`(859-2) = 저장 뒤 M01 몫이 바뀌어 따라옴 지문(화면 토스트 한 번) · 같으면 null.
|
||||
가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음
|
||||
(형제 SK 는 셈 때 읽음) · 바탕 참조 SK = 값 사본 없음(400).
|
||||
저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`).
|
||||
저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`) ·
|
||||
일위대가 초안 줄(860-2) = 키 「-」 저장(`save` → `_save_memory`) = 서버가 다시 셈한 수식 사본을 얹은 새 `본`
|
||||
(디스크 쓰기 0 · 일위대가 [저장] 때 SK 로 만듦 · 새 내 기계 초안은 안 받음).
|
||||
위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② ·
|
||||
저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`).
|
||||
바뀐 자리 바탕(848-8) = 읽기 답 칸 `층바탕`(`layers` · 화면이 칸 단위로 맞대 테두리 · 칸 되돌림).
|
||||
@@ -255,13 +257,40 @@ def _basis(doc: dict, body: dict) -> dict:
|
||||
return {**doc, "가져온": {**doc["가져온"], "단가기준": want}}
|
||||
|
||||
|
||||
MEMORY = "-" # 저장 전 문서 길 키(836-5 · 860-2)
|
||||
|
||||
|
||||
def save(key: str, body: dict) -> dict[str, Any]:
|
||||
"""저장(층 쓰기) — 서버가 다시 셈한 사본을 그 SK 에 씀 · {문서, 부름, 끊음, 셈, 사본, 판} ·
|
||||
기계 창 초안(827-1) = 같은 요청 안에서 내 기계 만들기 · 고침 → 키 바꿈 → 저장(실패 = 되돌림)."""
|
||||
기계 창 초안(827-1) = 같은 요청 안에서 내 기계 만들기 · 고침 → 키 바꿈 → 저장(실패 = 되돌림) ·
|
||||
키 「-」 = 저장 전 문서(`_save_memory`)."""
|
||||
if key == MEMORY:
|
||||
return _save_memory(body)
|
||||
got = _file(key)
|
||||
if str(body.get("판") or "") != got["판"]:
|
||||
raise _bad({"stale": [key], "판": got["판"]}, 409)
|
||||
return draft.saving(body, lambda b: _save(key, b, got))
|
||||
out = draft.saving(body, lambda b: _save(key, b, got))
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
at = refs.here() # 860-2 ⑤ 이 SK 를 거쳐 쓰는 구조물 조합 일위대가 금액 = 새 값
|
||||
uses.refresh_labor({"층": at[0], "주인": at[1], "키": key})
|
||||
return out
|
||||
|
||||
|
||||
def _save_memory(body: dict) -> dict[str, Any]:
|
||||
"""일위대가 초안 SK(860-2) — 몸 `본` 에 화면 고침(문서 · 끊음)을 얹어 정본으로 다시 셈 → 읽기 꼴 +
|
||||
새 `본`(수식 사본 = 그 셈 · 위 층과 같아지면 파생) · 디스크 쓰기 0."""
|
||||
doc = _mem(body.get("본"))
|
||||
sent = body.get("문서")
|
||||
if isinstance(sent, dict) and draft.FIELD in sent:
|
||||
if draft.TAG.search(json.dumps({**sent, draft.FIELD: None}, ensure_ascii=False)):
|
||||
raise _bad("새 내 기계는 일위대가 [저장] 뒤 그 단가산출에서 만듦")
|
||||
body = {**body, "문서": {k: v for k, v in sent.items() if k != draft.FIELD}}
|
||||
key = str(doc.get("키") or MEMORY)
|
||||
mine = plain(edited(current(doc), body, key, doc), doc)
|
||||
new = {**_basis(doc, body), dsk.KEY: dsk.norm(mine)}
|
||||
return {**read_memory(new), "본": new}
|
||||
|
||||
|
||||
def machine(key: str, no: str) -> dict[str, Any]:
|
||||
|
||||
@@ -15,6 +15,8 @@
|
||||
참조 = `{층, 주인, 키}`(마스터 주인 null · 회사 `C` · 개인 `C/U`) — 종류는 키 머리(SP · SC · SK) ·
|
||||
위 층만 가리킴(개인 → 그 개인 · 그 회사 · 마스터 / 회사 → 그 회사 · 마스터 / 마스터 → 마스터) ·
|
||||
같은 참조 두 번 · 순환(422)은 저장 때 막음 · 계산 때도 깊이 상한(`DEPTH`)에서 멈추고 까닭.
|
||||
초안 줄(860-2 ③ ④) = `{층: 초안, 키: SK-초안n, 몸: SK 문서}` — 일위대가에 담은 저장 전 단가산출(화면 캐시에만 ·
|
||||
읽기 = 몸 · 셈만) · 일위대가 [저장] 때 SK 로 만들어 바꿔 낌(`M02_Labor_SkRow.write`).
|
||||
지우기 = 쓰는 곳(모든 층 일위대가 · 사전조합)이 있으면 409 · 층 사이 복사 = 대상 층이 못 읽는
|
||||
참조는 그 문서도 같이 복사(새 키 · `본뜬`) · 프로젝트 = 참조사본으로 굳힘(`frozen`).
|
||||
"""
|
||||
@@ -44,6 +46,8 @@ _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, 몸}
|
||||
DRAFT = "초안" # 860-2 저장 전 SK — 참조 꼴 {층: 초안, 주인: None, 키: SK-초안n, 몸}
|
||||
_DRAFT_KEY = re.compile(r"^SK-초안\d{1,4}$")
|
||||
|
||||
|
||||
def _bad(text: str, status: int = 400) -> store.StoreError:
|
||||
@@ -112,6 +116,11 @@ def is_copy(ref: Any) -> bool:
|
||||
return isinstance(ref, dict) and ref.get("층") == COPY and isinstance(ref.get("몸"), dict)
|
||||
|
||||
|
||||
def is_draft(ref: Any) -> bool:
|
||||
"""초안 줄(860-2) — 일위대가에 담은 저장 전 SK(몸 = SK 문서 · 파일 없음)."""
|
||||
return isinstance(ref, dict) and ref.get("층") == DRAFT and isinstance(ref.get("몸"), dict)
|
||||
|
||||
|
||||
def copy_ref(body: dict[str, Any], key: str) -> Ref:
|
||||
"""사본 블록 참조 — 몸(종류 · 이름 · 단위 · 담은로직 · 자재 · 본뜬) · 주인 = 몸 지문."""
|
||||
import hashlib
|
||||
@@ -131,7 +140,7 @@ SEEN: ContextVar[Callable[[Path], None] | None] = ContextVar("m02_refs_seen", de
|
||||
|
||||
|
||||
def read_ref(ref: Ref) -> dict[str, Any] | None:
|
||||
if is_copy(ref):
|
||||
if is_copy(ref) or is_draft(ref):
|
||||
return ref["몸"]
|
||||
try:
|
||||
path = ref_path(ref)
|
||||
@@ -146,7 +155,7 @@ 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: # 사본 블록 = 줄 안 몸(어느 층도 읽음)
|
||||
if ref.get("층") in (COPY, DRAFT): # 사본 블록 · 초안 = 줄 안 몸(어느 층도 읽음)
|
||||
return True
|
||||
if layer == "project":
|
||||
return False
|
||||
@@ -163,6 +172,8 @@ def check_ref(raw: Any, at: str, here_: Here) -> Ref:
|
||||
raise _bad(f"{at} · 참조는 {{층, 주인, 키}}")
|
||||
if raw.get("층") == COPY:
|
||||
return _check_copy(raw, at)
|
||||
if raw.get("층") == DRAFT:
|
||||
return _check_draft(raw, at, here_)
|
||||
layer, owner, key = raw.get("층"), raw.get("주인"), str(raw.get("키") or "")
|
||||
if layer == "system":
|
||||
owner = None
|
||||
@@ -192,6 +203,19 @@ def _check_copy(raw: Ref, at: str) -> Ref:
|
||||
return copy_ref(body, key)
|
||||
|
||||
|
||||
def _check_draft(raw: Ref, at: str, here_: Here) -> Ref:
|
||||
"""초안 줄 검사(860-2) — 키 꼴 · 몸 = SK 문서 · 몸이 가리키는 참조 = 이 층이 읽는 것만(셈이 남의 층을 안 읽게) ·
|
||||
프로젝트 층 = 안 받음(굳힌 사본만)."""
|
||||
body, key = raw.get("몸"), str(raw.get("키") or "")
|
||||
if here_[0] == "project" or not isinstance(body, dict) or not _DRAFT_KEY.match(key):
|
||||
raise _bad(f"{at} · 초안 줄은 {{층: 초안, 키: SK-초안n, 몸}}")
|
||||
if body.get("종류") not in (None, TITLE["sangeun"]):
|
||||
raise _bad(f"{at} · 초안 몸은 단가산출")
|
||||
for n, ref in enumerate(refs_in(body), start=1):
|
||||
check_ref(ref, f"{at} · 초안 참조 {n}째", here_)
|
||||
return {"층": DRAFT, "주인": None, "키": key, "몸": body}
|
||||
|
||||
|
||||
# ── 서고 문서 정리 ─────────────────────────────────────────────────────
|
||||
def check_key(kind: str, name: str) -> None:
|
||||
found = _KEY.match(name)
|
||||
@@ -369,7 +393,7 @@ def summary(
|
||||
out["안이은줄"] = sum(
|
||||
1 for x in fixes if not x.get("비율") and not any((x.get("이음") or {}).values())
|
||||
)
|
||||
# 717-2a 목록 열 — 바탕(로직 「키 이름」 | 참조 키 | None) · 고친 줄 수 · 쓰는 곳 수
|
||||
# 717-2a 목록 열 — 바탕(로직 「키 이름」 | 참조 키 | None) · 고친 칸 수(860-2 ②) · 쓰는 곳 수
|
||||
if kind == "sangeun":
|
||||
top, (layer, owner) = doc.get("바탕") or {}, where(folder)
|
||||
logic = top.get("로직")
|
||||
@@ -379,7 +403,9 @@ def summary(
|
||||
|
||||
name = (m01doc.docs().get(str(logic)) or {}).get("이름") or ""
|
||||
out["바탕"] = f"{logic} {name}".strip() # 없는 기초 = 키만(셈 때 까닭)
|
||||
out["고친줄수"] = sum(len(doc.get(k) or ()) for k in ("덮개", "더한줄", "뺀줄"))
|
||||
from M02_MasterTemplete import M02_Sk_EditCount as edit_count
|
||||
|
||||
out["고친칸수"] = edit_count.of_sk(doc) # 줄 쌓기 파란 테두리 칸 수(860-2 ②)
|
||||
# SK 마다 모든 층 훑음 — 파일 읽기는 판 기억(`M02_Library_Uses.ids_of`)이라 처음 한 번만 무거움
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
|
||||
@@ -9,6 +9,10 @@ M01 로직 줄(옛 저장본 · 740-1 로 펼쳐 담은 줄) → 그 층 SK 문
|
||||
자재표시 빈 재료 = 일위대가 기본(별도계상)을 적어 둠(SK 빈 칸 = 직접계산이라 금액이 바뀜) ·
|
||||
사본 · 수식 = 그 일위대가 것을 실어 보냄(같은 값 묶음 · M01 이 바뀌었어도 금액 그대로)
|
||||
옛 로직 줄 → SK 참조 옮기기(한 번용 `migrate`)는 끝나 걷음(894) — 남은 것 = [+ 줄] M01 기초 SK 사본.
|
||||
860-2 ③ ④(요구 910) — [항목 추가] 로 담은 SK 는 일위대가 [저장] 때 만듦:
|
||||
담기 = `draft`(디스크 쓰기 0 · 답 = 초안 몸 | 같은 내용 「그것을 씀」 참조) · 화면 = 초안 줄(`refs.DRAFT`) ·
|
||||
[저장] = `write`(한 잠금 안에서 초안마다 SK 새 키 → 줄 참조 · 규격 열 수량 열쇠 바꿔 낌 → 일위대가 저장 ·
|
||||
중간 실패 = 만든 SK 지움 · 번호 장부 되돌림 → 아무것도 안 남음).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
@@ -49,18 +53,90 @@ def logic_doc(one: dict, doc: dict, whole: Any) -> dict[str, Any]:
|
||||
return {**sk, **{k: doc[k] for k in CARRY if doc.get(k)}}
|
||||
|
||||
|
||||
def from_logic(code: Any, new: bool = False, use: str | None = None) -> dict[str, Any]:
|
||||
"""[+ 줄] M01 기초 고름 — 지금 층에 SK 사본(같은 내용 = 409 물음 · 733-2) → `{이름: SK 키, 참조}`."""
|
||||
# ── 860-2 초안 — 담을 때 안 만듦 · 일위대가 [저장] 때 만듦 ─────────────────────
|
||||
NO_KEY = "SK-000000" # 초안 몸 키 — 어느 층도 안 내는 번호(파일 없음 · 저장 때 새 키)
|
||||
|
||||
|
||||
def _body(sk: dict[str, Any]) -> dict[str, Any]:
|
||||
"""저장될 꼴 SK 몸(수식 사본 포함 · 키 = `NO_KEY`) — 셈 · 줄 쌓기가 파일 없이 읽음(디스크 쓰기 0)."""
|
||||
return refs.clean_doc("sangeun", {**sk, "키": NO_KEY})
|
||||
|
||||
|
||||
def draft(
|
||||
code: Any = None,
|
||||
src: dict[str, Any] | None = None,
|
||||
new: bool = False,
|
||||
use: str | None = None,
|
||||
) -> dict[str, Any]:
|
||||
"""[항목 추가] 담기 — `code` = M01 기초(같은 내용 SK 있으면 409 물음 · 씀 = 그 참조) ·
|
||||
`src` = 다른 층 SK(읽기 권한은 부르는 쪽) → `{초안: 몸}` | `{참조}` ·
|
||||
위 층 아닌 SK = 그 안 참조도 같이 복사해야 해 옛 길대로 바로 사본."""
|
||||
from M02_MasterTemplete import M02_Library_Ask as ask
|
||||
|
||||
at = refs.here()
|
||||
if src is not None:
|
||||
doc = refs.read_ref(src)
|
||||
if doc is None:
|
||||
raise store.StoreError(404, f"없는 단가산출 「{src.get('키')}」")
|
||||
if not refs.readable(at, src):
|
||||
body = refs.carry(refs.origin_mark(doc, src), (src["층"], src.get("주인")))
|
||||
key = refs.create("sangeun", body)["이름"]
|
||||
return {"참조": {"층": at[0], "주인": at[1], "키": key}}
|
||||
return {"초안": _body(refs.origin_mark(doc, src))}
|
||||
from M01_MasterData import M01_MasterData_Doc as m01doc
|
||||
|
||||
whole = _whole()
|
||||
try:
|
||||
m01doc.head(str(code))
|
||||
except Exception as e: # noqa: BLE001 — 없는 로직
|
||||
raise store.StoreError(400, f"없는 기초 「{code}」") from e
|
||||
sk = logic_doc({"로직": str(code), "입력값": {}}, {}, whole)
|
||||
key = ask.ask("sangeun", sk, new, use) or refs.create("sangeun", sk)["이름"]
|
||||
sk = logic_doc({"로직": str(code), "입력값": {}}, {}, _whole())
|
||||
if key := ask.ask("sangeun", sk, new, use):
|
||||
return {"참조": {"층": at[0], "주인": at[1], "키": key}}
|
||||
return {"초안": _body(sk)}
|
||||
|
||||
|
||||
def _keyed(body: dict[str, Any], key: str) -> dict[str, Any]:
|
||||
"""초안 몸의 수식 사본 문서 키(저장 전 `NO_KEY`) = 새 SK 키."""
|
||||
copy = body.get("수식")
|
||||
if not isinstance(copy, dict):
|
||||
return body
|
||||
copy = {**copy}
|
||||
for part in ("문서", "처음"):
|
||||
if isinstance(copy.get(part), dict):
|
||||
copy[part] = {**copy[part], "키": key}
|
||||
return {**body, "수식": copy}
|
||||
|
||||
|
||||
def write(kind: str, name: str, version: str, doc: Any, screen: bool = False) -> dict[str, Any]:
|
||||
"""일위대가 · 구조물 조합 일위대가 저장(`store.write`) — 초안 줄이 있으면 한 잠금 안에서 SK 로 만들어
|
||||
바꿔 낀 뒤 저장 · 실패 = 만든 SK 지움 · 번호 장부 되돌림(아무것도 안 남음)."""
|
||||
lines = doc.get("담은로직") if kind in ("labor", "precombo") and isinstance(doc, dict) else None
|
||||
drafts = [
|
||||
one for one in lines or [] if isinstance(one, dict) and refs.is_draft(one.get("참조"))
|
||||
]
|
||||
if not drafts:
|
||||
return store.write(kind, name, version, doc, screen)
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
|
||||
at = refs.here()
|
||||
return {"이름": key, "참조": {"층": at[0], "주인": at[1], "키": key}}
|
||||
with store.batch():
|
||||
book, made, done = refs.issued(), [], {}
|
||||
try:
|
||||
for one in drafts:
|
||||
old = refs.check_ref(one["참조"], "초안 줄", at)
|
||||
key = refs.next_key("sangeun")
|
||||
body = _keyed({k: v for k, v in old["몸"].items() if k != "키"}, key)
|
||||
made.append(refs.create("sangeun", body)["이름"])
|
||||
done[refs.ref_id(old)] = {"층": at[0], "주인": at[1], "키": made[-1]}
|
||||
fresh = [
|
||||
{**one, "참조": done[refs.ref_id(one["참조"])]} if one in drafts else one
|
||||
for one in lines
|
||||
]
|
||||
fresh = refs._spec_moved({**doc, "담은로직": fresh}, done)
|
||||
return store.write(kind, name, version, fresh, screen)
|
||||
except BaseException:
|
||||
for key in made:
|
||||
(store.root() / "sangeun" / f"{key}.json").unlink(missing_ok=True)
|
||||
if made:
|
||||
atomic_write_json(store.root() / refs.ISSUED, book)
|
||||
raise
|
||||
|
||||
@@ -172,7 +172,7 @@ def summaries(folder: str | Path, rows: list[dict[str, Any]]) -> None:
|
||||
row.update(recs[name]["요약"])
|
||||
if dirty:
|
||||
_save(key, recs)
|
||||
sk = [row for row in lib if row["종류"] == "sangeun" and "고친줄수" in row]
|
||||
sk = [row for row in lib if row["종류"] == "sangeun" and "고친칸수" in row]
|
||||
if sk:
|
||||
from M02_MasterTemplete import M02_Library_Uses as library_uses
|
||||
|
||||
|
||||
@@ -5,7 +5,8 @@
|
||||
파일마다 (이름, 참조 이름표들) 을 판(고친 때 · 크기)으로 기억(`ids_of` · 818-1) — 같은 판이면 안 엶 ·
|
||||
기억은 파생 저장본 `_derived/m02_layer_index/ids.json` 에도 둠(서버를 다시 띄워도 처음부터 안 읽음 ·
|
||||
지워도 다시 셈) · `users` = 「무엇 어디 「이름」」 목록 · `index` = {이름표: [(파일, 종류, 글)]} ·
|
||||
`counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409.
|
||||
`counts` = {이름표: 파일 수}(목록 쓰는곳수) · `refuse_used` = 쓰는 곳 있으면 409 ·
|
||||
`refresh_labor` = 그 문서를 바로 · 거쳐 쓰는 구조물 조합 일위대가 계산값 다시 적음(860-2 ⑤ — 표 「일위대가 금액」).
|
||||
자원 키 찾기(층 안):
|
||||
`machines` = 내 기계 키 → 이 층 단가산출(사본 · 수식 사본 단가 줄에 그 키) ·
|
||||
`materials` = 내 재료 키 → 이 층 모든 문서(글에 그 키 · `_` `.` 폴더 · 내 재료 파일 뺌).
|
||||
@@ -100,6 +101,27 @@ def refuse_used(folder: Path, kind: str, key: str) -> None:
|
||||
raise store.StoreError(409, f"쓰는 곳이 있어 못 지움 「{key}」 — " + " · ".join(found))
|
||||
|
||||
|
||||
def refresh_labor(ref: refs.Ref) -> list[Path]:
|
||||
"""`ref`(SC · SK) 저장 뒤 — 그것을 바로 · 일위대가 · 단가산출을 거쳐 쓰는 구조물 조합 일위대가(`labor`)의
|
||||
`계산값`(조합 표 「일위대가 금액」)을 그 층에서 다시 적음(`store._refresh_labor`) · 다시 적은 파일."""
|
||||
found, seen, todo, out = index(), set(), [refs.ref_id(ref)], []
|
||||
while todo:
|
||||
rid = todo.pop()
|
||||
if rid in seen:
|
||||
continue
|
||||
seen.add(rid)
|
||||
for path, kind, _ in found.get(rid, []):
|
||||
if kind == "labor":
|
||||
out.append(path)
|
||||
continue
|
||||
layer, owner = refs.where(path.parent.parent)
|
||||
todo.append(refs.ref_id({"층": layer, "주인": owner, "키": path.stem}))
|
||||
for path in dict.fromkeys(out):
|
||||
with store.at(path.parent.parent):
|
||||
store._refresh_labor(path.stem)
|
||||
return list(dict.fromkeys(out))
|
||||
|
||||
|
||||
def _load() -> None:
|
||||
"""기억을 파생 저장본에서 채움 — 프로세스에 한 번 · 판은 `ids_of` 가 다시 봄."""
|
||||
if _LOADED:
|
||||
|
||||
@@ -50,6 +50,8 @@ export interface LaborDetailHandle {
|
||||
/** [엑셀에서 고르기]로 바뀐 면적산출 문서를 저장(일위대가 [저장] 앞) · 저장했으면 참(없으면 거짓) —
|
||||
* 서버가 면적 저장 때 그 열 일위대가 계산값을 다시 적어 일위대가 판이 바뀜 → 부르는 쪽이 판을 다시 읽음 */
|
||||
saveArea: () => Promise<boolean>;
|
||||
/** [저장] 앞 필수 칸(860-2 ① · 일위대가 서고 = 이름 · 줄 있으면 단위) — 빈 칸이면 초점 · 칸 글 · 까닭(없으면 null) */
|
||||
check: () => string | null;
|
||||
destroy: () => void;
|
||||
}
|
||||
|
||||
|
||||
@@ -72,14 +72,17 @@ export async function openRefEdit(opt: RefEditOptions): Promise<void> {
|
||||
const ok = createButton({
|
||||
label: tc("Save"),
|
||||
variant: "filled",
|
||||
onClick: () =>
|
||||
onClick: () => {
|
||||
const need = handle?.check(); // 860-2 ① 빈 이름 · 단위 = 안 보냄 · 줄 그대로
|
||||
if (need) return void showToast(`${tc("Lib_SaveFailed")} — ${need}`, "error");
|
||||
void save(handle?.getDoc()).then(
|
||||
() => {
|
||||
close();
|
||||
finish();
|
||||
},
|
||||
(error) => fail(error, "Lib_SaveFailed"),
|
||||
),
|
||||
);
|
||||
},
|
||||
});
|
||||
body.append(
|
||||
el("p", {
|
||||
|
||||
@@ -7,6 +7,8 @@
|
||||
* · 머리(808-1 · 요구 701-4 · 5) = 단가산출 페이지 머리와 같음 — 보기 고르기 · [단가 갱신] · [재생성] · [저장] · [닫기]
|
||||
* · 프로젝트 사본(856-3 · `copy`) = 사본의 굳힌 SK 문서째 줄 쌓기 보기만(`memory` · 파일 안 읽음 · 저장 없음) ·
|
||||
* 고침은 M02 단가산출에서 고쳐 [재생성](요구 898 ①)
|
||||
* · 초안 줄(860-2 · `draft`) = 저장 전 SK 몸째 줄 쌓기(파일 안 읽음) · [저장] = 서버가 다시 셈한 몸을 그 줄에(`keep`) ·
|
||||
* SK 파일은 일위대가 [저장] 때
|
||||
* 짝 모달 = `Labor_RefEdit`(일위조합 SC 줄).
|
||||
* ========================================================================== */
|
||||
|
||||
@@ -15,6 +17,7 @@ import { openModal } from "@ui/ui_template_modal";
|
||||
import { createText } from "@ui/ui_template_text";
|
||||
import { readTemplate, saveTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import type { DraftRef } from "./M02_MasterTemplete_Labor_SkPick";
|
||||
import { tc } from "./M02_MasterTemplete_Labor_Text";
|
||||
import { mountSangeunDetail } from "./M02_MasterTemplete_Sangeun_Detail";
|
||||
|
||||
@@ -27,6 +30,8 @@ export interface SkEditOptions {
|
||||
readOnly: boolean;
|
||||
/** 프로젝트 사본(856-3) — 그 사본의 굳힌 SK 문서(있으면 보기만 · 파일 안 읽음) */
|
||||
copy?: Record<string, unknown>;
|
||||
/** 초안 줄(860-2) — 그 일위대가 층 · 주인(셈 길) · 고친 몸 받기(`ref` = 초안 참조) */
|
||||
draft?: { layer: Layer; owner: string | null; keep: (doc: Record<string, unknown>) => void };
|
||||
/** 닫힘 — `saved` = 그 SK 문서를 저장함(부르는 쪽이 금액을 다시 셈) */
|
||||
closed: (saved: boolean) => void;
|
||||
}
|
||||
@@ -39,16 +44,18 @@ export const isSkRef = (ref: LaborRef | undefined): ref is LaborRef =>
|
||||
const opened = new Set<string>();
|
||||
|
||||
export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
const layer = opt.ref.층 as Layer;
|
||||
const at = `${layer}/${opt.ref.주인 ?? ""}/${opt.ref.키}`;
|
||||
const draft = opt.draft;
|
||||
const layer = draft ? draft.layer : (opt.ref.층 as Layer);
|
||||
const owner = draft ? draft.owner : opt.ref.주인;
|
||||
const at = `${opt.ref.층}/${opt.ref.주인 ?? ""}/${opt.ref.키}`;
|
||||
if (opened.has(at)) return;
|
||||
opened.add(at);
|
||||
const copy = !!opt.copy;
|
||||
const readOnly = copy || opt.readOnly;
|
||||
let doc: unknown = opt.copy;
|
||||
let doc: unknown = draft ? (opt.ref as DraftRef).몸 : opt.copy;
|
||||
let version = "";
|
||||
try {
|
||||
if (!copy) {
|
||||
if (!copy && !draft) {
|
||||
const got = await readTemplate(layer, "sangeun", opt.ref.키, null, opt.ref.주인);
|
||||
doc = got.문서;
|
||||
version = got.판 ?? "";
|
||||
@@ -82,11 +89,11 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
handle = mountSangeunDetail(host, doc, {
|
||||
// 사본 = 층 읽기 길(굳힌 문서째 셈 · 주인 층 권한 없이)
|
||||
layer: copy ? "system" : layer,
|
||||
owner: copy ? null : opt.ref.주인,
|
||||
owner: copy ? null : owner,
|
||||
readOnly,
|
||||
onChanged: (d) => (dirty = d && !readOnly),
|
||||
onVersion: (v) => (version = v), // 수식 저장이 파일 판을 바꿈 — 문서 저장이 이어 받음
|
||||
mode: copy ? "memory" : "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
mode: copy ? "memory" : draft ? "draft" : "page", // 페이지와 같은 길 — 수식 저장 단추는 이 [저장] 한 번에 모임
|
||||
slot,
|
||||
});
|
||||
const ok = createButton({
|
||||
@@ -97,6 +104,13 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
if (!handle) return;
|
||||
try {
|
||||
await handle.flush();
|
||||
if (draft) {
|
||||
draft.keep(handle.getDoc() as Record<string, unknown>); // 860-2 SK 파일은 일위대가 [저장] 때
|
||||
saved = true;
|
||||
showToast(tc("Draft_Kept"), "success");
|
||||
close();
|
||||
return finish();
|
||||
}
|
||||
await saveTemplate(
|
||||
layer,
|
||||
"sangeun",
|
||||
@@ -121,9 +135,11 @@ export async function openSkEdit(opt: SkEditOptions): Promise<void> {
|
||||
createText(
|
||||
copy
|
||||
? tc("Ref_Copy")
|
||||
: opt.readOnly
|
||||
? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}`
|
||||
: tc("Ref_Shared"),
|
||||
: draft
|
||||
? tc("Draft_Hint")
|
||||
: opt.readOnly
|
||||
? `${tc("Ref_Shared")} · ${tc("Ref_ReadOnly")}`
|
||||
: tc("Ref_Shared"),
|
||||
"hint",
|
||||
),
|
||||
host,
|
||||
|
||||
@@ -1,13 +1,15 @@
|
||||
/* =============================================================================
|
||||
* M02_MasterTemplete_Labor_SkPick.ts
|
||||
* 일위대가 [+ 줄] 단가산출 = 그 층 SK 참조 한 행(PLAN 811-1 · 요구 707-1 · 681) — 일위대가 표(`Labor_Table`)가 부름.
|
||||
* · M01 기초 고름 = 그 층에 SK 사본을 만듦(`POST …/sangeun/from-logic` · 같은 내용 SK 있으면 물음 = 그것을 씀 · 그래도 새로)
|
||||
* · M02 단가산출 고름 = 같은 층 · 같은 주인 = 그대로 참조 · 다른 층(위 층 = 읽기 전용) = 이 층에 사본(`newLibrary` 본뜬) 뒤 참조
|
||||
* · 답 = 넣을 참조 {층, 주인, 키} · 취소 = null(일위대가 문서는 화면 [저장] 때 바뀜)
|
||||
* 일위대가 [항목 추가] 단가산출 = 그 층 SK 참조 한 행(PLAN 811-1 · 요구 707-1 · 681) — 일위대가 표(`Labor_Table`)가 부름.
|
||||
* · 860-2(요구 910) 담기 = 초안(`POST …/sangeun/draft` · 서버에 파일 안 만듦) — 답 `{초안: SK 몸}` →
|
||||
* 초안 줄 `{층: 초안, 키: SK-초안n, 몸}`(화면 캐시에만) · 일위대가 [저장] 때 서버가 SK 로 만들어 바꿔 낌
|
||||
* · M01 기초 고름 = 초안(같은 내용 SK 있으면 물음 = 그것을 씀 → 있는 SK 참조 · 그래도 새로 → 초안)
|
||||
* · M02 단가산출 고름 = 같은 층 · 같은 주인 = 그대로 참조 · 위 층 = 초안 · 그 밖 층 = 서버가 바로 사본(옛 길 · 안 참조 같이 복사)
|
||||
* · 답 = 넣을 것 `{참조}` | `{초안}` · 취소 = null
|
||||
* ========================================================================== */
|
||||
|
||||
import { fetchSessionUser } from "../A06_Login/A06_Login_Api_Fetch";
|
||||
import { call, newLibrary, type Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
|
||||
import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
|
||||
import { withSameAsk } from "./M02_MasterTemplete_Library_SameAsk";
|
||||
|
||||
@@ -16,19 +18,32 @@ export interface SkPickScope {
|
||||
owner: string | null;
|
||||
}
|
||||
|
||||
/** 초안 줄 참조(860-2) — 저장 전 SK 몸을 줄 안에(서버 `M02_Labor_Ref.DRAFT`) */
|
||||
export const DRAFT = "초안";
|
||||
export type DraftRef = LaborRef & { 몸: Record<string, unknown> };
|
||||
export const isDraft = (ref: LaborRef | null | undefined): ref is DraftRef =>
|
||||
!!ref && ref.층 === DRAFT && !!(ref as Partial<DraftRef>).몸;
|
||||
|
||||
/** 담기 답 — 있는 SK 참조 | 초안 몸 */
|
||||
export interface SkTaken {
|
||||
참조?: LaborRef;
|
||||
초안?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
const q = (s: SkPickScope): string =>
|
||||
s.owner && s.layer !== "system" ? `?owner=${encodeURIComponent(s.owner)}` : "";
|
||||
|
||||
/** M01 기초 → 이 층 SK 사본 참조 */
|
||||
export const skFromLogic = async (s: SkPickScope, code: string): Promise<LaborRef | null> =>
|
||||
(
|
||||
await withSameAsk((extra) =>
|
||||
call<{ 이름: string; 참조: LaborRef }>(`/layers/${s.layer}/sangeun/from-logic${q(s)}`, {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ 로직: code, ...extra }),
|
||||
}),
|
||||
)
|
||||
)?.참조 ?? null;
|
||||
const take = (s: SkPickScope, body: Record<string, unknown>): Promise<SkTaken | null> =>
|
||||
withSameAsk((extra) =>
|
||||
call<SkTaken>(`/layers/${s.layer}/sangeun/draft${q(s)}`, {
|
||||
method: "POST",
|
||||
body: JSON.stringify({ ...body, ...extra }),
|
||||
}),
|
||||
);
|
||||
|
||||
/** M01 기초 → 초안 몸(같은 내용 SK 「그것을 씀」 = 그 참조) */
|
||||
export const skFromLogic = (s: SkPickScope, code: string): Promise<SkTaken | null> =>
|
||||
take(s, { 로직: code });
|
||||
|
||||
/** 이 층 주인 — 주인 null = 로그인 사용자 자기 층(회사 「C」 · 개인 「C/U」 · 서버 참조 꼴) */
|
||||
async function ownerOf(s: SkPickScope): Promise<string | null> {
|
||||
@@ -38,11 +53,9 @@ async function ownerOf(s: SkPickScope): Promise<string | null> {
|
||||
return s.layer === "company" ? String(me.company_id) : `${me.company_id}/${me.id}`;
|
||||
}
|
||||
|
||||
/** 고른 SK — 이 층 것이면 그대로 · 다른 층이면 이 층 사본 */
|
||||
export async function ownSk(s: SkPickScope, ref: LaborRef): Promise<LaborRef> {
|
||||
/** 고른 SK — 이 층 것이면 그대로 · 다른 층이면 초안(위 층) · 바로 사본(그 밖) */
|
||||
export async function ownSk(s: SkPickScope, ref: LaborRef): Promise<SkTaken | null> {
|
||||
const owner = await ownerOf(s);
|
||||
if (ref.층 === s.layer && (ref.주인 ?? null) === owner) return ref;
|
||||
const 본뜬 = { ...ref, 층: ref.층 as Layer };
|
||||
const got = await newLibrary(s.layer, "sangeun", { 본뜬 }, s.owner);
|
||||
return { 층: s.layer, 주인: owner, 키: got.이름 };
|
||||
if (ref.층 === s.layer && (ref.주인 ?? null) === owner) return { 참조: ref };
|
||||
return take(s, { 본뜬: ref });
|
||||
}
|
||||
|
||||
@@ -17,6 +17,8 @@
|
||||
* 새 줄 수량 = 면적을 따름(빈 값). 단가산출(SK) 참조 줄 누름 = 그 단가산출 문서 모달(`Labor_SkEdit` — 수식 탭 · 저장 = 그 SK).
|
||||
* 811-1(요구 707-1) — 단가산출 줄 = SK 참조 한 행(저장 때 안 펼침) · [로직 추가] M01 기초 = 이 층 SK 사본 · 다른 층 SK =
|
||||
* 이 층 사본 뒤 참조(`Labor_SkPick`) · 프로젝트 · 셈 주입 표 = 늘 보기만이라 [로직 추가] 없음(856-3).
|
||||
* 860-2(요구 910) — 담은 SK = 초안 줄(화면 캐시에만 · 서버 파일 없음) · 줄 누름 = 저장 전 줄 쌓기(고친 값 = 초안 몸) ·
|
||||
* 일위대가 [저장] 때 서버가 SK 로 만듦 · 조합 갈래 초안 줄 = 면적 알약 잇기는 저장 뒤(알약 열쇠가 바뀜).
|
||||
* ========================================================================== */
|
||||
|
||||
import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
|
||||
@@ -44,7 +46,15 @@ import { tipBorn } from "./M02_MasterTemplete_Labor_Born";
|
||||
import { nationalRows } from "./M02_MasterTemplete_Labor_National";
|
||||
import { createCombo, diagramBox } from "./M02_MasterTemplete_Labor_Combo";
|
||||
import { isSkRef, openSkEdit } from "./M02_MasterTemplete_Labor_SkEdit";
|
||||
import { ownSk, skFromLogic, type SkPickScope } from "./M02_MasterTemplete_Labor_SkPick";
|
||||
import {
|
||||
DRAFT,
|
||||
isDraft,
|
||||
ownSk,
|
||||
skFromLogic,
|
||||
type DraftRef,
|
||||
type SkPickScope,
|
||||
type SkTaken,
|
||||
} from "./M02_MasterTemplete_Labor_SkPick";
|
||||
import { specBar, specCells } from "./M02_MasterTemplete_Labor_Spec";
|
||||
import { unlinkedBar } from "./M02_MasterTemplete_Labor_Unlinked";
|
||||
import { pasteInto } from "./M02_MasterTemplete_Labor_Paste";
|
||||
@@ -247,7 +257,8 @@ export function mountLaborTable(
|
||||
: await calcLabor(opt.layer, opt.column, cur, qty, opt.owner);
|
||||
if (!alive || mine !== seq) return;
|
||||
calc = last = got;
|
||||
combo?.setPills(got.알약 as { 키: string; 이름?: string; 단위?: string }[]);
|
||||
const pills = got.알약 as { 키: string; 이름?: string; 단위?: string }[];
|
||||
combo?.setPills(pills.filter((p) => !p.키.startsWith(`참조|${DRAFT}|`))); // 860-2 초안 = 저장 뒤 잇기
|
||||
} catch (error) {
|
||||
if (!alive || mine !== seq) return;
|
||||
fail = error instanceof Error ? error.message : tc("Labor_Calc_Fail");
|
||||
@@ -309,6 +320,7 @@ export function mountLaborTable(
|
||||
const have = calc ?? last;
|
||||
const mat = cur.자재[n - cur.담은로직.length];
|
||||
const row = cur.담은로직[n];
|
||||
if (isDraft(row?.참조)) return showToast(tc("Draft_LinkLater"), "info"); // 860-2 알약 열쇠 = 저장 뒤
|
||||
if (row)
|
||||
combo?.openQty(nameOf(row), row, lineOf(row), lineOf(row)?.분모 ?? "", () => changed(true));
|
||||
else if (mat)
|
||||
@@ -341,8 +353,12 @@ export function mountLaborTable(
|
||||
ref,
|
||||
title: nameOf(row),
|
||||
head: head(),
|
||||
readOnly: !edit || ref.층 !== opt.layer,
|
||||
readOnly: !edit || (ref.층 !== opt.layer && !isDraft(ref)),
|
||||
closed: (done: boolean) => alive && done && recalc(), // 저장했으면 금액을 다시 셈
|
||||
// 860-2 초안 = 저장 전 문서 고침 → 그 줄 몸(일위대가 [저장] 때 SK 로)
|
||||
...(isDraft(ref) && own
|
||||
? { draft: { ...own, keep: (doc: Record<string, unknown>) => keepDraft(ref, doc) } }
|
||||
: {}),
|
||||
};
|
||||
// 단가산출(SK) 줄 = 그 단가산출 문서 줄 쌓기(806-1) · 프로젝트 사본 = 굳힌 문서 보기만(856-3)
|
||||
if (!opt.skCopy) return void openSkEdit(sk);
|
||||
@@ -403,6 +419,23 @@ export function mountLaborTable(
|
||||
changed();
|
||||
}
|
||||
|
||||
/** 860-2 초안 줄 몸 갈아 끼움(줄 쌓기 [저장] = 서버가 다시 셈한 몸) */
|
||||
function keepDraft(ref: DraftRef, doc: Record<string, unknown>): void {
|
||||
const row = cur.담은로직.find((r) => r.참조?.키 === ref.키 && isDraft(r.참조));
|
||||
if (!row) return;
|
||||
row.참조 = { ...ref, 몸: doc } as DraftRef;
|
||||
opt.onChanged(dirty());
|
||||
}
|
||||
/** 담기 답 → 줄(있는 SK 참조 | 초안 줄 · 초안 키 = 이 문서에서 안 쓴 「SK-초안n」) */
|
||||
function addTaken(got: SkTaken | null, name: string, 별칭: string | null): void {
|
||||
if (!got || !alive) return;
|
||||
if (got.참조) return addRef(got.참조, name, 별칭);
|
||||
if (!got.초안) return;
|
||||
const used = new Set(cur.담은로직.map((r) => r.참조?.키));
|
||||
let n = 1;
|
||||
while (used.has(`SK-초안${n}`)) n += 1;
|
||||
addRef({ 층: DRAFT, 주인: null, 키: `SK-초안${n}`, 몸: got.초안 } as DraftRef, name, 별칭);
|
||||
}
|
||||
function addRef(ref: LaborRef, name: string, 별칭: string | null): void {
|
||||
const id = lineId({ 참조: ref });
|
||||
if (cur.담은로직.some((r) => lineId(r) === id))
|
||||
@@ -424,7 +457,7 @@ export function mountLaborTable(
|
||||
: null,
|
||||
pick: (ref: LaborRef, name: string, 별칭: string | null = null) =>
|
||||
own && isSkRef(ref) // 811-1 — 다른 층 SK = 이 층 사본 뒤 참조
|
||||
? void ownSk(own, ref).then((r) => alive && addRef(r, name, 별칭), failed)
|
||||
? void ownSk(own, ref).then((r) => addTaken(r, name, 별칭), failed)
|
||||
: addRef(ref, name, 별칭),
|
||||
fixed: (fx: LaborFixed, name: string) => {
|
||||
const id = lineId({ 고정: fx });
|
||||
@@ -463,12 +496,14 @@ export function mountLaborTable(
|
||||
variant: "filled",
|
||||
onClick: () =>
|
||||
openLogicPicker((x) => {
|
||||
// 811-1 — M01 기초 = 이 층 SK 사본 참조 한 행(펼치지 않음)
|
||||
if (own)
|
||||
void skFromLogic(own, x.키).then(
|
||||
(r) => r && alive && addRef(r, x.이름 || x.키, null),
|
||||
failed,
|
||||
);
|
||||
// 811-1 — M01 기초 = 이 층 SK 참조 한 행(펼치지 않음) · 860-2 초안(저장 때 만듦) · 같은 기초 초안 = 한 번
|
||||
const name = x.이름 || x.키;
|
||||
const twice = cur.담은로직.some(
|
||||
(r) =>
|
||||
isDraft(r.참조) && (r.참조.몸.바탕 as { 로직?: string } | undefined)?.로직 === x.키,
|
||||
);
|
||||
if (twice) return showToast(tc("Labor_AlreadyRef").replace("{value}", name), "error");
|
||||
if (own) void skFromLogic(own, x.키).then((r) => addTaken(r, name, null), failed);
|
||||
}, withSangeun(library)),
|
||||
});
|
||||
|
||||
@@ -479,10 +514,12 @@ export function mountLaborTable(
|
||||
nameField.input.readOnly = !edit;
|
||||
nameField.input.addEventListener("input", () => {
|
||||
(cur as { 이름?: string }).이름 = nameField.input.value.trim();
|
||||
nameField.setError();
|
||||
opt.onChanged(dirty());
|
||||
});
|
||||
const unit = el("div", { className: "ui-field", attrs: { "data-labor-field": "단위" } });
|
||||
const unit0 = cur.단위;
|
||||
let unitWhy = ""; // 860-2 ① 빈 단위로 [저장] — 칸 아래 글(단위를 고르면 지움)
|
||||
const drawUnit = (): void =>
|
||||
unit.replaceChildren(
|
||||
el("label", { className: "ui-field__label", text: tc("Labor_Unit") }),
|
||||
@@ -493,11 +530,13 @@ export function mountLaborTable(
|
||||
ariaLabel: tc("Labor_Unit"),
|
||||
onPick: (u) => {
|
||||
cur.단위 = u === NO_UNIT ? null : u;
|
||||
unitWhy = "";
|
||||
opt.onChanged(dirty());
|
||||
drawUnit();
|
||||
draw();
|
||||
},
|
||||
}),
|
||||
...(unitWhy ? [createText(unitWhy, "error")] : []),
|
||||
);
|
||||
drawUnit();
|
||||
const origin = createInputField({ type: "text", label: tc("Labor_Origin") });
|
||||
@@ -562,6 +601,20 @@ export function mountLaborTable(
|
||||
return out as unknown as LaborDoc;
|
||||
},
|
||||
saveArea: async () => (await combo?.save()) ?? false,
|
||||
// 860-2 ① 서버 400(이름 · 단위 빔) 전에 막음 — 칸 초점 · 칸 글 · 화면 줄 그대로
|
||||
check: () => {
|
||||
if (combo || !edit) return null;
|
||||
if (!(cur as { 이름?: string }).이름?.trim()) {
|
||||
nameField.setError(tc("NeedName"));
|
||||
nameField.input.focus();
|
||||
return tc("NeedName");
|
||||
}
|
||||
if (cur.단위 || !(cur.담은로직.length || cur.자재.length)) return null;
|
||||
unitWhy = tc("NeedUnit");
|
||||
drawUnit();
|
||||
unit.querySelector("button")?.focus();
|
||||
return unitWhy;
|
||||
},
|
||||
destroy: () => {
|
||||
alive = false;
|
||||
window.clearTimeout(timer);
|
||||
|
||||
@@ -21,6 +21,13 @@ const TEXT = {
|
||||
Loading: ["불러오는 중…", "Loading…"],
|
||||
Search: ["이름 · 키로 찾기", "Search by name or key"],
|
||||
NeedName: ["이름을 적어야 저장됨", "A name is required"],
|
||||
NeedUnit: ["단위를 골라야 저장됨", "Pick a unit to save"],
|
||||
Draft_Hint: [
|
||||
"저장 전 단가산출 — 일위대가 [저장] 때 만듦(그 전엔 서버에 없음)",
|
||||
"Unsaved — created when the unit-price item is saved",
|
||||
],
|
||||
Draft_Kept: ["일위대가에 담음 — 일위대가 [저장] 때 함께 저장", "Kept — saved with the item"],
|
||||
Draft_LinkLater: ["새 단가산출 줄 — 일위대가 [저장] 뒤 수량 잇기", "Link quantity after saving"],
|
||||
Load_Failed: ["불러오지 못함", "Load failed"],
|
||||
Origin_Self: ["원본", "Original"],
|
||||
Logics_Title: ["단가산출 기초", "Unit-price logics"],
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
* 서고 목록표(51-4 · 717-2a) — 좌측 일위대가 · 단가산출 층 단추를 누르면 상세 칸에 뜸.
|
||||
* 표 = 고름 · 키 · 구분 · 상세구분(51-12) · 이름 · 단위 · 기준 금액(서버 1 단위 계) · 고친 날 · 줄 누름 = 그 문서 상세 ·
|
||||
* 일위대가 = 안 이은 줄 수(729-3 · 서버 `summary` · 0 은 빈칸).
|
||||
* 단가산출 = 구분 둘 대신 바탕(M01 로직 · 없으면 「바탕 없음」) · 고친 줄 수 · 쓰는 곳 수(서버 `summary`).
|
||||
* 단가산출 = 구분 둘 대신 바탕(M01 로직 · 없으면 「바탕 없음」) · 고친 칸 수(860-2 ② 줄 쌓기 파란 테두리) · 쓰는 곳 수(서버 `summary`).
|
||||
* 머리 [생성] · [복사](고른 줄) · [삭제](고른 줄 · 쓰는 곳 있으면 서버 409 까닭 그대로).
|
||||
* 꼴 = M01 단가산출 로직 목록 — 찾기 줄(`buildHeadFilters`) · 쪽(`buildPager`) · 표(`m01-master__grid`) 를 M01 에서 import.
|
||||
* ========================================================================== */
|
||||
@@ -46,7 +46,7 @@ type Row = TemplateInfo & {
|
||||
구분?: string | null;
|
||||
상세구분?: string | null;
|
||||
바탕?: string | null;
|
||||
고친줄수?: number;
|
||||
고친칸수?: number;
|
||||
쓰는곳수?: number;
|
||||
/** 일위대가 안 이은 고정 줄 수(729-2 summary) */
|
||||
안이은줄?: number;
|
||||
@@ -76,7 +76,7 @@ export const sangeunBlank = (name: string): Record<string, unknown> => ({
|
||||
바탕: null,
|
||||
더한줄: [],
|
||||
});
|
||||
/** 표 열 — 머리 글 · 줄 값(일위대가 = 구분 둘 · 단가산출 = 바탕 · 고친 줄 · 쓰는 곳) */
|
||||
/** 표 열 — 머리 글 · 줄 값(일위대가 = 구분 둘 · 단가산출 = 바탕 · 고친 칸 · 쓰는 곳) */
|
||||
const COLUMNS: Record<LibraryKind, () => [string, (row: Row) => string][]> = {
|
||||
precombo: () => [
|
||||
[tc("Lib_Key"), (r) => r.이름],
|
||||
@@ -93,7 +93,7 @@ const COLUMNS: Record<LibraryKind, () => [string, (row: Row) => string][]> = {
|
||||
[tc("Lib_Name"), (r) => r.제목 ?? ""],
|
||||
[tc("Lib_Unit"), (r) => r.단위 ?? ""],
|
||||
[L("M02_SangeunBase"), (r) => r.바탕 || L("M02_SangeunNoBase")],
|
||||
[L("M02_SangeunEdited"), (r) => String(r.고친줄수 ?? 0)],
|
||||
[L("M02_SangeunEdited"), (r) => String(r.고친칸수 ?? 0)],
|
||||
[L("M02_SangeunUsers"), (r) => String(r.쓰는곳수 ?? 0)],
|
||||
[tc("Lib_Base"), (r) => money(r.기준금액)],
|
||||
[tc("Lib_Date"), (r) => dateText(r.수정일, "")],
|
||||
|
||||
@@ -352,11 +352,19 @@ def _refresh_drawing(folder: Path, column: str, unlink: list[str] | tuple[()] =
|
||||
|
||||
|
||||
def _store_save(folder: Path, kind: str, name: str, version: str, doc: Any, layer: str) -> dict:
|
||||
from M02_MasterTemplete import M02_Labor_SkRow as skrow
|
||||
|
||||
with store.at(folder):
|
||||
try:
|
||||
info = store.write(kind, name, version, doc, screen=True) # 화면 [저장](26-7e)
|
||||
try: # 화면 [저장](26-7e) · 일위대가 초안 줄 = 같은 잠금 안에서 SK 로 만듦(860-2)
|
||||
info = skrow.write(kind, name, version, doc, screen=True)
|
||||
except store.StoreError as error:
|
||||
raise HTTPException(status_code=error.status, detail=error.detail) from error
|
||||
if kind in layers.LIBRARY_KINDS: # 860-2 ⑤ 쓰는 구조물 조합 일위대가 금액 = 새 값
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
|
||||
here = refs.here()
|
||||
uses.refresh_labor({"층": here[0], "주인": here[1], "키": name})
|
||||
return {"종류": kind, "이름": name, "판": info["판"], "층": layer}
|
||||
|
||||
|
||||
|
||||
@@ -2,7 +2,8 @@
|
||||
* M02_MasterTemplete_Sangeun_Detail.ts
|
||||
* M02 단가산출(SK) 화면(PLAN 717-2b · 804-8 · 856-1) — 머리(이름 · 단위 · 단위 환산 · 바탕) · 머리 띠 · 줄 쌓기(`_Sangeun_Tabs`).
|
||||
* 모드(856-1 · 옛 키 글자 약속 `SK-000000` 대신) = page(단가산출 화면 · 일위대가 SK 모달 — 원문 패널 · 페이지 [저장] 한 번 ·
|
||||
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만)
|
||||
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만) ·
|
||||
* draft(860-2 일위대가 초안 줄 — 저장 전 문서 고침 · 수식 저장 = 서버가 다시 셈한 `수식` 을 이 문서에 · 디스크 쓰기 0)
|
||||
* 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) —
|
||||
* 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 ·
|
||||
* M01 개정 알림 = 줄 쌓기가 토스트 한 번(859-2 · 머리 띠 · 배지 없음)
|
||||
@@ -27,7 +28,7 @@ import { createSangeunSide, tabOf } from "./M02_MasterTemplete_Sangeun_Side";
|
||||
import { buildUnitSwap, type SwapHow } from "./M02_MasterTemplete_Sangeun_Unit";
|
||||
import "./M02_MasterTemplete_Sangeun.css";
|
||||
|
||||
export type SangeunMode = "page" | "ref" | "memory";
|
||||
export type SangeunMode = "page" | "ref" | "memory" | "draft";
|
||||
|
||||
/** SK 문서 중 화면 머리가 만지는 칸 */
|
||||
export interface SkDoc {
|
||||
@@ -89,7 +90,8 @@ export function mountSangeunDetail(
|
||||
const doc = clone((doc0 ?? {}) as SkDoc);
|
||||
let saved = JSON.stringify(doc);
|
||||
const edit = !opt.readOnly;
|
||||
const page = opt.mode === "page";
|
||||
const draft = opt.mode === "draft";
|
||||
const page = opt.mode === "page" || draft;
|
||||
const scope = { layer: opt.layer, owner: opt.owner };
|
||||
let base: LogicOne | null = null;
|
||||
let got: StackAnswer | null = null; // 줄 쌓기 셈 답 · 사본 표지(856-2)
|
||||
@@ -106,7 +108,8 @@ export function mountSangeunDetail(
|
||||
onSaved: (v) => void (refreshing = formulaSaved(v)),
|
||||
page: page ? () => report() : undefined, // 804-8 페이지 [저장] · [되돌림]
|
||||
// 836-5 저장 전 가져온 식(불러오기 미리 보기) = 그 문서째 수식 보기
|
||||
memory: opt.mode === "memory" ? () => doc as Record<string, unknown> : undefined,
|
||||
memory: opt.mode === "memory" || draft ? () => doc as Record<string, unknown> : undefined,
|
||||
memorySave: draft ? (got) => memorySaved(got) : undefined,
|
||||
onAnswer: (next) => {
|
||||
got = next;
|
||||
if (alive) drawNotes();
|
||||
@@ -127,6 +130,13 @@ export function mountSangeunDetail(
|
||||
/* 못 읽음 = 다음 열기 때 새로 */
|
||||
}
|
||||
}
|
||||
/** 초안 수식 저장(860-2) — 서버가 다시 셈한 몸의 `수식` · `가져온` 을 이 문서에(머리 고침은 그대로) */
|
||||
function memorySaved(got: Record<string, unknown>): void {
|
||||
const was = JSON.parse(saved) as SkDoc;
|
||||
[doc.수식, was.수식, doc.가져온, was.가져온] = [got.수식, got.수식, got.가져온, got.가져온];
|
||||
saved = JSON.stringify(was);
|
||||
touch();
|
||||
}
|
||||
const main = el("div", {
|
||||
className: "m02-sk",
|
||||
attrs: { "data-sangeun-detail": doc.키 ?? "" },
|
||||
@@ -141,7 +151,7 @@ export function mountSangeunDetail(
|
||||
opt.slot?.replaceChildren(
|
||||
el("span", { className: "ui-toolbar m02-main__tools", children: [tabs.tools] }),
|
||||
);
|
||||
tabs.draw(opt.mode === "memory" ? "" : (doc.키 ?? ""));
|
||||
tabs.draw(opt.mode === "memory" || draft ? "" : (doc.키 ?? ""));
|
||||
|
||||
const baseKey = (): string | null => doc.바탕?.로직 ?? null;
|
||||
|
||||
|
||||
@@ -21,6 +21,8 @@ export interface SkEquationOptions {
|
||||
page?: () => void;
|
||||
/** 저장 전 불러온 단가산출 문서(836-5 · 미리 보기 835-1) — 그 문서째 수식 보기 */
|
||||
memory?: () => Record<string, unknown> | null;
|
||||
/** 860-2 저장 전 문서 고침 켬 — 수식 저장 = 서버가 다시 셈한 새 몸(디스크 쓰기 0) */
|
||||
memorySave?: (doc: Record<string, unknown>) => void;
|
||||
/** 856-2 셈 답 · 사본 표지 — 머리 띠 */
|
||||
onAnswer?: (got: StackAnswer) => void;
|
||||
}
|
||||
@@ -60,6 +62,7 @@ export function createSangeunTabs(opt: SkEquationOptions): {
|
||||
page: opt.page,
|
||||
tools,
|
||||
memory: opt.memory,
|
||||
memorySave: opt.memorySave,
|
||||
onAnswer: opt.onAnswer,
|
||||
});
|
||||
return {
|
||||
|
||||
@@ -457,6 +457,8 @@ export function createMain(
|
||||
// [저장] = 엑셀에서 고른 칸 연결(면적 문서) 먼저 · 그다음 일위대가(서버가 새 칸 값으로 계산값)
|
||||
editor = {
|
||||
getDoc: async () => {
|
||||
const need = labor.check(); // 860-2 ① 빈 필수 칸 = 안 보냄(까닭 = 저장 못 함 토스트 · 화면 줄 그대로)
|
||||
if (need) throw new Error(need);
|
||||
// 면적 저장이 일위대가 계산값을 다시 적어 판이 바뀜 — 판을 다시 읽어 409 를 막음
|
||||
if (await labor.saveArea())
|
||||
version = (await readTemplate(at.layer, "labor", at.name, at.projectId)).판 ?? "";
|
||||
@@ -621,7 +623,10 @@ export function createMain(
|
||||
title.textContent = at.label = named ? `${at.name} ${named}` : at.name;
|
||||
showNotice([]);
|
||||
showToast(L("M02_Saved"), "success");
|
||||
onSaved?.(); // 좌측 목록의 판을 새 판으로
|
||||
onSaved?.(); // 좌측 목록의 판을 새 판으로 · 860-2 새로 만든 단가산출도 보임
|
||||
// 860-2 초안 줄 = 서버가 SK 로 바꿔 낌 — 다시 읽어 진짜 참조로(다음 [저장] 이 또 만들지 않게)
|
||||
const lines = (doc as { 담은로직?: { 참조?: { 층?: string } }[] } | null)?.담은로직;
|
||||
if (lines?.some((r) => r.참조?.층 === "초안") && sel === at) void open(at);
|
||||
} catch (error) {
|
||||
if (error instanceof StaleError) {
|
||||
const again = createButton({ label: L("M02_Reload"), variant: "ghost" });
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
"""M02 단가산출(SK) 서버 길 — 일위대가 [+ 줄] M01 기초 = 그 층 SK 사본(811-1 · `M02_Labor_SkRow`) `…/sangeun/from-logic`(층 쓰기) ·
|
||||
"""M02 단가산출(SK) 서버 길 — 일위대가 [항목 추가] 담기 = 초안 몸(860-2 · `M02_Labor_SkRow.draft` · 디스크 쓰기 0 ·
|
||||
SK 는 일위대가 [저장] 때 만듦) `…/sangeun/draft`(층 쓰기 · M01 기초 | 다른 층 SK) ·
|
||||
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported/price` ·
|
||||
`/link`(화면 캐시 문서 고침 · 저장 없음 · 층 읽기 · 기초로 바꾸기 없음 · 809-1) ·
|
||||
불러오기 단산 블록 → 가져온 식(793-3b · `M02_Sangeun_FromHopyo`) `…/sangeun/from-hopyo`
|
||||
@@ -28,24 +29,36 @@ from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _
|
||||
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Sangeun"])
|
||||
|
||||
|
||||
class FromLogicBody(BaseModel):
|
||||
로직: str
|
||||
class DraftBody(BaseModel):
|
||||
로직: str | None = None # M01 기초
|
||||
본뜬: dict[str, Any] | None = None # 다른 층 SK {층, 주인, 키}
|
||||
새로: bool = False
|
||||
씀: str | None = None
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/sangeun/from-logic")
|
||||
def sangeun_from_logic(
|
||||
@router.post("/layers/{layer}/sangeun/draft")
|
||||
def sangeun_draft(
|
||||
layer: Layer,
|
||||
body: FromLogicBody,
|
||||
body: DraftBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
) -> dict:
|
||||
"""일위대가 [+ 줄] M01 기초(811-1) — 그 층 SK 사본 · 답 = 새 키 + 참조(일위대가 문서는 화면 [저장] 때)."""
|
||||
"""일위대가 [항목 추가] 담기(860-2) — 답 `{초안: SK 몸}`(파일 안 만듦) | `{참조}`(같은 내용 그것을 씀 ·
|
||||
아래 · 옆 층 SK 사본) · 일위대가 문서는 화면 [저장] 때(`M02_Labor_SkRow.write`)."""
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Labor_SkRow as skrow
|
||||
from M02_MasterTemplete import M02_Layer_Access as access
|
||||
|
||||
folder = _root(session, layer, owner, write=True)
|
||||
return _call(folder, skrow.from_logic, body.로직, body.새로, body.씀)
|
||||
src = None
|
||||
if body.본뜬 is not None:
|
||||
got = access.grant(session, str(body.본뜬.get("층")), body.본뜬.get("주인")) # 원본 읽기
|
||||
src = {"층": got.layer, "주인": got.owner, "키": str(body.본뜬.get("키") or "")}
|
||||
if not refs._KEY.match(src["키"]) or refs.kind_of(src["키"]) != "sangeun":
|
||||
raise HTTPException(status_code=400, detail="본뜬 = 단가산출 키(SK-######)")
|
||||
elif not body.로직:
|
||||
raise HTTPException(status_code=400, detail="담을 것 = 로직 | 본뜬")
|
||||
return _call(folder, skrow.draft, body.로직, src, body.새로, body.씀)
|
||||
|
||||
|
||||
class FromHopyoBody(BaseModel):
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
"""M02 단가산출(SK) 내가 고친 칸 수(PLAN 860-2 ② · 요구 910) — 서고 › 단가산출 목록 「고친 칸」 열.
|
||||
|
||||
파이썬 · TS 짝 — 짝 = `common_util/common_util_line_stack_diff.ts` `docDiff`
|
||||
(줄 쌓기 파란 테두리 · 위 층 없이 = 나만) · 거울 시험 `resources/tester/test_860_2_edit_count.py`.
|
||||
셈 = 지금 수식 문서(`수식.문서`) 대 위 층 문서(읽기 답 `층바탕.위` · `M02_Doc_Sk_Path.layers`) —
|
||||
값 칸(`v:` 값 정의 · `u:` 단위 · `m:` 금액 줄 이름 · 단가 · 수량 · 단위 · 비목) +
|
||||
줄 틀(더한 줄 · 차례 바뀐 줄) + 빠진 줄 +
|
||||
기계 고침(`기계덮음` — 기계마다 값 칸 수 · 조종원 · 잡품 목록 하나씩).
|
||||
줄 쌓기 차림(항목 제목 `t:` · 글 줄 `g:`)은 값이 아니라 안 셈.
|
||||
따로 아닌 SK(파생 = 고침 없음) = 0 · 위 층 문서를 모름 = 기계 고침만.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_Doc_Copy as dc # 수식 문서 기호 열쇠 `dc.md.var_id`
|
||||
|
||||
LINE_FIELDS = ("이름", "단가", "수량", "단위", "비목")
|
||||
COVER = "기계덮음"
|
||||
_NO = object() # TS undefined
|
||||
_NUM = re.compile(r"^-?[\d,]*\.?\d+$")
|
||||
|
||||
|
||||
def canon(x: Any) -> Any:
|
||||
"""견줌 꼴(TS `canon`) — 수 글 = 수 · 빈 값 = 없음 · 글 띄어쓰기 뺌 · 묶음 칸 차례 무시."""
|
||||
if x is None or x is _NO:
|
||||
return _NO
|
||||
if isinstance(x, str):
|
||||
t = re.sub(r"\s+", "", x)
|
||||
if not t:
|
||||
return _NO
|
||||
if _NUM.match(t):
|
||||
try:
|
||||
return _num(float(t.replace(",", "")))
|
||||
except ValueError:
|
||||
return t
|
||||
return t
|
||||
if isinstance(x, list):
|
||||
return [None if (v := canon(y)) is _NO else v for y in x] if x else _NO
|
||||
if isinstance(x, dict):
|
||||
out = {k: v for k in sorted(x) if (v := canon(x[k])) is not _NO}
|
||||
return out or _NO
|
||||
if isinstance(x, float):
|
||||
return _num(x)
|
||||
return x
|
||||
|
||||
|
||||
def _num(v: float) -> Any:
|
||||
return int(v) if v.is_integer() else v
|
||||
|
||||
|
||||
def same(a: Any, b: Any) -> bool:
|
||||
return canon(a) == canon(b)
|
||||
|
||||
|
||||
def _key(x: Any) -> str:
|
||||
"""금액 줄 짝 열쇠(TS `JSON.stringify(canon(단가))`)."""
|
||||
got = canon(x)
|
||||
return "∅" if got is _NO else json.dumps(got, ensure_ascii=False, sort_keys=True)
|
||||
|
||||
|
||||
def _vars(doc: dict) -> dict[str, dict]:
|
||||
return {dc.md.var_id(v): v for v in doc.get("변수") or [] if isinstance(v, dict)}
|
||||
|
||||
|
||||
def _steps(doc: dict) -> dict[str, str]:
|
||||
return {
|
||||
str(x.get("기호") if x.get("기호") is not None else ""): str(
|
||||
x.get("식") if x.get("식") is not None else ""
|
||||
)
|
||||
for x in doc.get("식") or []
|
||||
if isinstance(x, dict)
|
||||
}
|
||||
|
||||
|
||||
def _value_at(vars_: dict, steps: dict, vid: str) -> Any:
|
||||
v, s = vars_.get(vid), steps.get(vid, _NO)
|
||||
if not v and s is _NO:
|
||||
return _NO
|
||||
v = v or {}
|
||||
return {"변수": True if v else _NO, "연결": v.get("연결"), "식": s, "이름": v.get("이름")}
|
||||
|
||||
|
||||
def _line_val(line: Any, field: str) -> Any:
|
||||
if not isinstance(line, dict):
|
||||
return _NO
|
||||
if field == "이름":
|
||||
return {"이름": line.get("이름"), "규격": line.get("규격")}
|
||||
return line.get(field)
|
||||
|
||||
|
||||
def match_lines(now: list, up: list) -> list[int]:
|
||||
"""금액 줄 짝(TS `matchLines`) — 지금 차례 → 위 층 차례(-1 = 없음)."""
|
||||
pool: dict[str, list[int]] = {}
|
||||
for j, line in enumerate(up):
|
||||
pool.setdefault(_key(line.get("단가")), []).append(j)
|
||||
out = []
|
||||
for line in now:
|
||||
hit = pool.get(_key(line.get("단가")))
|
||||
out.append(hit.pop(0) if hit else -1)
|
||||
free = [j for j in range(len(up)) if j not in out]
|
||||
for i, line in enumerate(now):
|
||||
if out[i] >= 0 or canon(line.get("이름")) is _NO:
|
||||
continue
|
||||
at = next((n for n, j in enumerate(free) if same(up[j].get("이름"), line.get("이름"))), -1)
|
||||
if at >= 0:
|
||||
out[i] = free.pop(at)
|
||||
return out
|
||||
|
||||
|
||||
def _moved(match: list[int]) -> set[int]:
|
||||
"""차례 바뀐 짝 줄 — 가장 긴 오름 차례에 안 든 것(TS `movedOf`)."""
|
||||
at = [(b, i) for i, b in enumerate(match) if b >= 0]
|
||||
size, prev = [], []
|
||||
for k, (b, _) in enumerate(at):
|
||||
size.append(1)
|
||||
prev.append(-1)
|
||||
for p in range(k):
|
||||
if at[p][0] < b and size[p] + 1 > size[k]:
|
||||
size[k], prev[k] = size[p] + 1, p
|
||||
keep: set[int] = set()
|
||||
k = size.index(max(size)) if size else -1
|
||||
while k >= 0:
|
||||
keep.add(at[k][1])
|
||||
k = prev[k]
|
||||
return {i for _, i in at if i not in keep}
|
||||
|
||||
|
||||
def count(now: Any, up: Any) -> int:
|
||||
"""지금 문서 대 위 층 — 내가 고친 값 칸 + 줄 틀 + 빠진 줄(기계 고침 뺌 · `covers`)."""
|
||||
now, up = (x if isinstance(x, dict) else {} for x in (now, up))
|
||||
nv, uv, ns, us = _vars(now), _vars(up), _steps(now), _steps(up)
|
||||
marks = 0
|
||||
for vid in {*nv, *ns}:
|
||||
marks += not same(_value_at(nv, ns, vid), _value_at(uv, us, vid))
|
||||
if vid in uv or (nv.get(vid) or {}).get("단위"):
|
||||
marks += not same((nv.get(vid) or {}).get("단위"), (uv.get(vid) or {}).get("단위"))
|
||||
nl = [x if isinstance(x, dict) else {} for x in now.get("금액") or []]
|
||||
ul = [x if isinstance(x, dict) else {} for x in up.get("금액") or []]
|
||||
match = match_lines(nl, ul)
|
||||
for i, b in enumerate(match):
|
||||
if b >= 0:
|
||||
marks += sum(not same(_line_val(nl[i], f), _line_val(ul[b], f)) for f in LINE_FIELDS)
|
||||
lines = sum(b < 0 for b in match) + len(_moved(match))
|
||||
has_items = any(now.get(k) for k in ("쌓기", "금액", "변수", "식"))
|
||||
gone = sum(j not in match for j in range(len(ul))) if has_items else 0
|
||||
return marks + lines + gone
|
||||
|
||||
|
||||
def covers(doc: Any) -> int:
|
||||
"""기계 고침 칸 — 기계마다 값 칸 수 + 조종원 · 잡품 목록 하나씩."""
|
||||
cover = doc.get(COVER) if isinstance(doc, dict) else None
|
||||
if not isinstance(cover, dict):
|
||||
return 0
|
||||
return sum(
|
||||
len(one.get("값") or {}) + bool(one.get("조종원")) + bool(one.get("잡품"))
|
||||
for one in cover.values()
|
||||
if isinstance(one, dict)
|
||||
)
|
||||
|
||||
|
||||
def of_sk(sk: Any) -> int:
|
||||
"""SK 문서 → 내가 고친 칸 수(목록 「고친 칸」) · 따로 아님 = 0 · 못 셈 = 0."""
|
||||
from M02_MasterTemplete import M02_Doc_Sk as dsk
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
held = sk.get(dsk.KEY) if isinstance(sk, dict) else None
|
||||
if not (isinstance(held, dict) and held.get("따로")) or not dsk.own(sk):
|
||||
return 0
|
||||
try:
|
||||
copy = path.current(sk)
|
||||
up = path.layers(copy, sk).get("위")
|
||||
except (store.StoreError, ArithmeticError, KeyError, TypeError, ValueError):
|
||||
return 0
|
||||
doc = copy.get("문서") or {}
|
||||
return (count(doc, up) if up else 0) + covers(doc)
|
||||
@@ -8,6 +8,8 @@
|
||||
* 금액 줄 짝 = 단가 글(같으면 차례대로) › 남은 줄은 이름 · 줄 틀 = 더한 줄 · 차례 바뀐 줄 · 빠진 줄 = 항목마다 되살림 목록
|
||||
* 견줌 = 수 · 수 글 같음 · 빈 칸 = 없음 · 글 사이 띄어쓰기 무시(표시 탓 다름 0)
|
||||
* 되돌림 = 칸 하나(`resetPath`) · 빠진 줄 되살림(`restoreLines` — 그 줄이 부르는 기호까지) — 부른 쪽 `change` 안에서
|
||||
* 파이썬 짝(860-2 ② 고친 칸 수 · 값 칸 v: u: m: + 줄 틀 + 빠진 줄) = `M02_MasterTemplete/M02_Sk_EditCount.py` ·
|
||||
* 거울 시험 `resources/tester/test_860_2_edit_count.py`
|
||||
* ========================================================================== */
|
||||
|
||||
import {
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
"precombo.나무": "d08cff9db9575c99",
|
||||
"precombo.되돌림": "c6cee923af63dbde",
|
||||
"precombo.만들기": "e53ad45acbf386bc",
|
||||
"precombo.목록": "8794b5e2d7a11999",
|
||||
"precombo.목록": "b4b9fb3defffd3b3",
|
||||
"precombo.복사": "ea957146cf361b70",
|
||||
"precombo.붙여넣기": "236bf55301ef9045",
|
||||
"precombo.쓰는곳": "8f68c3d2501f7a53",
|
||||
@@ -16,7 +16,7 @@
|
||||
"sangeun.나무": "991823a8c1fe1913",
|
||||
"sangeun.되돌림": "dd36436bdac1a6a7",
|
||||
"sangeun.만들기": "2155d280fd6d97ae",
|
||||
"sangeun.목록": "61e043f162549b4b",
|
||||
"sangeun.목록": "d7c68b66e2cc8021",
|
||||
"sangeun.복사": "40edbd4d0644186f",
|
||||
"sangeun.붙여넣기": "57cfb7bb522a80d3",
|
||||
"sangeun.쓰는곳": "2c9ec1824709481f",
|
||||
@@ -31,9 +31,9 @@
|
||||
"공유.요청": "762ba10d5af57643",
|
||||
"권한.같은회사남": "2d3d50a90583497d",
|
||||
"권한.남의회사관리": "a1213c908c70528f",
|
||||
"권한.시스템": "62482b9feacef35d",
|
||||
"권한.일반": "1c5a65215f7e254e",
|
||||
"권한.회사관리": "c08e29bffd8dd114",
|
||||
"권한.시스템": "33b6241129a9bce3",
|
||||
"권한.일반": "3f3009d92f5f403b",
|
||||
"권한.회사관리": "cd2c0f1d3073201e",
|
||||
"내기계.고치기": "3f00365dbfb77cee",
|
||||
"내기계.만들기": "20f5562f02c276f8",
|
||||
"내기계.목록": "064102da4c9740d6",
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
/* 860-2 ② 고친 칸 수 헬퍼 — common_util_line_stack_diff.ts `docDiff`(위 층 없이 = 나만)를 트랜스파일해 Node 로 돌림.
|
||||
* stdin = [{문서, 위}] → [값 칸(v: · u: · m:) 표시 수 + 줄 틀 수 + 빠진 줄 수](짝 = M02_Sk_EditCount.count)
|
||||
*/
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const ts = require(path.join(__dirname, "..", "..", "config", "node_modules", "typescript"));
|
||||
|
||||
const cache = new Map();
|
||||
function load(at) {
|
||||
if (cache.has(at)) return cache.get(at);
|
||||
const js = ts.transpileModule(fs.readFileSync(at, "utf8"), {
|
||||
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2020 },
|
||||
}).outputText;
|
||||
const box = { exports: {} };
|
||||
cache.set(at, box.exports);
|
||||
const need = (p) =>
|
||||
p.startsWith(".") ? load(path.resolve(path.dirname(at), `${p}.ts`)) : require(p);
|
||||
new Function("exports", "module", "require", js)(box.exports, box, need);
|
||||
return box.exports;
|
||||
}
|
||||
const df = load(path.join(__dirname, "..", "..", "common_util", "common_util_line_stack_diff.ts"));
|
||||
|
||||
const cases = JSON.parse(fs.readFileSync(0, "utf8"));
|
||||
const out = cases.map(({ 문서, 위 }) => {
|
||||
const g = df.docDiff(문서, 위);
|
||||
const marks = [...g.marks].filter(([p, m]) => /^[vum]:/.test(p) && m.diff === "mine").length;
|
||||
const gone = [...g.gone.values()].reduce((n, x) => n + x.at.length, 0);
|
||||
return marks + g.lines.size + gone;
|
||||
});
|
||||
process.stdout.write(JSON.stringify(out));
|
||||
@@ -1,6 +1,6 @@
|
||||
"""M02 단가산출 칸 목록 줄(PLAN 717-2a · `M02_Labor_Ref.summary` sangeun 갈래) — 임시 storage.
|
||||
|
||||
바탕 = 로직 「키 이름」 · 참조 = SK 키 · 없음 = None · 고친 줄 수 = 덮개 + 더한줄 + 뺀줄 ·
|
||||
바탕 = 로직 「키 이름」 · 참조 = SK 키 · 없음 = None · 고친 칸 수 = 줄 쌓기 파란 테두리 칸(860-2 ② · `M02_Sk_EditCount`) ·
|
||||
쓰는 곳 수 = 그 SK 를 바탕 · 더한줄로 담은 문서 수 · 일위대가(precombo) 줄엔 안 붙음.
|
||||
"""
|
||||
|
||||
@@ -34,7 +34,7 @@ def test_sangeun_row_base_edits_users(world):
|
||||
name = m01_doc.docs()[PCT]["이름"] # 기초 이름 = 수식 문서(855 L3)
|
||||
row = _row(mine, "sangeun", a)
|
||||
assert row["바탕"] == f"{PCT} {name}".strip()
|
||||
assert row["고친줄수"] == 0 and row["쓰는곳수"] == 0
|
||||
assert row["고친칸수"] == 0 and row["쓰는곳수"] == 0
|
||||
assert row["제목"] == "목록 시험" and row["단위"] == "㎡"
|
||||
# 바탕 참조 SK(740-1) = 저장 때 펼쳐 담음 → 바탕 = 기초 · 쓰는 곳 0
|
||||
b = _sk(mine, 바탕={"참조": {**MINE, "키": a}})
|
||||
@@ -43,11 +43,11 @@ def test_sangeun_row_base_edits_users(world):
|
||||
# 바탕 없음
|
||||
c = _sk(mine)
|
||||
row_c = _row(mine, "sangeun", c)
|
||||
assert row_c["바탕"] is None and row_c["고친줄수"] == 0
|
||||
assert row_c["바탕"] is None and row_c["고친칸수"] == 0
|
||||
|
||||
|
||||
def test_precombo_row_has_no_sangeun_fields(world):
|
||||
with store.at(world["personal"]):
|
||||
sc = refs.create("precombo", {"이름": "조합", "담은로직": []})["이름"]
|
||||
row = _row(world["personal"], "precombo", sc)
|
||||
assert not {"바탕", "고친줄수", "쓰는곳수"} & set(row)
|
||||
assert not {"바탕", "고친칸수", "쓰는곳수"} & set(row)
|
||||
|
||||
@@ -2,8 +2,8 @@
|
||||
"""811-1 일위대가 단가산출 줄 = SK 참조 한 행(요구 707-1 · 681 · 698) — 임시 storage · M01 읽기만.
|
||||
|
||||
- 저장 · 읽기 = 안 펼침(SK 참조 그대로) · 셈 = SK 1 단위 × 수량 · 모달 저장 = 그 SK 문서 → 일위대가 금액 따라감
|
||||
- [+ 줄] M01 기초 = 그 층 SK 사본(`from-logic` · 같은 내용 = 409 물음 · 씀 · 새로) · 일반 사용자 회사 층 403
|
||||
- 다른 층 SK = 이 층 사본 뒤 참조(화면 `Labor_SkPick` · 서버 서고 복사 길)
|
||||
- [항목 추가] M01 기초 = 초안 → 일위대가 [저장] 때 그 층 SK(860-2 · 시험 = `test_860_2_sk_draft.py`)
|
||||
- 다른 층 SK = 위 층 = 초안(860-2) · 그 밖 층 = 이 층 사본 뒤 참조(화면 `Labor_SkPick` · 서버 `M02_Labor_SkRow.draft`)
|
||||
- 옮긴 뒤 상태 = 마스터 층 로직 줄 0(한 번용 옮기기 도구는 894 에서 걷음)
|
||||
"""
|
||||
|
||||
@@ -12,25 +12,19 @@ import json
|
||||
import re
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Labor_SkRow as skrow
|
||||
from M02_MasterTemplete import M02_Library_Flat as flat
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Router as sk_router
|
||||
from M02_MasterTemplete import M02_Template_Layers as layers
|
||||
from M02_MasterTemplete.M02_Labor_Expand import Expand
|
||||
from resources.tester.test_740_1_library_flat import USER, _make, _read, _whole
|
||||
from resources.tester.test_m02_labor_ref import MINE, STONE, TEN, world # noqa: F401
|
||||
from resources.tester.test_740_1_library_flat import _make, _read, _whole
|
||||
from resources.tester.test_m02_labor_ref import MINE, TEN, world # noqa: F401
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[2]
|
||||
M02 = ROOT / "M02_MasterTemplete"
|
||||
FORM = "GC000211" # 합판거푸집 — 재료 줄 있음(일위대가 기본 별도계상)
|
||||
|
||||
|
||||
def _src(name: str) -> str:
|
||||
@@ -69,42 +63,6 @@ def test_모달_저장_SK_문서_뒤_일위대가_따라감(world):
|
||||
assert _read(me, "precombo", sc)["담은로직"][0]["참조"]["키"] == sk # 일위대가 문서는 그대로
|
||||
|
||||
|
||||
def test_from_logic_층_SK_사본_같은것_물음_권한(world):
|
||||
app = FastAPI()
|
||||
app.include_router(sk_router.router)
|
||||
app.dependency_overrides[verify_session] = lambda: USER
|
||||
client = TestClient(app)
|
||||
url = "/api/m02/layers/{}/sangeun/from-logic"
|
||||
res = client.post(url.format("personal"), json={"로직": TEN})
|
||||
assert res.status_code == 200, res.text
|
||||
key, ref = res.json()["이름"], res.json()["참조"]
|
||||
assert ref == {**MINE, "키": key}
|
||||
doc = _read(world["personal"], "sangeun", key)
|
||||
assert doc["바탕"] == {"로직": TEN} and doc["단위"] == "㎡" # 원/10㎡ → ㎡(줄 ÷ 배와 같은 값)
|
||||
again = client.post(url.format("personal"), json={"로직": TEN})
|
||||
assert again.status_code == 409 # 같은 내용 = 물음(733-2)
|
||||
use = client.post(url.format("personal"), json={"로직": TEN, "씀": key})
|
||||
assert use.json()["이름"] == key
|
||||
new = client.post(url.format("personal"), json={"로직": TEN, "새로": True})
|
||||
assert new.json()["이름"] != key
|
||||
assert client.post(url.format("personal"), json={"로직": "GF999999"}).status_code == 400
|
||||
assert client.post(url.format("company"), json={"로직": TEN}).status_code == 403
|
||||
|
||||
|
||||
def test_M01_기초_SK_값_로직_줄과_같음_재료_별도계상(world):
|
||||
"""새 SK 1 단위 = 옛 로직 줄 ÷ 배 · 재료 빈 칸 = 일위대가 기본(별도계상)을 적어 둠."""
|
||||
me = world["personal"]
|
||||
for code in (TEN, STONE, FORM):
|
||||
with store.at(me):
|
||||
got = skrow.from_logic(code, new=True)
|
||||
line = labor.clean({"담은로직": [{"로직": code, "수량": {"손": 2}}]})
|
||||
ref = labor.clean({"담은로직": [{"참조": got["참조"], "수량": {"손": 2}}]})
|
||||
a, b = labor.calc(line, {}), labor.calc(ref, {})
|
||||
assert a["반영합"] == b["반영합"], code
|
||||
doc = _read(me, "sangeun", got["이름"])
|
||||
assert doc["자재표시"] and all(v["별도계상"] == "별도계상" for v in doc["자재표시"].values())
|
||||
|
||||
|
||||
def test_마스터_층_단가산출_로직_줄_0():
|
||||
"""옮긴 뒤 상태 — 마스터 층 일위대가 · 조합의 담은로직에 로직 줄 0(참조 줄은 SK · SP · SC)."""
|
||||
for kind in ("precombo", "labor"):
|
||||
|
||||
@@ -51,16 +51,3 @@ def test_memory_doc_read_writes_nothing_same_as_saved(world, tag, no) -> None:
|
||||
assert saved["셈"] == got["셈"] # 금액 = 저장한 SK 와 같음
|
||||
with pytest.raises(store.StoreError):
|
||||
path.read_memory("문서 아님")
|
||||
|
||||
|
||||
def test_screen_memory_doc_stack_view() -> None:
|
||||
stack = (ROOT / "A00_Common" / "line_stack_screen.ts").read_text(encoding="utf-8")
|
||||
assert "memory?: () => Record<string, unknown> | null;" in stack
|
||||
assert 'cp.route(saved ? "-" : key, path)' in stack and "본: saved" in stack
|
||||
assert 'call<Loaded>("/read", {})' in stack and "left.inert = !!mem();" in stack
|
||||
tabs = (ROOT / "M02_MasterTemplete" / "M02_MasterTemplete_Sangeun_Tabs.ts").read_text(
|
||||
encoding="utf-8"
|
||||
)
|
||||
assert "memory: opt.memory," in tabs
|
||||
router = (ROOT / "M02_MasterTemplete" / "M02_Doc_Router.py").read_text(encoding="utf-8")
|
||||
assert '"/layers/{layer}/sangeun/-/doc/read"' in router and "write=body.본 is None" in router
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
"""860-2 ② 서고 › 단가산출 목록 「고친 칸」 = 내가 고친 칸 수(요구 910).
|
||||
|
||||
짝 = `M02_MasterTemplete/M02_Sk_EditCount.py`(목록 셈) ↔
|
||||
`common_util/common_util_line_stack_diff.ts` `docDiff`(줄 쌓기 파란 테두리 · 위 층 없이 = 나만) —
|
||||
수식 문서 전수에 같은 고침을 얹어 두 셈이 같음.
|
||||
서버 — SK 칸 고침 저장 = 목록 「고친 칸」 1 · 기계 값 고침 더함 · 다 되돌리면 0(파생).
|
||||
"""
|
||||
|
||||
import copy as cp
|
||||
import importlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
|
||||
from M02_MasterTemplete import M02_Sk_EditCount as ec
|
||||
|
||||
ml = importlib.import_module("master_doc_link")
|
||||
mcv = importlib.import_module("master_doc_cover")
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
|
||||
|
||||
def _node(cases):
|
||||
proc = subprocess.run(
|
||||
["node", os.path.join(HERE, "helper_860_2_edit_count.cjs")],
|
||||
input=json.dumps(cases, ensure_ascii=False),
|
||||
capture_output=True,
|
||||
text=True,
|
||||
encoding="utf-8",
|
||||
)
|
||||
assert proc.returncode == 0, proc.stderr[-2000:]
|
||||
return json.loads(proc.stdout)
|
||||
|
||||
|
||||
def _js(d):
|
||||
return json.loads(json.dumps(ml._norm(d), ensure_ascii=False, default=str))
|
||||
|
||||
|
||||
def _edits(doc):
|
||||
"""같은 문서에 얹는 고침 갈래 — 값 · 단위 · 수량 · 줄 뺌 · 줄 더함 · 차례 · 이름."""
|
||||
out = [cp.deepcopy(doc)]
|
||||
money = doc.get("금액") or []
|
||||
if doc.get("변수"):
|
||||
d = cp.deepcopy(doc)
|
||||
d["변수"][0]["연결"] = {**(d["변수"][0].get("연결") or {}), "값": 12345}
|
||||
d["변수"][-1]["단위"] = "시험단위"
|
||||
out.append(d)
|
||||
if money:
|
||||
d = cp.deepcopy(doc)
|
||||
d["금액"][0]["수량"] = f"({money[0].get('수량')}) × 2"
|
||||
d["금액"].append({**money[-1], "단가": "1234", "이름": "시험 줄"})
|
||||
out.append(d)
|
||||
d = cp.deepcopy(doc)
|
||||
d["금액"].pop()
|
||||
out.append(d)
|
||||
if len(money) > 2:
|
||||
d = cp.deepcopy(doc)
|
||||
d["금액"][0], d["금액"][1] = d["금액"][1], d["금액"][0]
|
||||
d["금액"][-1]["이름"] = "바꾼 이름"
|
||||
out.append(d)
|
||||
return out
|
||||
|
||||
|
||||
def test_거울_전수_파이썬_TS_같음():
|
||||
cases = []
|
||||
for _, d in sorted(ml.load_all().items()):
|
||||
up = _js(d)
|
||||
cases += [{"문서": now, "위": up} for now in _edits(up)]
|
||||
assert len(cases) >= 6000
|
||||
want = _node(cases)
|
||||
got = [ec.count(c["문서"], c["위"]) for c in cases]
|
||||
bad = [(i, g, w) for i, (g, w) in enumerate(zip(got, want)) if g != w]
|
||||
assert not bad, bad[:5]
|
||||
assert got[0] == 0 and max(got) > 3 # 고침 없음 = 0 · 고침 = 셈
|
||||
|
||||
|
||||
def test_서버_SK_고친_칸(tmp_path, monkeypatch):
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as path
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from resources.tester.test_m02_labor_ref import world as make
|
||||
|
||||
me = make.__wrapped__(tmp_path, monkeypatch)["personal"]
|
||||
with store.at(me):
|
||||
body = {"이름": "sub6임시 고친칸", "단위": "㎥", "바탕": {"로직": "GF000099"}, "더한줄": []}
|
||||
key = refs.create("sangeun", body)["이름"]
|
||||
row = lambda: refs.summary(me, "sangeun", key)["고친칸수"] # noqa: E731
|
||||
assert row() == 0
|
||||
first = path.read(key)
|
||||
doc = cp.deepcopy(first["문서"])
|
||||
doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 2"
|
||||
path.save(key, {"문서": doc, "판": first["판"]})
|
||||
assert row() == 1
|
||||
doc[mcv.COVER] = {"0201-0070": {"값": {"가격": 900000}}} # 굴착기 0.7㎥ — GF000099 기계
|
||||
path.save(key, {"문서": doc, "판": path.read(key)["판"]})
|
||||
assert row() == 2 # 수량 1 + 기계 값 1
|
||||
path.save(key, {"문서": first["문서"], "판": path.read(key)["판"]})
|
||||
assert row() == 0 # 다 되돌림 = 파생
|
||||
@@ -0,0 +1,159 @@
|
||||
# ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀
|
||||
"""860-2 ③ ④ ⑤ 일위대가에 담은 단가산출 = 일위대가 [저장] 때 만듦(요구 910 ㉡) — 임시 storage.
|
||||
|
||||
- 담기(`…/sangeun/draft`) = 초안 몸 · 파일 0 · 같은 내용 SK 있으면 물음(씀 = 그 참조 · 새로 = 초안) · 회사 층 403
|
||||
- 초안 줄 셈 = 저장 뒤 셈(같은 금액) · 초안 몸 참조는 이 층이 읽는 것만
|
||||
- 저장(`M02_Labor_SkRow.write`) = 초안마다 SK 만들고 잇기 · 단위 빔 · 판 409 = SK 0 · 번호 장부 그대로
|
||||
- 저장 전 줄 쌓기 고침(`M02_Doc_Sk_Path.save("-")`) = 디스크 0 · 고친 값이 만든 SK 에
|
||||
- 단가산출 · 일위대가 저장 뒤 쓰는 구조물 조합 일위대가 금액 = 새 값(`M02_Library_Uses.refresh_labor`)
|
||||
"""
|
||||
|
||||
import copy
|
||||
import json
|
||||
|
||||
import pytest
|
||||
from fastapi import FastAPI
|
||||
from fastapi.testclient import TestClient
|
||||
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M02_MasterTemplete import M02_Doc_Sk_Path as sk_path
|
||||
from M02_MasterTemplete import M02_Labor_Doc as labor
|
||||
from M02_MasterTemplete import M02_Labor_Ref as refs
|
||||
from M02_MasterTemplete import M02_Labor_SkRow as skrow
|
||||
from M02_MasterTemplete import M02_Library_Uses as uses
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
from M02_MasterTemplete import M02_Sangeun_Router as sk_router
|
||||
from resources.tester.test_740_1_library_flat import USER, _make, _read
|
||||
from resources.tester.test_m02_labor_ref import MINE, STONE, TEN, world # noqa: F401
|
||||
|
||||
FORM = "GC000211" # 합판거푸집 — 재료 줄 있음
|
||||
|
||||
|
||||
def _client():
|
||||
app = FastAPI()
|
||||
app.include_router(sk_router.router)
|
||||
app.dependency_overrides[verify_session] = lambda: USER
|
||||
return TestClient(app)
|
||||
|
||||
|
||||
def _files(me):
|
||||
return (
|
||||
sorted(p.name for p in (me / "sangeun").glob("*.json")) if (me / "sangeun").is_dir() else []
|
||||
)
|
||||
|
||||
|
||||
def _draft(body, key="SK-초안1"):
|
||||
return {"층": refs.DRAFT, "주인": None, "키": key, "몸": body}
|
||||
|
||||
|
||||
def _sum(me, doc):
|
||||
with store.at(me):
|
||||
return labor.calc(labor.clean(doc), {})["반영합"]["계"]
|
||||
|
||||
|
||||
def test_담기_초안_파일_0_물음_권한(world):
|
||||
me, client = world["personal"], _client()
|
||||
url = "/api/m02/layers/{}/sangeun/draft"
|
||||
got = client.post(url.format("personal"), json={"로직": TEN})
|
||||
assert got.status_code == 200, got.text
|
||||
body = got.json()["초안"]
|
||||
assert "참조" not in got.json() and _files(me) == [] # 디스크 쓰기 0
|
||||
assert body["바탕"] == {"로직": TEN} and body["단위"] == "㎡" and body["키"] == skrow.NO_KEY
|
||||
sc = _make(me, "precombo", 이름="sub6임시 SC", 담은로직=[])
|
||||
with store.at(me):
|
||||
skrow.write("precombo", sc, store.read("precombo", sc)["판"], {"이름": "sub6임시 SC", "단위": "㎡", "담은로직": [{"참조": _draft(body), "수량": {"손": 1}}]}) # fmt: skip
|
||||
(key,) = [p[:-5] for p in _files(me)]
|
||||
assert client.post(url.format("personal"), json={"로직": TEN}).status_code == 409 # 같은 내용
|
||||
use = client.post(url.format("personal"), json={"로직": TEN, "씀": key}).json()
|
||||
assert use == {"참조": {**MINE, "키": key}}
|
||||
assert "초안" in client.post(url.format("personal"), json={"로직": TEN, "새로": True}).json()
|
||||
assert client.post(url.format("personal"), json={"로직": "GF999999"}).status_code == 400
|
||||
assert client.post(url.format("company"), json={"로직": TEN}).status_code == 403
|
||||
assert _files(me) == [f"{key}.json"]
|
||||
|
||||
|
||||
def test_초안_셈_저장_뒤_같음_잇기_재료_별도계상(world):
|
||||
me = world["personal"]
|
||||
for code in (TEN, STONE, FORM): # 811-1 옛 from-logic 견본 셋
|
||||
with store.at(me):
|
||||
body = skrow.draft(code, new=True)["초안"]
|
||||
doc = {
|
||||
"이름": "sub6임시 SC",
|
||||
"단위": "㎡",
|
||||
"담은로직": [{"참조": _draft(body), "수량": {"손": 2}}],
|
||||
}
|
||||
before = _sum(me, doc)
|
||||
line = _sum(me, {"담은로직": [{"로직": code, "수량": {"손": 2}}]})
|
||||
sc = _make(me, "precombo", 이름="sub6임시 SC", 담은로직=[])
|
||||
with store.at(me):
|
||||
skrow.write("precombo", sc, store.read("precombo", sc)["판"], doc)
|
||||
saved = _read(me, "precombo", sc)
|
||||
ref = saved["담은로직"][0]["참조"]
|
||||
assert ref["층"] == "personal" and ref["키"].startswith("SK-")
|
||||
assert before == line == _sum(me, saved) and before > 0, code
|
||||
assert uses.users(ref) == ["일위대가 개인 7/42 「sub6임시 SC」"]
|
||||
made = _read(me, "sangeun", ref["키"])
|
||||
assert made["자재표시"] and all(v["별도계상"] == "별도계상" for v in made["자재표시"].values())
|
||||
|
||||
|
||||
def test_초안_몸_남의_층_참조_막음(world):
|
||||
me = world["personal"]
|
||||
with store.at(me):
|
||||
body = skrow.draft(TEN, new=True)["초안"]
|
||||
bad = {**body, "더한줄": [{"참조": {"층": "personal", "주인": "7/99", "키": "SK-000001"}}]}
|
||||
with pytest.raises(store.StoreError):
|
||||
labor.clean({"담은로직": [{"참조": _draft(bad), "수량": {"손": 1}}]})
|
||||
|
||||
|
||||
@pytest.mark.parametrize("how", ["단위빔", "판"])
|
||||
def test_저장_실패_SK_0_번호_그대로(world, how):
|
||||
me = world["personal"]
|
||||
sc = _make(me, "precombo", 이름="sub6임시 SC", 담은로직=[])
|
||||
with store.at(me):
|
||||
body = skrow.draft(TEN, new=True)["초안"]
|
||||
book = refs.issued()
|
||||
doc = {"이름": "sub6임시 SC", "단위": "" if how == "단위빔" else "㎡"}
|
||||
doc["담은로직"] = [{"참조": _draft(body), "수량": {"손": 1}}, {"참조": _draft(body, "SK-초안2"), "수량": {"손": 1}}] # fmt: skip
|
||||
with pytest.raises(store.StoreError) as e:
|
||||
skrow.write("precombo", sc, "옛판" if how == "판" else store.read("precombo", sc)["판"], doc) # fmt: skip
|
||||
assert e.value.status == (409 if how == "판" else 400)
|
||||
assert _files(me) == [] and refs.issued() == book
|
||||
assert _read(me, "precombo", sc).get("담은로직") in (None, [])
|
||||
|
||||
|
||||
def test_저장_전_줄_쌓기_고침_디스크_0_만든_SK_에(world):
|
||||
me = world["personal"]
|
||||
with store.at(me):
|
||||
body = skrow.draft(TEN, new=True)["초안"]
|
||||
first = sk_path.read_memory(body)
|
||||
doc = copy.deepcopy(first["문서"])
|
||||
doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 2"
|
||||
got = sk_path.save(sk_path.MEMORY, {"본": body, "문서": doc, "판": ""})
|
||||
assert _files(me) == [] and got["본"]["수식"]["따로"]
|
||||
assert got["셈"]["계"] != first["셈"]["계"]
|
||||
sc = _make(me, "precombo", 이름="sub6임시 SC", 담은로직=[])
|
||||
line = {"참조": _draft(got["본"]), "수량": {"손": 1}}
|
||||
want = labor.calc(labor.clean({"담은로직": [line]}), {})["반영합"]["계"]
|
||||
skrow.write("precombo", sc, store.read("precombo", sc)["판"], {"이름": "sub6임시 SC", "단위": "㎡", "담은로직": [line]}) # fmt: skip
|
||||
key = _read(me, "precombo", sc)["담은로직"][0]["참조"]["키"]
|
||||
assert sk_path.read(key)["셈"]["계"] == got["셈"]["계"]
|
||||
assert refs.summary(me, "sangeun", key)["고친칸수"] == 1
|
||||
assert _sum(me, _read(me, "precombo", sc)) == want
|
||||
|
||||
|
||||
def test_일위대가_저장_뒤_조합_금액_새_값(world):
|
||||
me = world["personal"]
|
||||
sk = _make(me, "sangeun", 이름="sub6임시 SK", 바탕={"로직": TEN})
|
||||
sc = _make(me, "precombo", 이름="sub6임시 SC", 단위="㎡", 담은로직=[{"참조": {**MINE, "키": sk}, "수량": {"손": 1}}]) # fmt: skip
|
||||
with store.at(me):
|
||||
store.write(
|
||||
"labor", "rv", "", {"담은로직": [{"참조": {**MINE, "키": sc}, "수량": {"손": 2}}]}
|
||||
)
|
||||
was = store.read("labor", "rv")["문서"]["계산값"]["반영합"]["계"]
|
||||
read = sk_path.read(sk)
|
||||
doc = copy.deepcopy(read["문서"])
|
||||
doc["금액"][0]["수량"] = f"({doc['금액'][0]['수량']}) × 3"
|
||||
sk_path.save(sk, {"문서": doc, "판": read["판"]}) # SK 저장 → SC → 조합
|
||||
now = store.read("labor", "rv")["문서"]["계산값"]["반영합"]["계"]
|
||||
assert now != was and now > 0
|
||||
assert json.dumps(uses.refresh_labor({**MINE, "키": sc}), default=str).count("rv") == 1
|
||||
@@ -158,7 +158,7 @@ export const ui_locales_m2 = {
|
||||
M02_SangeunNewHere: ["여기에 새 단가산출", "New unit-price analysis here"],
|
||||
M02_SangeunBase: ["바탕", "Base"],
|
||||
M02_SangeunNoBase: ["바탕 없음", "No base"],
|
||||
M02_SangeunEdited: ["고친 줄", "Edited rows"],
|
||||
M02_SangeunEdited: ["고친 칸", "Edited cells"],
|
||||
M02_SangeunUsers: ["쓰는 곳", "Used by"],
|
||||
M02_SangeunUnit: ["단위(1 단위 값)", "Unit (value per 1)"],
|
||||
M02_SangeunNeed: ["비우면 저장 안 됨", "Required"],
|
||||
|
||||
Reference in New Issue
Block a user