Merge remote-tracking branch 'origin/sub_laptop_1' into sub_laptop_8
This commit is contained in:
@@ -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<string, number | null> | 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<string, unknown>) : null;
|
||||
const b = r.후 && typeof r.후 === "object" ? (r.후 as Record<string, unknown>) : 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<string, string>): Promise<boolean> {
|
||||
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"));
|
||||
}
|
||||
|
||||
@@ -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: [
|
||||
|
||||
@@ -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<string, unknown> | 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
|
||||
? [
|
||||
@@ -511,25 +500,6 @@ export function createStackScreen(opt: StackScreenOptions) {
|
||||
},
|
||||
});
|
||||
|
||||
/** 사본 [단가 갱신] · [재생성] — 미리 셈 → 알림 → 저장(고친 것 먼저 저장 · 버림) */
|
||||
const runJob = async (job: CopyJob): Promise<void> => {
|
||||
if (!doc || !cp) return;
|
||||
if (dirty()) return void showToast(ft("Dirty_First"), "warning");
|
||||
showLoadingOverlay();
|
||||
let got: JobReply;
|
||||
try {
|
||||
got = await call<JobReply>("/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({
|
||||
|
||||
@@ -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`)."""
|
||||
|
||||
@@ -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 · 층 읽기) → {사본, 지금, 새값}
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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: [
|
||||
|
||||
@@ -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 };
|
||||
}
|
||||
|
||||
|
||||
@@ -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}
|
||||
|
||||
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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<JobReply>("/preview", { 할일: job })' in src
|
||||
assert "e.status !== 409" in src and "#끊음" not in src
|
||||
assert len(src.splitlines()) <= 700
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
|
||||
@@ -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["셈"]["계"] == now["셈"]["계"] # 지운 키 = 지우기 직전 따라온 값(요구 902)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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["새값"]
|
||||
|
||||
@@ -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"]
|
||||
|
||||
Reference in New Issue
Block a user