feat(859-2 ㉯): M02 단가산출 M01 따라옴 알림 = 토스트 한 번 — [확인] 창 · 머리 띠 · 배지 걷음

- 화면: 열 때 알림 창(표 · [위 값으로] · [확인] · [나중에]) → 토스트 「M01 기초가 바뀌어 반영됨」(+ 「내가 고친 칸 n 은 내 값 그대로」 · 「다시 못 얹은 내 고침 n」) · 확인 단추 없음
- 되풀이 막기: 서버 읽기 답 `사본.따라옴` = 저장본 대 지금 사본의 M01 몫 지문(값 판 · 부른 문서 · 바탕 판 · 문서 계산 내용 · 같으면 null) ·
  화면 localStorage(SK 길마다 {따라옴 지문, 알림 글}) — 새 지문 · 새 알림일 때만 · [저장] 하면 지문 없음
- 머리 띠 「바탕 단가산출 기초가 저장 뒤 바뀜」 · 배지 「M01 개정 — 확인」 · 「지워짐 n」 배지 걷음 · 글 키 걷음
- 서버: [확인] 저장 할일 `갱신확인`(`renew.CONFIRM` · form/_covers/_soft confirm 갈래) · 수식 길 `할일` 칸 걷음 ·
  읽기 답 바뀜 표지(M01새판 · 지운키 · 단가새값 · 문서새판 · 자동 = 열 때마다 dc.state 셈) 걷음
