diff --git a/A00_Common/formula_doc_copy.ts b/A00_Common/formula_doc_copy.ts index 1e0f92075..a54103e7e 100644 --- a/A00_Common/formula_doc_copy.ts +++ b/A00_Common/formula_doc_copy.ts @@ -1,40 +1,25 @@ /* ============================================================================= * formula_doc_copy.ts - * 수식 문서 사본 몫(PLAN 802-4b-2 · 요구 655-2 · 656 · 659-3) — M02 단가산출(SK) 수식 탭 머리 - * 「M01 새 판 있음」 배지(값 줄 · 부름 문서가 지금 M01 과 다름) · [단가 갱신](자원 단가만 · 식 그대로) · - * [재생성](지금 M01 문서로 다시 찍음 · 버리는 것 알림) — 누를 때만(자동 갱신 없음) - * 흐름 = 미리 셈(`{길}/preview` {할일}) → 확인 창(계 전 → 후 · 바뀐 자원 · 버리는 것) → 저장(`{길}/save` {할일, 판}) - * 층 쓰기 권한 없으면 「읽기만」 배지 - * (821-3) 값 줄만 바뀜(M01 단가 · 내 기계 고침) = 「새 값 있음」(같은 자리 · 같은 꼴) · 지운 키(M01 · 내 기계) = 「지워짐 n」 · - * [단가 갱신] 확인 창 = 바뀐 자원 줄(이름 · 바뀐 칸 전 → 후 · 지워짐 = 마지막 값 유지) - * (822-1) 값 사본에 없는 셈 줄(옛 저장본 빈틈) = 「사본 없는 줄 n」(지금 값으로 셈 · 저장하면 굳음) - * (836-2) 표지 `자동`(프로젝트 층 밖 = M01 자동 따라옴) = 단추 · 「새 값」 · 「사본 없는 줄」 안 그림(지워짐만) + * 수식 문서 사본 몫(PLAN 802-4b-2 · 요구 655-2 · 656 · 659-3) — M02 단가산출(SK) 수식 탭 머리 배지 + * 층 쓰기 권한 없으면 「읽기만」 배지 · 지운 키(M01 · 내 기계) = 「지워짐 n」(마지막 값 유지) + * (859-2 · 요구 903 ~ 905) 프로젝트 안 [단가 갱신] · [재생성] · 「M01 새 판」 · 「새 값」 · 「사본 없는 줄」 걷음 — + * 프로젝트 사본 = 지정한 때 그대로 · 바꾸려면 다시 지정 * ========================================================================== */ import { createBadge } from "@ui/ui_template_badge"; -import { createButton } from "@ui/ui_template_button"; -import { eqText } from "@ui/ui_template_equation"; -import { showConfirmDialog } from "@ui/ui_template_elements"; import type { FormulaDoc } from "../common_util/common_util_formula_doc"; import type { Basis } from "../common_util/common_util_formula_doc_import"; import { swappedCount } from "../common_util/common_util_line_stack_pick"; import { ft } from "./formula_doc_text"; import type { RenewNote } from "./formula_doc_renew"; -export type CopyJob = "단가갱신" | "재생성"; - /** 사본 표지(서버 `M02_Doc_Copy.state` + 시점 · 따로) */ export interface CopyMark { - M01새판?: boolean; 지운키?: string[]; - 단가새값?: boolean; - /** 값 사본에 없는 셈 줄 수(822-1) — 지금 값으로 셈 · 저장하면 굳음 */ - 사본없음?: number; - 문서새판?: string[]; 따로?: boolean; /** 가져온 식(엑셀 불러오기 · 807-1) 단가기준 — 엑셀 = 엑셀 값 기억 · 우리 = 연결 값 */ 단가기준?: Basis; - /** M01 자동 따라옴(836-2 · 프로젝트 층 밖) — [단가 갱신] · [재생성] · 「새 값」 · 「사본 없는 줄」 없음 */ + /** M01 자동 따라옴(836-2 · 프로젝트 층 밖) */ 자동?: boolean; /** 열 때 알림(836-2) — M01 에서 바뀐 항목의 지운 고침 */ 갱신?: RenewNote[]; @@ -47,40 +32,14 @@ export interface CopyOptions { onSaved?: (version: string) => void; } -type Money = Record | null; - -export interface JobReply { - 전?: Money; - 후?: Money; - 바뀐자원?: unknown[]; - 버림?: { 문서고침?: boolean; 끊음?: string[] }; -} - -/** 「M01 새 판 있음」 — 값 줄 · 단가 · 부름 문서 어느 하나라도 지금 M01 과 다름 */ -export function isStale(m: CopyMark | undefined): boolean { - return !!m && (!!m.M01새판 || !!m.단가새값 || !!m.지운키?.length || !!m.문서새판?.length); -} - export function copyBadges(m: CopyMark | undefined, edit: boolean): HTMLElement[] { const out: HTMLElement[] = []; - const doc = !!m?.M01새판 || !!m?.문서새판?.length; - if ((doc || m?.단가새값) && !m?.자동) { - const b = createBadge(ft(doc ? "New_M01" : "New_Value"), "danger"); - b.dataset.copyStale = doc ? "doc" : "value"; - out.push(b); - } if (m?.지운키?.length) { const b = createBadge(`${ft("Gone")} ${m.지운키.length}`, "warning"); b.title = `${m.지운키.join(" · ")} — ${ft("Gone_Note")}`; b.dataset.copyGone = m.지운키.join(","); out.push(b); } - if (m?.사본없음 && !m.자동) { - const b = createBadge(`${ft("Gap")} ${m.사본없음}`, "warning"); - b.title = ft("Gap_Note"); - b.dataset.copyGap = String(m.사본없음); - out.push(b); - } if (!edit) out.push(createBadge(ft("Read_Only"), "neutral")); return out; } @@ -93,58 +52,3 @@ export function swapBadge(doc: FormulaDoc): HTMLElement[] { b.dataset.swappedN = String(n); return [b]; } - -export function copyTools(edit: boolean, run: (job: CopyJob) => void): HTMLElement[] { - if (!edit) return []; - return (["단가갱신", "재생성"] as const).map((job) => { - const b = createButton({ - label: job === "단가갱신" ? ft("Price") : ft("Regen"), - variant: "ghost", - size: 28, - onClick: () => run(job), - }); - b.dataset.copyJob = job; - return b; - }); -} - -const sum = (m: Money | undefined): string => - typeof m?.계 === "number" ? `${eqText(m.계)} 원` : "—"; - -/** 바뀐 자원 한 줄 — 「이름 칸 전 → 후」(값 묶음에서 다른 칸만) · 지워짐 = 마지막 값 유지 */ -export function changedLine(x: unknown): string { - const r = (x ?? {}) as { - 키?: string; - 이름?: string; - 전?: unknown; - 후?: unknown; - 지워짐?: boolean; - }; - const name = r.이름 || r.키 || ""; - if (r.지워짐) return `${name} ${ft("Gone")}(${ft("Gone_Note")})`; - const show = (v: unknown): string => (typeof v === "number" ? eqText(v) : String(v ?? "—")); - const a = r.전 && typeof r.전 === "object" ? (r.전 as Record) : null; - const b = r.후 && typeof r.후 === "object" ? (r.후 as Record) : null; - if (!a || !b) return `${name} ${show(r.전)} → ${show(r.후)}`; - const keys = [...new Set([...Object.keys(a), ...Object.keys(b)])].filter( - (k) => JSON.stringify(a[k]) !== JSON.stringify(b[k]), - ); - return `${name} ${keys.map((k) => `${k} ${show(a[k])} → ${show(b[k])}`).join(", ")}`; -} - -/** 할일 알림 — 계 전 → 후 · 바뀐 자원 수 · 재생성이 버리는 것(이름) → 확인이면 true */ -export function askJob(job: CopyJob, got: JobReply, names: Map): Promise { - const bits = [ - job === "단가갱신" ? ft("Price_Ask") : ft("Regen_Ask"), - `${ft("Before_After")} ${sum(got.전)} → ${sum(got.후)}`, - ]; - const lines = job === "단가갱신" ? (got.바뀐자원 ?? []).slice(0, 8).map(changedLine) : []; // 821-3 - if (job === "단가갱신") bits.push(`${ft("Changed")} ${got.바뀐자원?.length ?? 0}`); - const lost = [ - ...(got.버림?.문서고침 ? [ft("Regen_Edit")] : []), - ...(got.버림?.끊음 ?? []).map((k) => `${ft("Cut")} ${names.get(k) || k}`), - ]; - if (job === "재생성" && lost.length) bits.push(`${ft("Regen_Lost")} — ${lost.join(" · ")}`); - const text = [bits.join(" · "), ...lines].join("\n"); - return showConfirmDialog(text, job === "단가갱신" ? ft("Price") : ft("Regen")); -} diff --git a/A00_Common/formula_doc_text.ts b/A00_Common/formula_doc_text.ts index 09eb0ae00..83af3e8c0 100644 --- a/A00_Common/formula_doc_text.ts +++ b/A00_Common/formula_doc_text.ts @@ -41,24 +41,11 @@ const TEXT = { More: ["더 있음 — 찾는 말을 더 넣으세요", "More — refine search"], Nothing: ["찾은 것 없음", "Nothing found"], Linked: ["연결", "Linked"], - Cut: ["끊음", "Unlinked"], Unlink: ["연결 끊기", "Unlink"], Relink: ["다시 잇기", "Relink"], - New_M01: ["M01 새 판 있음", "New M01 version"], - New_Value: ["새 값 있음", "New values"], Gone: ["지워짐", "Deleted"], Gone_Note: ["마지막 값 유지", "last value kept"], - Gap: ["사본 없는 줄", "Uncopied rows"], Swapped_N: ["바꾼 줄 {n} — 원본과 다름", "{n} swapped — differs from source"], - Gap_Note: ["저장하면 지금 값으로 굳음", "saving freezes current values"], - Price: ["단가 갱신", "Refresh prices"], - Regen: ["재생성", "Regenerate"], - Price_Ask: ["자원 단가만 지금 M01 값으로 — 식 · 연결 그대로", "Prices only — equation unchanged"], - Regen_Ask: ["지금 M01 수식 문서로 다시 찍음", "Re-copy from the current M01 equation"], - Regen_Lost: ["버리는 것", "Discarded"], - Regen_Edit: ["수식 고침", "Equation edits"], - Changed: ["바뀐 자원", "Changed resources"], - Before_After: ["계", "Sum"], Job_Done: ["적용함", "Applied"], Renew_Title: ["M01 이 바뀌어 다시 복사함", "Re-copied from updated M01"], Renew_Ask: [ diff --git a/A00_Common/line_stack_screen.ts b/A00_Common/line_stack_screen.ts index 89abd4681..693d37345 100644 --- a/A00_Common/line_stack_screen.ts +++ b/A00_Common/line_stack_screen.ts @@ -1,7 +1,7 @@ /* ============================================================================= * line_stack_screen.ts * 단가산출 「줄 쌓기」 탭(PLAN 804-2 · 요구 670~677) — 공용(M01 단가산출 기초 · M02 단가산출 = 길 앞머리만 바꿈) - * 위 = 옵션 가로(`formula_doc_options.ts`) · M02 사본 [단가 갱신] · [재생성] · 「M01 새 판」 배지(층 쓰기) + * 위 = 옵션 가로(`formula_doc_options.ts`) · M02 사본 배지(읽기만 · 지워짐) * `page` 있음(M01 804-7 · M02 804-8) = 저장 · 되돌림 단추 없음 — 페이지 [저장] · [되돌림]이 `save` · `discard` 를 부름 · * 고침이 바뀌면 `page()` · `page` 없음(일위대가 줄 모달 등) = 위에 [고침 버림] · [수식 저장] · * `tools` 있음(808-1) = 화면 단추를 페이지 머리 칸에 @@ -13,7 +13,6 @@ * M02 사본(`copy`) — 저장 몸 {문서, 끊음(받은 그대로), 판} · 판 바뀜(409)은 문서가 그대로면 새 판으로 한 번 더 * 기계 줄 · 옵션 가로 기계 = 기계 창(827-1 · 836-1 찾기 · 바꾸기만) · 기계 내부 값 = 왼쪽 기계 제어 구역(836-1 · * `line_stack_machine_ctl` — 문서 칸 `기계덮음` · 캐시 · [저장] 때 서버가 다시 셈) - * [단가 갱신] · [재생성] = 미리 셈 → 알림 → 저장(`formula_doc_copy.ts` · 고친 것 먼저 저장) * 저장 전 문서(`memory` · 836-5 · 불러오기 미리 보기) = 빈 키 + 서버에 문서째(`본`) 읽음 · 왼쪽 줄 쌓기는 보기만(inert) · 디스크 쓰기 0 * 층(848-3) — SK 읽기 · 미리 셈 답 `위덮음`(① 기초 고침) 을 셈 · 산출근거 · 제어 구역에 얹음(`layeredCover` · 화면 셈 = 서버 셈) · * M01 기초 = 시스템 관리자에게 제어 구역 엶 · 머리 [초기화] = 그 기초 기계 고침 전부 걷고 저장(확인창 목록) @@ -53,16 +52,7 @@ import { type StackDoc, type StackItem, } from "../common_util/common_util_line_stack"; -import { - askJob, - copyBadges, - copyTools, - type CopyJob, - type CopyMark, - type CopyOptions, - type JobReply, - swapBadge, -} from "./formula_doc_copy"; +import { copyBadges, type CopyMark, type CopyOptions, swapBadge } from "./formula_doc_copy"; import { docFoot } from "./formula_doc_foot"; import { askRenew, type RenewNote } from "./formula_doc_renew"; import { buildOptions, machineText } from "./formula_doc_options"; @@ -91,7 +81,7 @@ export interface StackScreenOptions { scope?: { layer: Layer; owner: string | null }; /** 페이지가 저장 · 되돌림을 맡음(M01 804-7 · M02 804-8) — 고침 있음이 바뀔 때 부름 · 화면 위 [고침 버림] · [수식 저장] 없음 */ page?: () => void; - /** 페이지 머리 칸(808-1 · 요구 701-3) — 있으면 [단가 갱신] · [재생성] 등 화면 단추를 여기에(화면 위 단추 줄 대신) */ + /** 페이지 머리 칸(808-1 · 요구 701-3) — 있으면 화면 단추를 여기에(화면 위 단추 줄 대신) */ tools?: HTMLElement; /** 저장 전 SK 문서(836-5 · 불러오기 미리 보기) — 빈 키일 때 이 문서를 서버가 읽어 줌(파일 안 읽음 · 안 씀) */ memory?: () => Record | null; @@ -253,7 +243,7 @@ export function createStackScreen(opt: StackScreenOptions) { if (mine !== seq) return; cache.merge(got.연결); cache.merge({ 문서: cut }); - if (got.사본) mark = got.사본; // 새로 읽은 줄 「사본 없는 줄 n」(826-3) + if (got.사본) mark = got.사본; if (got.위덮음) upper = got.위덮음; recalc(); draw(); @@ -384,7 +374,6 @@ export function createStackScreen(opt: StackScreenOptions) { const busy = dirty(); const tools = [ ...(basis() && opt.page ? [basisPick(basis()!)] : []), // 모달 = 머리 판 단추(793-3b) - ...(cp && edit() && key && !mark?.자동 ? copyTools(true, (job) => void runJob(job)) : []), // 836-2 자동 = 없음 ...(!cp && edit() && key && Object.keys(coverOf(doc)).length ? [resetBase()] : []), // 848-3 M01 기초 [초기화] ...(edit() && key && !opt.page ? [ @@ -510,25 +499,6 @@ export function createStackScreen(opt: StackScreenOptions) { }, }); - /** 사본 [단가 갱신] · [재생성] — 미리 셈 → 알림 → 저장(고친 것 먼저 저장 · 버림) */ - const runJob = async (job: CopyJob): Promise => { - if (!doc || !cp) return; - if (dirty()) return void showToast(ft("Dirty_First"), "warning"); - showLoadingOverlay(); - let got: JobReply; - try { - got = await call("/preview", { 할일: job }); - } catch (e) { - hideLoadingOverlay(); - return void showToast( - `${ft("Save_Failed")} — ${e instanceof Error ? e.message : ""}`, - "error", - ); - } - hideLoadingOverlay(); - if (await askJob(job, got, cache.names)) await save({ 할일: job, 판: version }, ft("Job_Done")); - }; - /** 가져온 식 [엑셀 단가 그대로] · [우리 단가로](807-1) — 저장(서버가 그 기준으로 다시 셈) */ const basisPick = (now: Basis): HTMLElement => { const seg = createSegment({ diff --git a/M02_MasterTemplete/M02_Doc_Copy.py b/M02_MasterTemplete/M02_Doc_Copy.py index a9e2b4b21..83a1a5b67 100644 --- a/M02_MasterTemplete/M02_Doc_Copy.py +++ b/M02_MasterTemplete/M02_Doc_Copy.py @@ -9,7 +9,7 @@ 따로(문서를 수식 길로 고침 — 옛 칸에서 다시 짓지 않음) · 위덮음(848-1 · ① 기초 `기계덮음` 사본 — 셈 cover = ① 위에 문서 `기계덮음`(②) · `cover_of`)} 셈 = `master_doc_calc.calc`(M01 과 같은 계산기) · 연결 = `master_doc_link.Links`(값 사본 색인 위) · -[단가 갱신] = 자원 단가 줄만 지금 M01(`skc.refresh`) · 문서 그대로 · [재생성] = 지금 M01 문서로. +[재생성](서버 안 · 서고 합치기 등) = 지금 M01 문서로. 부름 문서 = 색인이 실어 온 사본 문서 › M01 문서(`수식문서/`). 줄 규칙(요구 664 · 브레인 802-4a ④) = 일위대가 줄 옵션을 문서 안에 드러냄(`line_doc`) — 켜쌓기율 = 변수 `r_켜쌓기`(입력) · 금액 줄 수량 × r ÷ 100 · 고른 자재 = 그 줄 단가 기호 연결 @@ -415,12 +415,6 @@ def grow(copy: dict, values: dict | None, keys: list[str]) -> dict: return {**copy, **rows, "부름": closure(whole, keys, copy.get("부름"))} -def refresh(copy: dict) -> tuple[dict, list[dict]]: - """[단가 갱신] — 자원 단가 줄만 지금 M01 · 문서 그대로.""" - rows, changed = skc.refresh(values_of(copy), skc.whole_()) - return {**copy, **rows}, changed - - def state(copy: dict) -> dict[str, Any]: """{M01새판, 지운키, 단가새값, 문서새판} — 값 줄 · 부름 문서를 지금 M01 과 대조 (문서 = 계산 내용만 · 848-2 `doc_fp`).""" diff --git a/M02_MasterTemplete/M02_Doc_Router.py b/M02_MasterTemplete/M02_Doc_Router.py index 13db5efbd..43a8b9434 100644 --- a/M02_MasterTemplete/M02_Doc_Router.py +++ b/M02_MasterTemplete/M02_Doc_Router.py @@ -1,8 +1,7 @@ """M02 단가산출(SK) 수식 길(PLAN 802-4a 4) — `M02_Doc_Sk_Path` 를 층 권한 안에서. GET /api/m02/layers/{층}/sangeun/{키}/doc 읽기(층 읽기) → {문서, 부름, 끊음, 셈, 사본, 판} - POST /api/m02/layers/{층}/sangeun/{키}/doc/preview 미리 셈(층 쓰기) {문서?, 끊음?, 할일?} - → {…, 전, 후, 바뀐자원?, 버림?} + POST /api/m02/layers/{층}/sangeun/{키}/doc/preview 미리 셈(층 쓰기) {문서?, 끊음?} → {…, 전, 후} POST /api/m02/layers/{층}/sangeun/{키}/doc/save 저장(층 쓰기) {문서?, 끊음?, 할일?, 판} → 읽기 꼴 POST /api/m02/layers/{층}/sangeun/-/doc/read 저장 전 문서 읽기(층 읽기 · 836-5) {본} → 읽기 꼴 · 미리 셈 몸에도 `본` 가능 GET /api/m02/layers/{층}/sangeun/{키}/doc/machine?no= 기계 창(827-1 · 층 읽기) → {사본, 지금, 새값} diff --git a/M02_MasterTemplete/M02_Doc_Sk.py b/M02_MasterTemplete/M02_Doc_Sk.py index 24f7caa10..e2efd8069 100644 --- a/M02_MasterTemplete/M02_Doc_Sk.py +++ b/M02_MasterTemplete/M02_Doc_Sk.py @@ -279,7 +279,7 @@ def norm(copy: dict) -> dict: def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: """저장 꼴에 `수식` 을 정함 — 수식 길 저장(`NEW`) = 그 사본 · 따로 = 저장본(옛 칸 고침 409 · - 단가갱신 = 값만 · 재생성 = 파생으로) · 그 밖 = 다시 지음(부름 = 있던 것 · 재생성 = 새로 · 옛 엔진 안 돎) · + 재생성 = 파생으로) · 그 밖 = 다시 지음(부름 = 있던 것 · 재생성 = 새로 · 옛 엔진 안 돎) · 옛 칸 고침 파생 SK = 문서 없이 값 사본 · 부름만(못 셈).""" out = {k: v for k, v in out.items() if k != KEY} if not own(out): @@ -305,9 +305,8 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict: ) if dim.is_imported(out): return {**out, KEY: norm(have)} - copy = dc.refresh(have)[0] if job == skc.PRICE else have slim = skc.READS.get() is not None # 저장 관문이 셈 한 번으로 박음(826-3) - return {**out, KEY: norm(copy if slim else gap.fill(copy))} # 빈틈 = 지금 값(822-1) + return {**out, KEY: norm(have if slim else gap.fill(have))} # 빈틈 = 지금 값(822-1) # 빈 SK(바탕 · 줄 없음) = 빈 문서(요구서_664 0 장) · 수식 길로 고친 빈 SK = 위 따로(804-4) if skc.held(out) is None and not dim.is_imported(out): empty = seed(out) diff --git a/M02_MasterTemplete/M02_Doc_Sk_Path.py b/M02_MasterTemplete/M02_Doc_Sk_Path.py index 41abe67bb..7b9033b9b 100644 --- a/M02_MasterTemplete/M02_Doc_Sk_Path.py +++ b/M02_MasterTemplete/M02_Doc_Sk_Path.py @@ -2,13 +2,12 @@ M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} → {셈} · 저장 {문서} → {문서, 셈}. 몸 칸 — `문서`(이 SK 수식 문서 · 키 = SK 키) · `끊음` {키: 문서}(이 사본에 굳힌 부름 · 고칠 수 있음 · - 없는 키 = 다시 이음) · `할일` 단가갱신 | 재생성 · `판`(저장 · 그 SK 파일 판). + 없는 키 = 다시 이음) · `할일` 갱신확인(알림 확인 저장) · `판`(저장 · 그 SK 파일 판). 셈 = 서버 정본(`M02_Doc_Copy.run`) — 화면이 보낸 값 · 사본은 안 받음(문서 · 끊음 글만). 저장 = 그 SK 저장(`store.write` — 층 쓰기 권한 · 판 409 · 옛 칸 · 로직 사본 그대로) · - 문서 고침 = 따로(이 문서가 정본) · 재생성 = 지금 M01 로 다시 찍어 파생으로(고친 문서 · 끊음 버림) · - 단가갱신 = 값 줄만 지금 M01(문서 그대로). + 문서 고침 = 따로(이 문서가 정본) · 859-2 [단가 갱신] · [재생성] 할일 걷음(받으면 400). 가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음 - (형제 SK 는 셈 때 읽음) · 단가갱신 = 문서 그대로 · 바탕 참조 SK = 값 사본 없음(400). + (형제 SK 는 셈 때 읽음) · 바탕 참조 SK = 값 사본 없음(400). 저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`). 위 층 덮음(848-1) = 답 몸 칸 `위덮음`(① · 화면 셈 cover = `layeredCover(문서, 위덮음)`) · 문서 `기계덮음` = ② · 저장 = ② 를 ① + 정본과 견줘 같은 칸 지움(`prune_doc` 의 `upper`). @@ -34,7 +33,7 @@ from M02_MasterTemplete import M02_Sk_AutoRenew as renew import master_doc_cover as mcv # noqa: E402 — 기계 덮음(836-1 · scripts 길 = dc) MAX = 2_000_000 # 문서 글 크기(바이트) 상한 -JOBS = (skc.PRICE, skc.REGEN) +JOBS = (renew.CONFIRM,) # 859-2 단가갱신 · 재생성 걷음 def _bad(why: str, status: int = 400) -> store.StoreError: @@ -47,26 +46,32 @@ def _file(key: str) -> dict[str, Any]: return store.read(sd.KIND, key) -def _settled(doc: dict, job: Any = None) -> tuple[dict, Any]: +def _job(body: dict) -> Any: + job = body.get("할일") or None + if job not in (None, *JOBS): + raise _bad("할일은 갱신확인") + return job + + +def _settled(doc: dict) -> tuple[dict, Any]: """옛 셈 길 첫머리(`calc_doc`)와 같게 — (정리한 문서, 사본 색인).""" from M02_MasterTemplete import M02_Sangeun_Calc as calc - raw = {**doc, skc.JOB: job} if job else doc - whole = skc.over(doc := skc.settle(raw), skc.whole_()) # 내 기계(821-1) + whole = skc.over(doc := skc.settle(doc), skc.whole_()) # 내 기계(821-1) try: return sd.clean(doc, None, whole), whole except sd.DocError as e: raise calc._fail(e) from e -def current(doc: dict, job: Any = None) -> dict: - """그 SK 의 지금 수식 사본(할일 적용 · 저장 없음) — 따로 = 저장한 문서 · 파생 = 다시 지음(옛 엔진 안 돎) · +def current(doc: dict) -> dict: + """그 SK 의 지금 수식 사본(저장 없음) — 따로 = 저장한 문서 · 파생 = 다시 지음(옛 엔진 안 돎) · 옛 칸 고침 파생 SK = 400(못 셈 · 855 2-C1).""" if not dsk.own(doc): raise _bad(dsk.REF_WHY) - clean, whole = _settled(doc, job) + clean, whole = _settled(doc) if not dc.has(clean): # 옮기기 전 · 새 SK — 저장 때 지을 사본을 미리 - seed = dsk.settle(clean, whole, job, doc).get(dsk.KEY) + seed = dsk.settle(clean, whole, None, doc).get(dsk.KEY) if seed is None: raise _bad("수식 사본을 지을 수 없음 — 바탕 로직 · 줄 없음") clean = {**clean, dsk.KEY: seed} @@ -81,11 +86,7 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]: got = dsk.run(sk, copy) head = {k: copy.get(k) for k in ("시점", "단가시점")} mark = {**head, "따로": bool(copy.get("따로")), "자동": renew.on()} # 836-2 M01 자동 따라옴 - mark |= ( - {"단가기준": dim.basis_of(sk)} - if dim.is_imported(sk) - else {**dc.state(copy), "사본없음": len(gap.gaps(copy))} # 저장하면 지금 값으로 굳음 - ) + mark |= {"단가기준": dim.basis_of(sk)} if dim.is_imported(sk) else dc.state(copy) body = { "문서": copy["문서"], "위덮음": copy.get(dsk.UPPER) or {}, @@ -161,10 +162,6 @@ def _doc(raw: Any, key: str, where: str) -> dict: def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: """화면 고침 얹은 사본 — 문서 · 끊음 글만 받음(값 · 부름은 서버 것 · 가져온 식 = 부름 없음).""" - if body.get("할일") not in (None, "", *JOBS): - raise _bad("할일은 단가갱신 · 재생성") - if body.get("할일") == skc.REGEN: - return copy # 재생성 = 고친 것 버림(그 사본이 이미 새로 찍힌 것) out = {**copy} if body.get("문서") is not None: out["문서"] = _doc(body["문서"], key, "문서") @@ -204,7 +201,7 @@ def edited(copy: dict, body: dict, key: str, sk: dict | None = None) -> dict: def preview(key: str, body: dict) -> dict[str, Any]: - """미리 셈(저장 없음) — {셈, 전, 후, 바뀐자원?, 버림?} · 기계 창 초안(827-1) = 이 요청 안만 얹음.""" + """미리 셈(저장 없음) — {셈, 전, 후} · 기계 창 초안(827-1) = 이 요청 안만 얹음.""" with draft.overlay(body.get("문서")): return _preview(key, body) @@ -216,21 +213,10 @@ def _preview(key: str, body: dict) -> dict[str, Any]: else: doc = _file(key)["문서"] mine = _basis(doc, body) + _job(body) before = current(doc) - job = body.get("할일") or None - was = current(doc, job) if job else before - after = edited(was, body, key, doc) - out = answer(after, mine) - if not dim.is_imported(doc): # 고침으로 새로 읽은 줄 = 지금 값으로 셈 · 저장하면 굳음(826-3) - out["사본"]["사본없음"] += len(_rows(after) - _rows(was)) + out = answer(edited(before, body, key, doc), mine) out |= {"전": dc.money(dsk.run(doc, before)), "후": dc.money(out["셈"])} - if job == skc.PRICE and not dim.is_imported(doc): - out["바뀐자원"] = dc.refresh(before)[1] - if job == skc.REGEN: - out["버림"] = { - "문서고침": bool(before.get("따로")), - "끊음": sorted(before.get("끊음") or {}), - } return json.loads(json.dumps(dc.ml._norm(out), ensure_ascii=False, default=str)) @@ -265,11 +251,6 @@ def plain(mine: dict, sk: dict) -> dict: return got if same else mine -def _rows(copy: dict) -> set[str]: - rows = [*skc.plain(copy.get("로직")), *(copy.get("단가") or [])] # 로직 줄 안 셈(855 L2 ⓑ) - return {str(r.get("키")) for r in rows} - - def _basis(doc: dict, body: dict) -> dict: """가져온 식 단가기준 바꿈(807-1 · 몸 `단가기준` 엑셀 | 우리) — 그 밖 SK · 빈 값 = 그대로.""" want = body.get("단가기준") @@ -297,11 +278,11 @@ def machine(key: str, no: str) -> dict[str, Any]: def _save(key: str, body: dict, got: dict) -> dict[str, Any]: - job = body.get("할일") or None + job = _job(body) raw = {**_basis(got["문서"], body), **({skc.JOB: job} if job else {})} token = None - if job != skc.REGEN and (body.get("문서") is not None or body.get("끊음") is not None): - mine = plain(edited(current(got["문서"], job), body, key, got["문서"]), got["문서"]) + if body.get("문서") is not None or body.get("끊음") is not None: + mine = plain(edited(current(got["문서"]), body, key, got["문서"]), got["문서"]) token = dsk.SAVING.set({"키": key, "사본": mine}) try: store.write(sd.KIND, key, got["판"], raw) diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts index 2f33a4acd..57e4d84e7 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Text.ts @@ -43,8 +43,8 @@ const TEXT = { ], Ref_ReadOnly: ["이 층은 고칠 수 없음 — 읽기만", "Read-only layer"], Ref_Copy: [ - "프로젝트 사본 — 보기만 · 고침은 M02 단가산출에서 고쳐 [재생성]", - "Project copy — view only · edit the build-up in M02 and regenerate", + "프로젝트 사본 — 보기만 · 바꾸려면 M02 에서 고친 뒤 구조물 다시 지정", + "Project copy — view only · edit in M02, then re-assign the structure", ], Sk_NoCopy: ["사본에 이 단가산출 문서가 없음", "This copy has no build-up document"], Logic_Direct: [ diff --git a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts index 33aad305f..1e40a9408 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Sangeun_Detail.ts @@ -5,7 +5,7 @@ * 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만) * 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) — * 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 · - * M01 개정 = 자동 따라옴 알림(`갱신`) · 프로젝트 층 「M01 새 판」 · 짝 잃음 = 덮개 없음([재생성] 답이 알림) + * M01 개정 = 자동 따라옴 알림(`갱신`) * 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌 * ========================================================================== */ @@ -20,7 +20,6 @@ import { setLogicApiPaths, type LogicOne, } from "../M01_MasterData/M01_MasterData_UI_Logic_Api"; -import { isStale } from "../A00_Common/formula_doc_copy"; import type { StackAnswer } from "../A00_Common/line_stack_screen"; import { readTemplate, type Layer } from "./M02_MasterTemplete_Api_Fetch"; import { createSangeunTabs } from "./M02_MasterTemplete_Sangeun_Tabs"; @@ -76,7 +75,7 @@ export function bandsOf(got: StackAnswer | null): { const gaps = (a?.셈됨 ? (a.줄 ?? []) : []) .filter((r) => r.까닭 && r.금액 == null) .map((r) => ({ 이름: String(r.이름 ?? ""), 까닭: String(r.까닭) })); - const revised = !!m?.갱신?.length || (!m?.자동 && isStale(m)); + const revised = !!m?.갱신?.length; return { why, gaps, revised }; } diff --git a/M02_MasterTemplete/M02_Sangeun_Copy.py b/M02_MasterTemplete/M02_Sangeun_Copy.py index 5f4e21e4c..c0b181d5f 100644 --- a/M02_MasterTemplete/M02_Sangeun_Copy.py +++ b/M02_MasterTemplete/M02_Sangeun_Copy.py @@ -13,12 +13,12 @@ 사본 없는 SK(옛 SK · 바탕 참조) = 옛 길. 사본은 셈 · 저장 첫머리 `settle` 이 정함 — 저장본에 사본이 있으면 그것(화면이 보낸 것 버림) · 없으면 받은 사본(층 복사 · 새로 · 판 다시 셈) · 그것도 없으면 저장 때 새로 찍음. -할일 칸 `사본할일`(화면 캐시 · [저장] 때 적용): - 단가갱신 = 단가 줄만 지금 M01 값(지워진 키 = 그대로) · +할일 칸 `사본할일`(서버 안 · 서고 합치기 · 불러온 식 초기화 · [저장] 때 적용): + 단가갱신(`refresh` · 일위대가 `M02_Labor_Copy` 만 · 859-2 SK 걷음) = 단가 줄만 지금 M01 값(지워진 키 = 그대로) · 재생성 = 지금 M01 로 새로 찍음 — 덮개 · 식덮개 · 변수줄 · 상수 · 표값 · 까닭은 cid 열쇠라 새 사본에 그대로 얹힘 · 못 얹은 칸 = 짝잃음. 저장 때 = 사본에 없는 새 줄(더한줄 로직 더함 · 기초 바꿈)만 지금 M01 에서 더함. -미리 셈 = `M02_Doc_Sk_Path.preview`(몸 `할일` · 옛 `preview` 는 걷음 · 855 2-E2). +미리 셈 = `M02_Doc_Sk_Path.preview`(옛 `preview` 는 걷음 · 855 2-E2). 셈 답 덧칸 `사본` = {시점, 단가시점, M01새판, 지운키, 단가새값} · 같은 내용 지문 몫 = `same_part`. """ @@ -326,8 +326,6 @@ def settle(doc: Any, save: bool = False) -> Any: copy = _stored(doc.get("키")) or taken(held(doc)) if job == REGEN or (copy is None and save): copy = stamp(out) - elif job == PRICE and copy: - copy = refresh(copy, whole_())[0] if copy and any(isinstance(x, dict) and x.get("다시잇기") for x in out.get("더한줄") or []): copy = rejoin(copy, out["더한줄"]) if copy: @@ -339,26 +337,16 @@ def settle(doc: Any, save: bool = False) -> Any: def _formula_job(out: dict, job: Any) -> dict: - """수식 사본(802-4a · `M02_Doc_Sk`) 할일 — 재생성 = 파생으로(부름 새로 · 고친 문서 버림) · - 단가갱신 = 따로 문서의 값 줄도 지금 M01.""" + """수식 사본(802-4a · `M02_Doc_Sk`) 할일 — 재생성 = 파생으로(부름 새로 · 고친 문서 버림).""" from M02_MasterTemplete import M02_Doc_Copy as dc from M02_MasterTemplete import M02_Sk_AutoRenew as renew got = out.get(dc.KEY) if dc.has(out) else None - if got is None or job not in (PRICE, REGEN): + if got is None or job != REGEN: return out - if job == REGEN: # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림 - drop = ( - "문서", - "끊음", - "따로", - "처음", - "바탕문서", - *renew.KEEP, - ) # 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ) - got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}} - elif got.get("따로"): - got = dc.refresh(got)[0] + # 맡긴 기계 고침 · 옵션 값 · 지킨 칸 바탕(848-2)도 버림 · 바탕문서 = 프로젝트 굳힘(855 L2 ⓑ) + drop = ("문서", "끊음", "따로", "처음", "바탕문서", *renew.KEEP) + got = {k: v for k, v in got.items() if k not in drop} | {"부름": {}} return {**out, dc.KEY: got} diff --git a/resources/tester/test_795_1_sk_copy.py b/resources/tester/test_795_1_sk_copy.py index 97c8600e5..57afce5ad 100644 --- a/resources/tester/test_795_1_sk_copy.py +++ b/resources/tester/test_795_1_sk_copy.py @@ -1,7 +1,7 @@ # ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 """795-1 SK 로직 사본 — 저장 때 M01 닫힌 묶음을 찍고 셈은 사본으로(임시 storage · M01 은 메모리 덮개). -① M01 로직 줄 바꿔도 사본 SK 금액 그대로 ② 노임 바꿔도 [단가 갱신] 전엔 그대로 · 누르면 따라감 +① M01 로직 줄 바꿔도 사본 SK 금액 그대로 ② 노임 바꿔도 그대로(859-2 [단가 갱신] 걷음) ③ [재생성] 뒤 고친 칸 다시 얹힘 · 못 얹은 칸 알림 ④ M01 새 판 배지 ⑤ 지워진 키 = 마지막 값 ⑥ 옛 SK(사본 없음) = 옛 길 · 지문 그대로 ⑦ 가져온 식 SK 같은 규칙. """ @@ -14,7 +14,6 @@ import json import pytest from M01_MasterData import M01_MasterData_Store as m01 -from M02_MasterTemplete import M02_Doc_Sk_Path as path from M02_MasterTemplete import M02_Labor_Ref as refs from M02_MasterTemplete import M02_Library_Same as same from M02_MasterTemplete import M02_MasterTemplete_Store as store @@ -126,7 +125,7 @@ def test_copy_stamped_and_logic_change_kept(world, monkeypatch): def test_price_refresh_only_on_press(world, monkeypatch): - """② 노임 바꿈 → 그대로 · [단가 갱신] 미리 셈 · 저장 = 새 SK 와 같은 값 · 바뀐자원.""" + """② 노임 바꿈 → 그대로(859-2 [단가 갱신] 걷음).""" me = world["personal"] key = _sk(me, 바탕={"로직": PCT}) was = _sum(me, key) @@ -137,14 +136,6 @@ def test_price_refresh_only_on_press(world, monkeypatch): assert _sum(me, key) == was # 누르기 전 = 단가 기준 시점 값 fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 지금 M01 로 새로 찍은 SK assert fresh != was - with store.at(me): # 화면 [단가 갱신] 미리 셈 = 수식 길(옛 `skc.preview` 걷음 · 855 2-E2) - got = path.preview(key, {"할일": skc.PRICE}) - assert got["전"]["계"] == was and got["후"]["계"] == fresh - assert [x["키"] for x in got["바뀐자원"]] == [lb] - _save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [저장] = 서버가 할일 적용 - saved = _doc(me, key) - assert skc.JOB not in saved and _sum(me, key) == fresh - assert skc.held(saved)["단가시점"] >= skc.held(saved)["시점"] def test_deleted_keys_keep_last_value(world, monkeypatch): @@ -157,10 +148,6 @@ def test_deleted_keys_keep_last_value(world, monkeypatch): now = _calc(me, _doc(me, key)) assert now["기준"]["계"] == was assert {lb} <= set(now["사본"]["지운키"]) - with store.at(me): - got = path.preview(key, {"할일": skc.PRICE}) - assert {"키": lb, "이름": got["바뀐자원"][0]["이름"], "지워짐": True} in got["바뀐자원"] - assert got["후"]["계"] == was def test_old_sk_without_copy_old_path(world, monkeypatch): @@ -197,7 +184,7 @@ def _imported_row(): def test_imported_same_rule(world, monkeypatch): - """⑦ 가져온 식 SK(단가기준 우리) — 이음 노임 바꿔도 그대로 · [단가 갱신] 뒤 따라감.""" + """⑦ 가져온 식 SK(단가기준 우리) — 이음 노임 바꿔도 그대로.""" me = world["personal"] with store.at(me): key = imp.create(_imported_row(), None, "sub2임시 가져온")["이름"] @@ -211,7 +198,3 @@ def test_imported_same_rule(world, monkeypatch): row["값"] = row["값"] * 2 _fake(monkeypatch, [row]) assert _sum(me, key) == was - before = _calc(me, _doc(me, key))["기준"]["노무비"] - _save(me, key, {**_doc(me, key), skc.JOB: skc.PRICE}) # [단가 갱신] 뒤 [저장] = 할일 적용 - after = _calc(me, _doc(me, key))["기준"]["노무비"] - assert after == pytest.approx(before * 2, abs=1) diff --git a/resources/tester/test_802_4a_m02_doc.py b/resources/tester/test_802_4a_m02_doc.py index 73b84d251..a53f67079 100644 --- a/resources/tester/test_802_4a_m02_doc.py +++ b/resources/tester/test_802_4a_m02_doc.py @@ -2,8 +2,8 @@ """802-4a M02 단가산출 · 일위대가 · B09 사본 = 수식 문서 — 임시 storage · M01 은 메모리 덮개. ① 찍기 = M01 문서 사본(금액 = M01 문서 셈) ② 고침 = 사본 문서(M01 안 바뀜 · 옛 칸 고침 409) -③ [단가 갱신] = 자원 단가만(문서 그대로) ④ [재생성] = 지금 M01 문서 · 고친 것 버림 -⑤ 단가산출 연결 = [재생성] 때 따라감 · 끊기 = 사본 안에 굳힘 ⑥ SC · 일위대가 = 문서 셈(옛 금액 같음 · +(③ [단가 갱신] · ④ [재생성] = 859-2 걷음) +⑤ 단가산출 연결 = 부름 사본 · 끊기 = 사본 안에 굳힘 ⑥ SC · 일위대가 = 문서 셈(옛 금액 같음 · 줄 규칙 켜쌓기율 · 고른 자재 · 별도계상) ⑦ B09 사본 `수식.json` ⑧ 권한 ⑨ 지움 견딤 · 빈 SK 「—」. """ @@ -32,7 +32,7 @@ from resources.tester.test_795_1_sk_copy import ( _save, _sk, ) -from resources.tester.test_795_2_sc_copy import LB, PCT, _double, _labor, _sc +from resources.tester.test_795_2_sc_copy import PCT, _labor, _sc from resources.tester.test_795_2_sc_copy import _calc as _sc_calc from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 @@ -106,45 +106,11 @@ def test_edit_goes_to_copy_doc(world): assert e.value.status == 409 -def test_price_refresh_values_only(world, monkeypatch): - """③ [단가 갱신] = 자원 단가만 — M01 문서 바뀜은 안 따라감 · 바뀐자원 · 누르기 전 그대로.""" - me = world["personal"] - key = _sk(me, 바탕={"로직": PCT}) - was = _sum(me, key) - root = _at(me, path.read, key)["문서"] - _fake(monkeypatch, [_changed(_m01_doc(PCT)), _double(LB)]) - assert _sum(me, key) == was - pre = _at(me, path.preview, key, {"할일": "단가갱신"}) - assert [x["키"] for x in pre["바뀐자원"]] == [LB] and pre["문서"] == root - fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) # 새 문서 + 새 단가 - assert pre["후"]["계"] != was and pre["후"]["계"] != fresh - read = _at(me, path.read, key) - got = _at(me, path.save, key, {"할일": "단가갱신", "판": read["판"]}) - assert got["셈"]["계"] == pre["후"]["계"] == _sum(me, key) and got["문서"] == root - assert got["사본"]["단가새값"] is False and PCT in got["사본"]["문서새판"] - - -def test_regen_takes_m01_doc_drops_edits(world, monkeypatch): - """④ [재생성] = 지금 M01 문서로 · 고친 문서 버림(알림) · 파생으로 돌아감.""" - me = world["personal"] - key = _sk(me, 바탕={"로직": PCT}) - read = _at(me, path.read, key) - _at(me, path.save, key, {"문서": _twice(read["문서"], 1), "판": read["판"]}) - _fake(monkeypatch, [_changed(_m01_doc(PCT))]) - fresh = _sum(me, _sk(me, 바탕={"로직": PCT})) - pre = _at(me, path.preview, key, {"할일": "재생성", "문서": {"아무": "버려짐"}}) - assert pre["버림"]["문서고침"] is True and pre["후"]["계"] == fresh - read = _at(me, path.read, key) - got = _at(me, path.save, key, {"할일": "재생성", "판": read["판"]}) - assert got["사본"]["따로"] is False and got["셈"]["계"] == fresh == _sum(me, key) - assert got["사본"]["M01새판"] is False and got["사본"]["문서새판"] == [] - - CALLER, CALLED = "GC000006", "GC000267" # 가설울타리 강관 지주 → 굴착기(무한궤도) 시간당 -def test_link_follows_on_regen_unlink_freezes(world, monkeypatch): - """⑤ 단가산출 연결 = 부름 사본(M01 바뀌어도 그대로 · [재생성] 때 따라감) · 끊기 = 사본 안 고침.""" +def test_link_copy_unlink_freezes(world, monkeypatch): + """⑤ 단가산출 연결 = 부름 사본 · 끊기 = 사본 안 고침(859-2 [재생성] 걷음).""" me = world["personal"] key = _sk( me, 바탕={"로직": CALLER}, 단위="m" @@ -164,11 +130,6 @@ def test_link_follows_on_regen_unlink_freezes(world, monkeypatch): with pytest.raises(store.StoreError) as e: # 부르지 않는 키 끊기 _at(me, path.preview, key, {"끊음": {"GC999999": read["부름"][CALLED]}}) assert e.value.status == 400 - read = _at(me, path.read, key) - pre = _at(me, path.preview, key, {"할일": "재생성"}) - assert pre["버림"]["끊음"] == [CALLED] - got = _at(me, path.save, key, {"할일": "재생성", "판": read["판"]}) - assert got["끊음"] == {} and got["셈"]["계"] > was # 연결 = 새 원본 따라감 def test_sc_and_labor_use_doc(world, monkeypatch): diff --git a/resources/tester/test_804_4_line_stack_take.py b/resources/tester/test_804_4_line_stack_take.py index f129f2fae..957cecba7 100644 --- a/resources/tester/test_804_4_line_stack_take.py +++ b/resources/tester/test_804_4_line_stack_take.py @@ -12,7 +12,6 @@ from __future__ import annotations import json -import shutil from decimal import Decimal from pathlib import Path @@ -189,29 +188,20 @@ def test_권한_저장_단가갱신(world, monkeypatch): store.write("sangeun", target, file["판"], {**file["문서"], "이름": "sub3임시 이름바꿈"}) again = _norm(path.read(target)) assert again["셈"]["계"] == saved["셈"]["계"] and again["사본"]["따로"] - # M01 노임 바뀜 → [단가 갱신] 미리 셈 = 그 자원 단가 따라감(구조 · 품 그대로) — 값 줄 있는 SK(바탕 = 보통인부 든 로직) + # M01 노임 바뀜 → 개인 층 = 자동 따라옴(구조 · 품 그대로 · 859-2 프로젝트 [단가 갱신] 걷음) — 값 줄 있는 SK(바탕 = 보통인부 든 로직) other = _sk(me, 바탕={"로직": STONE}) with store.at(me): read = _norm(path.read(other)) g = _into(read["문서"], _take(me, _rid(sc))) with store.at(me): again = _norm(path.save(other, {"문서": g["문서"], "판": read["판"]})) - proj = me.parent / "p804" / "templates" # 프로젝트 층 사본 = 자동 따라옴 없음(836-2) - (proj / "sangeun").mkdir(parents=True) - shutil.copy(me / "sangeun" / f"{other}.json", proj / "sangeun" / f"{other}.json") row = dict(_live().get(LB)) row["값"] = row["값"] + 1000 _fake(monkeypatch, [row]) - with store.at(me): # 개인 층 = M01 자동 따라옴 — 금액이 이미 올라 있어 갈 바뀐자원 없음 - auto = _norm(path.preview(other, {"할일": "단가갱신"})) - assert not auto.get("바뀐자원") and auto["후"]["계"] > again["셈"]["계"] + 1000 * 0.3 - with store.at(proj): # 프로젝트 층 = [단가 갱신] 으로만 따라감 - got = _norm(path.preview(other, {"할일": "단가갱신"})) - assert any(x["키"] == LB for x in got["바뀐자원"]) - assert ( - got["후"]["계"] > again["셈"]["계"] + 1000 * 0.3 - ) # 보통인부 줄들(복사한 0.3 인 포함) 따라감 - assert got["문서"]["금액"] == again["문서"]["금액"] + with store.at(me): # 개인 층 = M01 자동 따라옴 — 보통인부 줄들(복사한 0.3 인 포함) 따라감 + auto = _norm(path.preview(other, {})) + assert auto["후"]["계"] > again["셈"]["계"] + 1000 * 0.3 + assert auto["문서"]["금액"] == again["문서"]["금액"] def test_끌어옮김_번지이름(world): diff --git a/resources/tester/test_804_6_formula_tab_gone.py b/resources/tester/test_804_6_formula_tab_gone.py index ae42fde34..390c223a8 100644 --- a/resources/tester/test_804_6_formula_tab_gone.py +++ b/resources/tester/test_804_6_formula_tab_gone.py @@ -58,9 +58,6 @@ def test_보기_수식은_줄쌓기_첫탭(): assert "createStackScreen({" in lab and "createDocScreen" not in lab -def test_줄쌓기가_사본_할일_이어받음(): +def test_줄쌓기_700_줄(): src = _text("A00_Common/line_stack_screen.ts") - assert "copyTools(true, (job) => void runJob(job))" in src - assert 'call("/preview", { 할일: job })' in src - assert "e.status !== 409" in src and "#끊음" not in src assert len(src.splitlines()) <= 700 diff --git a/resources/tester/test_804_7_line_stack_fix.py b/resources/tester/test_804_7_line_stack_fix.py index 566ae6e3e..88ae3a43d 100644 --- a/resources/tester/test_804_7_line_stack_fix.py +++ b/resources/tester/test_804_7_line_stack_fix.py @@ -207,10 +207,6 @@ def test_시험_페이지_걷음_화면_차림() -> None: def test_M02_수식탭_M01과_같은_단추_저장_한_번() -> None: """804-8 — M02 단가산출 수식 탭 = M01 과 같은 공용 화면 · 페이지 [되돌림] · [저장] 한 번 · 머리 줄 한 줄.""" screen = _src("A00_Common/line_stack_screen.ts") - assert ( - "...(cp && edit() && key && !mark?.자동 ? copyTools(true, (job) => void runJob(job)) : [])," - in screen - ) # 836-2 자동 층 = 단추 없음 · 프로젝트 층 = 있음 assert "notesOf" not in screen and "lstk__notes" not in screen # 못 고치는 칸 안내 줄 걷음 assert "Notes:" not in _src("A00_Common/line_stack_text.ts") tabs = _src("M02_MasterTemplete/M02_MasterTemplete_Sangeun_Tabs.ts") diff --git a/resources/tester/test_821_1_my_machine.py b/resources/tester/test_821_1_my_machine.py index 4399d291e..51500988d 100644 --- a/resources/tester/test_821_1_my_machine.py +++ b/resources/tester/test_821_1_my_machine.py @@ -147,15 +147,8 @@ def test_sk_copy_edit_refresh_delete(world): now = _calc(me, _doc(me, sk)) assert now["기준"]["계"] == was and now["사본"]["단가새값"] is True assert now["사본"]["지운키"] == [] - new = _at(me, mh.hourly, key)["계"] - look = _at(me, path.preview, sk, {"할일": skc.PRICE}) # 화면 [단가 갱신] 미리 셈(수식 길) - assert float(look["전"]["계"]) == float(was) and float(look["후"]["계"]) == new - assert [x["키"] for x in look["바뀐자원"]] == [key] - with store.at(me): # [저장] = 할일 적용 - got = store.read("sangeun", sk) - store.write("sangeun", sk, got["판"], {**got["문서"], skc.JOB: skc.PRICE}) - assert float(_sum(me, sk)) == new - assert _calc(me, _doc(me, sk))["사본"]["단가새값"] is False + assert _at(me, mh.hourly, key)["계"] != float(was) + new = float(was) # 859-2 [단가 갱신] 걷음 — 만든 SK 는 사본 값 그대로(내 기계 고침 안 따라감) # 층 사이 복사 — 사본이 따라감(받은 층에 그 내 기계 없음 · 마지막 값) other = layers.personal_dir(7, 43) moved = _at(other, skc.settle, {**_doc(me, sk), "키": "SK-999999"}) @@ -164,8 +157,7 @@ def test_sk_copy_edit_refresh_delete(world): assert gone["쓰는곳"] == [{"키": sk, "이름": "sub3임시 내기계"}] after = _calc(me, _doc(me, sk)) assert float(after["기준"]["계"]) == new and after["사본"]["지운키"] == [key] - look = _at(me, path.preview, sk, {"할일": skc.PRICE}) - assert look["바뀐자원"] == [{"키": key, "이름": NAME, "지워짐": True}] + look = _at(me, path.preview, sk, {}) assert float(look["후"]["계"]) == new diff --git a/resources/tester/test_821_3_my_machine_screen.py b/resources/tester/test_821_3_my_machine_screen.py index 1bbd5e1de..44de28212 100644 --- a/resources/tester/test_821_3_my_machine_screen.py +++ b/resources/tester/test_821_3_my_machine_screen.py @@ -133,10 +133,8 @@ def test_stack_line_copy(world): copy = _at(me, lambda: store.read("sangeun", sk)["문서"]["수식"]) assert key in [r["키"] for r in copy["단가"]] # 값 사본에 박힘 _at(me, mym.update, key, {**made["줄"], "값": {**made["줄"]["값"], "가격": 3000}}) - now = _at(me, path.read, sk) # 836-2 프로젝트 밖 SK = 자동 따라옴(새 값 배지 · 갱신 할 것 없음) + now = _at(me, path.read, sk) # 836-2 프로젝트 밖 SK = 자동 따라옴(새 값 배지 없음) assert now["셈"]["계"] > was and now["사본"]["자동"] and not now["사본"]["단가새값"] - job = _at(me, path.preview, sk, {"할일": "단가갱신"}) - assert job["바뀐자원"] == [] and job["후"]["계"] == now["셈"]["계"] _at(me, mym.delete, key) gone = _at(me, path.read, sk) assert gone["셈"]["계"] == was # 지운 키 = 저장한 사본 줄 값 diff --git a/resources/tester/test_822_1_copy_gap.py b/resources/tester/test_822_1_copy_gap.py index 73a80f6e7..9df51b0da 100644 --- a/resources/tester/test_822_1_copy_gap.py +++ b/resources/tester/test_822_1_copy_gap.py @@ -1,10 +1,10 @@ # ruff: noqa: F811 — 임시 층 fixture(world)를 test_m02_labor_ref 에서 받아 씀 """822-1 사본 빈틈 막기(요구 797-1) — 길마다: 만들기 → [저장] → M01 값(임시 · 메모리 덮개)을 -기계 가격 · 노임 · 유가 · 자재 값으로 바꿈 → 금액 그대로 + 「단가새값」 → [단가 갱신] → 반영. +기계 가격 · 노임 · 유가 · 자재 값으로 바꿈 → 금액 그대로 + 「단가새값」(859-2 [단가 갱신] 걷음). 길 = 수식 길 줄 쌓기(품셈 기계 · 바꿔 끼운 기계 · 자원 줄 · 단가산출 참조) · -옛 로직 길(더한줄 로직 · 재료 · 인력) · 가져온 식(단가기준 우리) · 층 복사 · [재생성] · -빈틈 SK 표시(`사본없음`). +옛 로직 길(더한줄 로직 · 재료 · 인력) · 가져온 식(단가기준 우리) · 층 복사 · +빈틈 SK(지금 값으로 셈 · 저장하면 굳음). M01 바꿈 = `skc.Copy` 아닌 진짜 색인 사본(`dc.base` 가 못 벗김) · 정본 파일 안 고침. """ @@ -19,7 +19,6 @@ from M01_MasterData import M01_MasterData_Store as m01 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 M02_MasterTemplete import M02_Sangeun_Copy as skc from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층 @@ -94,14 +93,6 @@ def _sum(folder, key): return _at(folder, path.read, key)["셈"]["계"] -def _price(folder, key) -> dict: - """[단가 갱신] 저장 — 바뀐 자원 키 · 뒤 금액.""" - look = _at(folder, path.preview, key, {"할일": skc.PRICE}) - 판 = _at(folder, path.read, key)["판"] - _at(folder, path.save, key, {"할일": skc.PRICE, "판": 판}) - return {"바뀐": sorted(x["키"] for x in look["바뀐자원"]), "후": _sum(folder, key)} - - MACHINE = {"갈래": "단가산출", "키": DIG_LOGIC, "입력": {"기계": f"'{DIG_NO}'"}} @@ -118,7 +109,7 @@ def _fuel_and_crew(no: str = DIG_NO) -> tuple[str, str]: @pytest.mark.parametrize("what", ["가격", "유가", "노임"]) def test_stack_m01_machine(world, monkeypatch, what): """품셈 기계(굴착기 1.0㎥) 줄 쌓기 → 저장 → 기계 가격 · 유가 · 조종원 노임 바뀜 → - 금액 그대로 + 단가새값 → [단가 갱신] → 반영.""" + 금액 그대로 + 단가새값.""" me = world["personal"] key = _sk(me) _stack(me, key, [("기계", MACHINE, "묶음")]) @@ -129,8 +120,6 @@ def test_stack_m01_machine(world, monkeypatch, what): _move(monkeypatch, moved) now = _at(me, path.read, key) assert now["셈"]["계"] == was and now["사본"]["단가새값"] is True - got = _price(me, key) - assert got["바뀐"] == [moved] and got["후"] > was def test_stack_swapped_machine(world, monkeypatch): @@ -148,12 +137,11 @@ def test_stack_swapped_machine(world, monkeypatch): other = _live().numbers["EQ"][DIG2_NO]["키"] _move(monkeypatch, other) assert _sum(me, key) == was - assert _price(me, key)["바뀐"] == [other] @pytest.mark.parametrize("kind", ["인력", "재료"]) def test_stack_resource(world, monkeypatch, kind): - """자원 줄 더하기(노임 · 자재 요소) — 저장 뒤 값 바뀌어도 그대로 · 갱신 뒤 반영.""" + """자원 줄 더하기(노임 · 자재 요소) — 저장 뒤 값 바뀌어도 그대로.""" me = world["personal"] res = MAN if kind == "인력" else next(iter(_live().index["MT"])) key = _sk(me) @@ -163,7 +151,6 @@ def test_stack_resource(world, monkeypatch, kind): assert was > 0 _move(monkeypatch, res) assert _sum(me, key) == was - assert _price(me, key)["바뀐"] == [res] def test_stack_logic_ref(world, monkeypatch): @@ -175,7 +162,6 @@ def test_stack_logic_ref(world, monkeypatch): assert was > 0 _move(monkeypatch, MAN) assert _sum(me, key) == was - assert MAN in _price(me, key)["바뀐"] # ── 옛 로직 길(더한줄 · 파생) ──────────────────────────────────────── @@ -207,9 +193,6 @@ def test_imported_ours(world, monkeypatch): was = _sum(me, key) _move(monkeypatch, MAN) assert _sum(me, key) == was - doc = _at(me, lambda: store.read("sangeun", key)) # [단가 갱신] 뒤 [저장] = 할일 적용 - _at(me, lambda: store.write("sangeun", key, doc["판"], {**doc["문서"], skc.JOB: skc.PRICE})) - assert _sum(me, key) > was def test_layer_copy_keeps_copy(world, monkeypatch): @@ -227,25 +210,9 @@ def test_layer_copy_keeps_copy(world, monkeypatch): assert _at(co, path.read, new["이름"])["사본"]["단가새값"] is True -def test_regen_follows_m01(world, monkeypatch): - """[재생성] — 지금 M01 로 다시 찍음(따로 문서 버림) · 그 뒤 M01 바뀌어도 그대로.""" - me = world["personal"] - key = _sk(me, 바탕={"로직": PCT}, 단위="㎡") - _stack(me, key, [("기계", MACHINE, "묶음")]) - _move(monkeypatch, MAN) - 판 = _at(me, path.read, key)["판"] - _at(me, path.save, key, {"할일": skc.REGEN, "판": 판}) - after = _at(me, path.read, key) - assert after["사본"]["따로"] is False and after["사본"]["사본없음"] == 0 - assert not after["사본"]["단가새값"] - was = after["셈"]["계"] - _move(monkeypatch, MAN) # 한 번 더(네 배) - assert _sum(me, key) == was - - def test_gap_mark_then_save_fills(world, monkeypatch): - """빈틈 있는 옛 SK — 열면 지금 값으로 셈 + 「사본없음 n」 · 일괄 고쳐 쓰지 않음 · - [저장] 하면 지금 값으로 굳음(n = 0) · 그 뒤 M01 바뀌어도 그대로.""" + """빈틈 있는 옛 SK — 열면 지금 값으로 셈 · 일괄 고쳐 쓰지 않음 · + [저장] 하면 지금 값으로 굳음 · 그 뒤 M01 바뀌어도 그대로.""" me = world["personal"] key = _sk(me) _stack(me, key, [("기계", MACHINE, "묶음")]) @@ -256,9 +223,7 @@ def test_gap_mark_then_save_fills(world, monkeypatch): vals[part] = [] # 옛 저장본 흉내 — 줄 쌓기 기계를 사본에 안 박은 때 file.write_text(json.dumps(raw, ensure_ascii=False), encoding="utf-8") before = file.read_bytes() - got = _at(me, path.read, key) - assert got["사본"]["사본없음"] > 0 - was = got["셈"]["계"] + was = _sum(me, key) assert file.read_bytes() == before # 열기 = 안 고쳐 씀 files, live = m01.loaded() _move(monkeypatch, DIG) @@ -266,7 +231,6 @@ def test_gap_mark_then_save_fills(world, monkeypatch): assert moved > was # 빈틈 = 지금 값으로 셈 got = _at(me, path.read, key) _at(me, path.save, key, {"문서": got["문서"], "판": got["판"]}) - now = _at(me, path.read, key) - assert now["사본"]["사본없음"] == 0 and now["셈"]["계"] == moved + assert _sum(me, key) == moved monkeypatch.setattr(m01, "loaded", lambda: (files, live)) # 앞 값(절반) assert _sum(me, key) == moved diff --git a/resources/tester/test_826_3_copy_slim.py b/resources/tester/test_826_3_copy_slim.py index 2cad8f582..9d60c98ae 100644 --- a/resources/tester/test_826_3_copy_slim.py +++ b/resources/tester/test_826_3_copy_slim.py @@ -2,8 +2,8 @@ """826-3 사본 = 셈이 실제로 읽은 줄만(요구 806 · 808) · SK 저장 길 한 번씩. 지킴: 사본 줄 = 읽은 줄(닫힌 묶음 수백 줄 → 열 줄 안팎) · 금액 = 닫힌 묶음 사본과 같음 · -M01 값 바뀌어도 그대로 · 옵션(기계) 바꿈 = 미리 셈 「사본없음 n」 + 지금 M01 값 → [저장] 때 박음 -(남은 줄 = 사본 값 그대로) · [단가 갱신] · [재생성] · 층 복사 · 일위대가 · 사전조합 사본도 · +M01 값 바뀌어도 그대로 · 옵션(기계) 바꿈 = 미리 셈 지금 M01 값 → [저장] 때 박음 +(남은 줄 = 사본 값 그대로) · 층 복사 · 일위대가 · 사전조합 사본도 · 옛 큰 사본 SK 그대로 읽힘 · 다음 [저장] 때 줄어듦 · 저장 한 번에 M01 모으기 0 · SK 파일 읽기 한 번. M01 바꿈 = 메모리 색인 사본(정본 파일 안 고침) · 층 = 임시 storage. """ @@ -31,7 +31,6 @@ from resources.tester.test_822_1_copy_gap import ( _at, _fuel_and_crew, _move, - _price, _sk, _stack, _sum, @@ -83,9 +82,8 @@ def test_base_logic_read_rows_only(world): assert _sum(me, key) == new["계"] -def test_m01_change_kept_then_price(world, monkeypatch): - """만든 뒤 M01(기계 · 유가 · 노임) 바뀜 → 금액 그대로 + 단가새값 → - [단가 갱신] → 반영 · 그래도 작음.""" +def test_m01_change_kept(world, monkeypatch): + """만든 뒤 M01(기계 · 유가 · 노임) 바뀜 → 금액 그대로 + 단가새값 · 사본 줄 그대로.""" me = world["personal"] key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") was = _sum(me, key) @@ -95,13 +93,11 @@ def test_m01_change_kept_then_price(world, monkeypatch): _move(monkeypatch, *moved) assert _sum(me, key) == was assert _at(me, path.read, key)["사본"]["단가새값"] is True - got = _price(me, key) - assert set(got["바뀐"]) == set(moved) and got["후"] > was assert set(_keys(skc.held(_file(me, key)))) == read def test_machine_swap_preview_then_save(world, monkeypatch): - """기계 바꿈(옵션) — 미리 셈 = 새 기계 지금 M01 값 + 「사본없음 n」 · [저장] = 새 줄만 박음 · + """기계 바꿈(옵션) — 미리 셈 = 새 기계 지금 M01 값 · [저장] = 새 줄만 박음 · 남은 줄(유가 · 노임) = 사본 값 그대로 · 안 읽는 옛 기계 줄은 빠짐.""" me = world["personal"] key = _sk(me) @@ -123,7 +119,6 @@ def test_machine_swap_preview_then_save(world, monkeypatch): if (var.get("연결") or {}).get("갈래") == "단가산출": var["연결"]["입력"] = {"기계": f"'{DIG2_NO}'"} look = _at(me, path.preview, key, {"문서": doc}) - assert look["사본"]["사본없음"] > 0 # 저장하면 지금 값으로 굳음 _at(me, path.save, key, {"문서": doc, "판": got["판"]}) after = _file(me, key) now = set(_keys(after["수식"])) @@ -142,21 +137,6 @@ def test_machine_swap_preview_then_save(world, monkeypatch): assert _sum(me, key) == amount # M01 되돌아가도 그대로 -def test_regen_slim(world, monkeypatch): - """[재생성] — 지금 M01 로 다시 찍어도 읽은 줄만 · 그 뒤 M01 바뀌어도 그대로.""" - me = world["personal"] - key = _sk(me, 바탕={"로직": DIG_BASE}, 단위="㎥") - read = [k for k in _keys(skc.held(_file(me, key))) if k[:2] in ("EQ", "MO")] - _move(monkeypatch, *read) - 판 = _at(me, path.read, key)["판"] - _at(me, path.save, key, {"할일": skc.REGEN, "판": 판}) - after = skc.held(_file(me, key)) - assert len(_keys(after)) <= 12 - was = _sum(me, key) - _move(monkeypatch, *read) - assert _sum(me, key) == was - - def test_layer_copy_slim(world, monkeypatch): """층 복사(개인 → 회사) — 받은 사본째 · 읽은 줄만 · 원본 M01 바뀐 뒤 복사해도 그 값.""" me, co = world["personal"], world["company"] @@ -250,7 +230,6 @@ def test_doc_path_save_keeps_both_slots(world): if var.get("열쇠") in ("Type", "지역"): var["연결"]["값"] = {"Type": "TypeⅢ", "지역": "경북"}[var["열쇠"]] look = _at(me, path.preview, key, {"문서": doc}) - assert look["사본"]["사본없음"] > 0 _at(me, path.save, key, {"문서": doc, "판": got["판"]}) after = _file(me, key) assert skc.KEY not in after # 층 파일 값 사본 = `수식` 한 벌(855 2-D) diff --git a/resources/tester/test_827_1_machine_window.py b/resources/tester/test_827_1_machine_window.py index 2b506ab56..d5e8824fd 100644 --- a/resources/tester/test_827_1_machine_window.py +++ b/resources/tester/test_827_1_machine_window.py @@ -181,8 +181,6 @@ def test_edit_mine_other_sk_new_value(world): assert _at(me, mym.rows)[0]["값"]["가격"] == 5000 and len(_at(me, mym.rows)) == 1 now = _at(me, path.read, first) assert now["셈"]["계"] == was and now["사본"]["단가새값"] is True - job = _at(me, path.preview, first, {"할일": "단가갱신"}) - assert [x["키"] for x in job["바뀐자원"]] == [key] and job["후"]["계"] == look["셈"]["계"] seen = _at(me, path.machine, first, f"'{no}'") assert ( seen["사본"]["값"]["가격"] == 1000 and seen["지금"]["값"]["가격"] == 5000 and seen["새값"] diff --git a/resources/tester/test_856_0_sk_screen.py b/resources/tester/test_856_0_sk_screen.py index a4a9a5002..5f5a92723 100644 --- a/resources/tester/test_856_0_sk_screen.py +++ b/resources/tester/test_856_0_sk_screen.py @@ -90,8 +90,8 @@ def test_head_bands() -> None: assert got["bands_why"]["banners"] == ["danger"] assert got["bands_why"]["texts"] == ["빈 문서 — 금액 줄 · 결과 없음"] assert got["bands_broken"]["texts"] == ["틀린 문서"] - # 프로젝트 층(자동 아님) 「M01 새 판」 = M01 개정 · 자동 따라옴 층은 알림 없으면 띠 없음 - assert got["bands_stale"]["banners"] == ["warning"] + # 프로젝트 층(자동 아님) 「M01 새 판」 표지 = 띠 없음(859-2) · 자동 따라옴 층도 알림 없으면 띠 없음 + assert got["bands_stale"]["banners"] == [] and got["bands_stale"]["badges"] == [] assert got["bands_auto_stale"]["banners"] == [] and got["bands_auto_stale"]["badges"] == [] # 못 읽음 = 빨강 하나(그 까닭) assert got["bands_fail"]["banners"] == ["danger"]