feat(860-2): 일위대가에 담은 단가산출 = 일위대가 [저장] 때 만듦(요구 910 ㉡) — 담을 때 서버 파일 0 · 저장 안 하고 나가면 아무것도 안 남음
- 담기 = 초안 줄 {층: 초안, 키: SK-초안n, 몸}(화면 캐시만) · 서버 길 `…/sangeun/draft`(디스크 쓰기 0 · 같은 내용 물음 그대로) · 옛 `…/sangeun/from-logic` 걷음
- 셈 = 있던 셈 길이 초안 몸을 읽음(`refs.read_ref`) · 초안 몸 참조 = 이 층이 읽는 것만
- 줄 누름 = 저장 전 줄 쌓기 고침(줄 쌓기 `memorySave` · 서버 `…/sangeun/-/doc/save` = 다시 셈한 새 몸 · 디스크 0) → 그 줄 몸
- 일위대가 [저장] = 한 잠금(Store.batch) 안에서 초안마다 SK 새 키 → 줄 · 규격 열 열쇠 바꿔 낌 → 저장 · 실패 = 만든 SK 지움 · 번호 장부 되돌림 · 저장 뒤 화면이 다시 읽음 · 왼쪽 나무 바로 보임
- 위 층 아닌 SK 고름 = 옛 길대로 바로 사본 · 조합 일위대가 초안 줄 = 면적 알약 잇기는 저장 뒤
- 화면 [저장] 앞 빈 칸 검사(860-2 ①)를 일위대가 편집기 getDoc 안으로(같은 토스트 · UI_Main 700 줄 지킴)
- 시험: test_860_2_sk_draft 새로 · test_836_5 의 소스 글자 시험(`left.inert = !!mem();` 등 글자 대조) 걷음(결과 시험 아님 · 4 장 규칙) · test_811_1 의 옛 from-logic 시험 둘은 걷어 860_2 로 옮김(같은 견본 셋 금액 같음)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
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,15 +257,36 @@ 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))
|
||||
|
||||
|
||||
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]:
|
||||
"""기계 창(827-1) — 이 SK 사본에 박힌 기계 줄 · 지금 줄 · 새 값."""
|
||||
doc = _file(key)["문서"]
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)),
|
||||
});
|
||||
|
||||
|
||||
@@ -22,6 +22,12 @@ const TEXT = {
|
||||
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"],
|
||||
|
||||
@@ -352,9 +352,11 @@ 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
|
||||
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 {
|
||||
|
||||
@@ -56,8 +56,6 @@ export interface Selection {
|
||||
|
||||
interface EditorHandle {
|
||||
getDoc: () => unknown | Promise<unknown>;
|
||||
/** [저장] 앞 필수 칸(860-2 ① 일위대가) — 까닭이면 저장 안 함 */
|
||||
check?: () => string | null;
|
||||
destroy: () => void;
|
||||
}
|
||||
|
||||
@@ -459,12 +457,13 @@ 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)).판 ?? "";
|
||||
return labor.getDoc();
|
||||
},
|
||||
check: labor.check,
|
||||
destroy: labor.destroy,
|
||||
};
|
||||
return;
|
||||
@@ -581,8 +580,6 @@ export function createMain(
|
||||
async function doSave(): Promise<void> {
|
||||
if (!sel) return;
|
||||
const at = sel;
|
||||
const need = editor?.check?.(); // 860-2 ① 빈 필수 칸 — 서버에 안 보냄 · 화면 줄 그대로
|
||||
if (need) return void showToast(L("M02_SaveFailed").replace("{value}", need), "error");
|
||||
try {
|
||||
const edited = editor ? await editor.getDoc() : loaded;
|
||||
// 구조물 도면 저장은 `도면` · `더한장` 칸만 갈아 끼움 — 도번은 읽은 그대로.
|
||||
@@ -626,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):
|
||||
|
||||
@@ -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,139 @@
|
||||
# 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 에
|
||||
"""
|
||||
|
||||
import copy
|
||||
|
||||
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
|
||||
Reference in New Issue
Block a user