- 자동 반영 · 내 고친 칸 지킴(파란 테두리 · 풍선 「원래 값」) 그대로
- 시험: 836_2 ㉧ 토스트 지문(만든 뒤 없음 · 바뀜 = 같은 지문 · 저장 뒤 없음 · 또 바뀜 = 다른 지문) · 848_10 따로 문서 옵션 따라옴 = 지문 ·
  확인 저장 단언은 [저장] 꼴로 · test_confirm_clears 지움 · 읽기 답 표지 단언 걷음 · 856_0 띠 = 빠진 줄만

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-18 23:34:39 +09:00
co-authored by Claude Opus 5.5
parent 74d0c0c957
commit c4050ccf73
19 changed files with 162 additions and 264 deletions
-1
View File
@@ -26,7 +26,6 @@ router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Sangeun Doc"])
class DocBody(BaseModel):
문서: dict[str, Any] | None = None
끊음: dict[str, Any] | None = None
할일: str | None = None
판: str | None = None
단가기준: str | None = None # 가져온 식만(807-1 · 엑셀 | 우리)
본: dict[str, Any] | None = None # 저장 전 SK 문서째(836-5 · 파일 안 읽음 · 안 씀)
+1 -1
View File
@@ -295,7 +295,7 @@ def settle(out: dict, whole: Any, job: Any, raw: Any) -> dict:
file = stored(out.get("키")) or {}
have = file.get(KEY) if dc.has(file) else (raw.get(KEY) if dc.has(raw) else None)
have = (
upper(out, renew.form(out, have, confirm=job == renew.CONFIRM)) if have else have
upper(out, renew.form(out, have)) if have else have
) # 836-2 · ① 위 층 덮음(848-1) — 저장 때 굳음
if have and have.get("따로") and job != skc.REGEN:
if file and old_fp(file) != old_fp(out):
+9 -16
View File
@@ -2,10 +2,11 @@
M01 수식 문서 길과 같은 꼴: 읽기 {문서, 셈} · 미리 셈 {문서} → {셈} · 저장 {문서} → {문서, 셈}.
몸 칸 — `문서`(이 SK 수식 문서 · 키 = SK 키) · `끊음` {키: 문서}(이 사본에 굳힌 부름 · 고칠 수 있음 ·
없는 키 = 다시 이음) · `할일` 갱신확인(알림 확인 저장) · `판`(저장 · 그 SK 파일 판).
없는 키 = 다시 이음) · `판`(저장 · 그 SK 파일 판).
셈 = 서버 정본(`M02_Doc_Copy.run`) — 화면이 보낸 값 · 사본은 안 받음(문서 · 끊음 글만).
저장 = 그 SK 저장(`store.write` — 층 쓰기 권한 · 판 409 · 옛 칸 · 로직 사본 그대로) ·
문서 고침 = 따로(이 문서가 정본) · 859-2 [단가 갱신] · [재생성] 할일 걷음(받으면 400).
문서 고침 = 따로(이 문서가 정본) · 859-2 할일(단가갱신 · 재생성 · 갱신확인) 걷음.
읽기 답 `사본.따라옴`(859-2) = 저장 뒤 M01 몫이 바뀌어 따라옴 지문(화면 토스트 한 번) · 같으면 null.
가져온 식 SK(807-1) = 가져온 줄 문서 · 셈 = 단가기준(엑셀 값 · 연결 값) · 부름 · 끊음 없음
(형제 SK 는 셈 때 읽음) · 바탕 참조 SK = 값 사본 없음(400).
저장 전 문서(836-5 · 불러오기 미리 보기 835-1) = 몸 `본`(그 SK 문서째) — 파일 안 읽음 · 안 씀 · 읽기 · 미리 셈만(`read_memory`).
@@ -33,7 +34,6 @@ 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 = (renew.CONFIRM,) # 859-2 단가갱신 · 재생성 걷음
def _bad(why: str, status: int = 400) -> store.StoreError:
@@ -46,13 +46,6 @@ def _file(key: str) -> dict[str, Any]:
return store.read(sd.KIND, key)
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
@@ -85,8 +78,9 @@ def answer(copy: dict, sk: dict) -> dict[str, Any]:
"""{문서, 부름, 끊음, 셈, 사본 표지, 연결 기록} — 글 · 수는 JSON 꼴 · 가져온 식 표지 = 단가기준."""
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)
mark = {**head, "따로": bool(copy.get("따로"))}
if dim.is_imported(sk):
mark["단가기준"] = dim.basis_of(sk)
body = {
"문서": copy["문서"],
"위덮음": copy.get(dsk.UPPER) or {},
@@ -129,7 +123,8 @@ def read(key: str) -> dict[str, Any]:
got = _file(key)
copy = current(got["문서"])
out = {**answer(copy, got["문서"]), "판": got["판"], "층바탕": layers(copy, got["문서"])}
out["사본"]["갱신"] = renew.notes(got["문서"]) # 836-2 열 때 알림(지울 고침)
out["사본"]["갱신"] = renew.notes(got["문서"]) # 836-2 열 때 알림(지킨 칸 · 지울 고침)
out["사본"]["따라옴"] = renew.followed(got["문서"], copy) # 859-2 열 때 토스트 한 번
return out
@@ -213,7 +208,6 @@ def _preview(key: str, body: dict) -> dict[str, Any]:
else:
doc = _file(key)["문서"]
mine = _basis(doc, body)
_job(body)
before = current(doc)
out = answer(edited(before, body, key, doc), mine)
out |= {"전": dc.money(dsk.run(doc, before)), "후": dc.money(out["셈"])}
@@ -278,8 +272,7 @@ def machine(key: str, no: str) -> dict[str, Any]:
def _save(key: str, body: dict, got: dict) -> dict[str, Any]:
job = _job(body)
raw = {**_basis(got["문서"], body), **({skc.JOB: job} if job else {})}
raw = _basis(got["문서"], body)
token = None
if body.get("문서") is not None or body.get("끊음") is not None:
mine = plain(edited(current(got["문서"]), body, key, got["문서"]), got["문서"])
@@ -5,11 +5,10 @@
* 수식 먼저 → 판 · 수식 칸 새로) · ref(저장한 SK — 줄 쌓기 자기 저장 · 불러오기 저장 뒤) · memory(저장 전 가져온 식 · 보기만)
* 머리 띠(856-2) = 줄 쌓기 셈 답 · 문서 읽기 사본 표지(`onAnswer` · 서버 셈 길 안 부름) —
* 까닭(빨강) = 못 읽음 · 못 셈(서버 `M02_Sangeun_Calc.run` 「까닭」 과 같은 차례) · 빠진 줄 = 금액 없는 줄 까닭 ·
* M01 개정 = 자동 따라옴 알림(`갱신`)
* M01 개정 알림 = 줄 쌓기가 토스트 한 번(859-2 · 머리 띠 · 배지 없음)
* 옛 상세 몸(덮개 · 뺀줄 · 더한줄 · 재료 고름 · 줄 모달)은 856-1 에 걷음 — 고침은 줄 쌓기 한 벌
* ========================================================================== */
import { createBadge } from "@ui/ui_template_badge";
import { createBanner } from "@ui/ui_template_banner";
import { el } from "@ui/ui_template_elements";
import { createInputField } from "@ui/ui_template_input";
@@ -54,14 +53,12 @@ export interface SangeunDetailOptions {
const LIB = { read: "/m02/logic-lib", calc: "/m02/logic-lib" };
const clone = <T>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
/** 머리 띠 재료(856-2) — 못 셈 까닭 · 금액 없는 줄 · M01 개정 */
/** 머리 띠 재료(856-2) — 못 셈 까닭 · 금액 없는 줄 */
export function bandsOf(got: StackAnswer | null): {
why: string;
gaps: { 이름: string; 까닭: string }[];
revised: boolean;
} {
const a = got?.answer;
const m = got?.mark;
const marks = (a?.표지 ?? []).map((x) => `${x.갈래} — ${x.글}`).join(" · ");
const why =
got?.fail ||
@@ -75,8 +72,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;
return { why, gaps, revised };
return { why, gaps };
}
export function mountSangeunDetail(
@@ -103,7 +99,6 @@ export function mountSangeunDetail(
const head = el("div", { className: "m02-sk__head", attrs: { "data-sk-head": "" } });
const notes = el("div");
const flag = el("span"); // M01 개정 배지 자리(856-2 — 줄 쌓기가 그릴 때마다 머리 칸은 그대로)
let refreshing: Promise<void> = Promise.resolve();
const tabs = createSangeunTabs({
edit,
@@ -201,16 +196,15 @@ export function mountSangeunDetail(
el("div", {
className: "m02-sk__tags",
attrs: { "data-sk-base": baseKey() ?? "" },
children: [createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14), flag],
children: [createText(`${L("M02_SangeunBase")} · ${baseText}`, "muted", 14)],
}),
);
}
function drawNotes(): void {
const { why, gaps, revised } = bandsOf(got);
const { why, gaps } = bandsOf(got);
notes.replaceChildren(
...(fail || why ? [createBanner({ tone: "danger", text: fail || why })] : []),
...(revised ? [createBanner({ tone: "warning", text: L("M02_SangeunRevisedNote") })] : []),
...(gaps.length
? [
createBanner({
@@ -221,7 +215,6 @@ export function mountSangeunDetail(
]
: []),
);
flag.replaceChildren(...(revised ? [createBadge(L("M02_SangeunRevisedBase"), "danger")] : []));
}
function draw(): void {
+47 -24
View File
@@ -3,12 +3,13 @@
프로젝트 층 밖 SK(마스터 · 회사 · 개인) = 셈 · 열기 · 목록 · 일위대가 펼침이 모두
사본 줄 = 지금 M01(+ 층 내 기계) 줄(`rows` · 지운 키 = 값 사본 마지막 줄 — 층 파일 = `수식` 값 몫 한 벌 · 855 2-D) ·
부름 문서 = 지금 M01 수식 문서(`form`)로 봄 — 묻지 않음 · [단가 갱신] · [재생성] 없음.
파일(작업본)은 [저장] · 알림 [확인](= 저장 · `confirm`) 때만 새 것으로 씀 — 읽기 길은 안 씀.
파일(작업본)은 [저장] 때만 새 것으로 씀 — 읽기 길은 안 씀 · 열 때 알림 = 화면 토스트 한 번(859-2 ·
`followed` 지문 · 확인 단추 없음).
판정 = 칸 단위(848-2):
기계 고침(② `문서.기계덮음`) — 칸마다 「위 값」(① `위덮음` 그 칸 › ⓪ 기계 줄 그 칸)
바탕 대 지금 · 위가 바뀐 칸에 ② 가 있으면 ② 지킴 + 알림(처리 「지킴」) ·
② 없는 칸 = 조용히 따라옴(셈이 지금 줄 · 지금 ① 을 읽음) · 기계 줄 글 = 칸 아님.
바탕 = `덮음바탕`(지킨 칸만 · 알림 [확인] 까지) › 저장 사본 기계 줄 · 저장 `위덮음` ·
바탕 = `덮음바탕`(지킨 칸만) › 저장 사본 기계 줄 · 저장 `위덮음` ·
둘 다 없음(고르지 않아 사본 줄 없는 기계) = 바탕 모름 → 알림 없음 · ② 그대로
(다음 저장 때 지금 값이 바탕).
문서(따로 문서 · 끊음) — 계산 내용(`dc.doc_fp`)이 바뀐 것만 다시 복사 · 고쳐 둔 문서 =
@@ -17,7 +18,7 @@
M01 [전 → 후 글], 내고침 [글]} + 지킴 = {문서, 열쇠, 경로, 칸, 층(기계 · 기초), 전, 후, 내값} ·
다시복사 · 지워짐 = {다시얹음 [글]}.
가져온 식 SK = 값 줄만 따라옴(가져온 줄 문서 · 식 그대로) · 기계 고침 판정 같음(① = 저장 `위덮음`).
프로젝트 층 · B09 사본 = 그대로(사용자가 고르는 [단가 갱신] · [재생성]).
프로젝트 층 · B09 사본 = 그대로(바꾸려면 다시 지정 · 859-2).
"""
from __future__ import annotations
@@ -42,9 +43,8 @@ FIRST = "처음" # `수식` 칸 — 따로가 된 때의 문서(고침 판정
OPTS = (
"맡긴값" # `수식` 칸 — 다시 복사한 따로 문서의 옵션 값 {변수 열쇠: 값}(파생 문서에 다시 얹음)
)
BASE = "덮음바탕" # `수식` 칸 — 지킨 ② 칸의 바탕 {열쇠: {경로: 위 값}} · 알림 [확인] 때 걷음
BASE = "덮음바탕" # `수식` 칸 — 지킨 ② 칸 바탕 {열쇠: {경로: 위 값}} · 같아지면 빠짐
KEEP = (COVER, OPTS, BASE) # 파생 저장 때 `수식` 에 이어 실을 칸(`M02_Doc_Sk.settle`)
CONFIRM = "갱신확인" # 알림 [확인] 저장 할일
PICK = ("선택", "입력") # 옵션 변수 갈래
MAX_LINES = 8
_MEMO: dict[tuple, dict] = {}
@@ -57,7 +57,7 @@ FROZEN = "굳힘" # `수식` 표지 — 사본(구조물 · B09 서고 · 프
def frozen(copy: Any) -> bool:
"""굳은 사본의 수식 — 위덮음 · 문서 · 값을 실린 그대로 셈(자동 따라옴 안 함 · 855 2-D ·
사용자 원칙: 프로젝트는 M02 것을 복사해 가져감 · [재생성] · [단가 갱신] 전까지 그대로)."""
사용자 원칙: 프로젝트는 M02 것을 복사해 가져감 · 다시 지정 전까지 그대로)."""
return isinstance(copy, dict) and copy.get(FROZEN) is True
@@ -209,28 +209,26 @@ def _relabel(mine: dict, first: dict, live: dict) -> None:
old.update(fresh)
def _soft(mine: dict, first: dict, live: dict, held: set, opts: bool, confirm: bool):
def _soft(mine: dict, first: dict, live: dict, held: set, opts: bool):
"""따로 문서 — 위 기초가 옵션 기본 · 글만 바꿈(848-10) → (새 문서, 새 원본,
지킨 옵션 [(열쇠, 전, 후, 내값)]) · 계산 구조가 바뀜 = None(다시 복사).
옵션: 안 고른 열쇠 = 새 기본 따라옴(원본도) · 고른 열쇠 = 내 값 지킴 + 알림(원본 그대로 =
[확인] 까지 · 옛 칸 `입력값` 고름 = 알림 없이 지킴) · 글: 안 고친 줄만 새 글 ·
옵션: 안 고른 열쇠 = 새 기본 따라옴(원본도) · 고른 열쇠 = 내 값 지킴 + 알림(원본 그대로 ·
옛 칸 `입력값` 고름 = 알림 없이 지킴) · 글: 안 고친 줄만 새 글 ·
`opts` 거짓 = 계산 내용 그대로(글만 봄)."""
was, have, now = _opts(first), _opts(mine), _opts(live)
if opts and dc.doc_fp(put_opts(live, was)) != dc.doc_fp(first):
return None
mine, first = cp.deepcopy(mine), cp.deepcopy(first)
_relabel(mine, first, live)
follow, kept, ack = {}, [], {}
follow, kept = {}, []
for k, v in now.items() if opts else ():
if k not in was or mcv._canon(v) == mcv._canon(was[k]):
continue
if k in held or (k in have and mcv._canon(have[k]) != mcv._canon(was[k])):
kept += [] if k in held else [(k, was[k], v, have.get(k))]
ack[k] = v
else:
follow[k] = v
mine, first = put_opts(mine, follow), put_opts(first, {**follow, **(ack if confirm else {})})
return mine, first, [] if confirm else kept
return put_opts(mine, follow), put_opts(first, follow), kept
def _opt_note(key: str, doc: dict, kept: list) -> dict:
@@ -241,14 +239,14 @@ def _opt_note(key: str, doc: dict, kept: list) -> dict:
} # fmt: skip
def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) -> Any:
def form(sk: Any, got: Any, notes: list | None = None) -> Any:
"""수식 사본 → 지금 M01 으로 본 것(값 줄 · 부름) · 기계 고침 = 칸 단위 지킴(`_covers`) ·
계산 내용이 바뀐 고친 문서(끊음 · 따로) = 다시 복사(옵션 값 · ② 다시 얹음) ·
프로젝트 층 = 그대로 · `confirm` = 알림 [확인] 저장(바탕 걷음)."""
프로젝트 층 = 그대로."""
if not isinstance(got, dict) or not on() or not is_sk(sk) or frozen(got):
return got
out = rows(got) if "로직" in got else dict(got)
out = _covers(sk, got, out, notes, confirm)
out = _covers(sk, got, out, notes)
if imp.is_imported(sk):
return out # 가져온 식 = 값만(식 · 가져온 줄 그대로)
live = dc.folder()
@@ -265,7 +263,7 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) ->
if k in redo and dc.doc_fp(cut[k]) == dc.doc_fp(was):
cut.pop(k)
continue # 안 고친 끊음 = 조용히 따라옴
soft = _soft(cut[k], was, live[k], set(), k in redo, False) if was else None
soft = _soft(cut[k], was, live[k], set(), k in redo) if was else None
if soft is not None: # 옵션 기본 · 글만 바뀜 = 끊음 지킴 · 고른 옵션 알림(848-10)
cut[k] = soft[0]
if soft[2] and notes is not None:
@@ -285,11 +283,11 @@ def form(sk: Any, got: Any, notes: list | None = None, confirm: bool = False) ->
moved_doc = out.get("따로") and key in live and not dc.same_origin(base, live[key])
if out.get("따로") and key in live and out.get(FIRST) is not None:
held = set((sk.get("입력값") or {}) if isinstance(sk.get("입력값"), dict) else ())
soft = _soft(out["문서"], out[FIRST], live[key], held, bool(moved_doc), confirm)
soft = _soft(out["문서"], out[FIRST], live[key], held, bool(moved_doc))
if soft is not None: # 옵션 기본 · 글만 바뀜 = 다시 복사 없이 얹음(848-10)
mine, first, kept = soft
out |= {"문서": mine, FIRST: first}
if moved_doc and (confirm or not kept):
if moved_doc and not kept:
out["원본"] = {**base, "판": dc.doc_fp(live[key])}
if kept and notes is not None:
notes.append(_opt_note(key, mine, kept))
@@ -398,14 +396,13 @@ def _same(a: Any, b: Any) -> bool:
return mcv._canon(a) == mcv._canon(b)
def _covers(sk: dict, got: dict, out: dict, notes: list | None, confirm: bool) -> dict:
"""② 칸마다 위 값 바탕 대 지금 — 바뀐 칸 = ② 지킴 + 알림 · 바탕(`덮음바탕`)은 지킨 칸만 남김 ·
`confirm` = 바탕 걷음(알림 없음)."""
def _covers(sk: dict, got: dict, out: dict, notes: list | None) -> dict:
"""② 칸마다 위 값 바탕 대 지금 — 바뀐 칸 = ② 지킴 + 알림 · 바탕(`덮음바탕`)은 지킨 칸만 남김."""
doc = out.get("문서") if isinstance(out.get("문서"), dict) else None
cover = mcv.cover_of(doc) if doc is not None else out.get(COVER) or {}
held: dict = {} if confirm else got.get(BASE) or {}
held: dict = got.get(BASE) or {}
keep: dict = {}
if cover and not confirm:
if cover:
was, here = _eq_rows(got), _eq_rows(out)
up0, up1 = got.get(UPPER) or {}, _upper_now(sk, got)
for text, mine in cover.items():
@@ -480,6 +477,32 @@ def _note(key, was, now, lost, kind, name=None, again=()) -> dict:
}
def followed(sk: Any, now: Any) -> str | None:
"""열 때 토스트(859-2) — 저장본 대 지금 셈 사본의 M01 몫(값 줄 판 · 저장본이 부른 문서 · 바탕 문서 판 ·
이 문서 계산 내용)이 다르면 지금 지문 · 같으면 None · 프로젝트 층 · 굳은 사본 = None."""
if not on() or not is_sk(sk) or not dc.has(sk) or not isinstance(now, dict):
return None
was = sk[dc.KEY]
if not isinstance(was, dict) or frozen(was):
return None
def part(copy: dict) -> dict:
calls = copy.get("부름") or {}
return {
"값": [copy.get("판"), copy.get("단가판")]
if was.get("판") or was.get("단가판")
else None,
"부름": {k: dc.fp(calls.get(k)) for k in sorted(was.get("부름") or {})},
"원본": (copy.get("원본") or {}).get("판")
if (was.get("원본") or {}).get("판")
else None,
"문서": dc.doc_fp(copy.get("문서")) if isinstance(was.get("문서"), dict) else None,
}
got = part(now)
return None if part(was) == got else dc.fp(got)
def notes(sk: Any) -> list[dict]:
"""열 때 알림 — 이 SK 저장본의 지킨 칸 · 다시 복사 · 지울 고침(없으면 []) · 프로젝트 층 = []."""
if not is_sk(sk) or not dc.has(sk):