Merge commit '3e0888610476700d939624ec4de36a2d1b78c540' into main_laptop_1

This commit is contained in:
2026-11-19 11:13:50 +09:00
28 changed files with 856 additions and 150 deletions
+11 -4
View File
@@ -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;
+32 -3
View File
@@ -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]:
+30 -4
View File
@@ -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
+82 -6
View File
@@ -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
+1 -1
View File
@@ -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
+23 -1
View File
@@ -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" });
+21 -8
View File
@@ -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):
+180
View File
@@ -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));
+4 -4
View File
@@ -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)
+4 -46
View File
@@ -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"):
-13
View File
@@ -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
+97
View File
@@ -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 # 다 되돌림 = 파생
+159
View File
@@ -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
+1 -1
View File
@@ -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"],