chore(853-2): 걸음 0 묶음 ① — 화면 0 서버 길 16 · 그 길만 부르던 본체 · 죽은 화면 래퍼 걷음

- 길: sangeun from-line · formula-check · copy · equation(셋) · block · labor copy · 프로젝트 양식 reset · apply · save-as · sources · drawing-import · drawing-fields · logic-lib machine-parts · logic-lib/auto
- 본체: Calc.from_line · Formula.check_doc 외 셋 · Equation 읽기 · 미리 셈 · Equation_Full 파일 · Block 끊기 · 잇기 · 수식 탭 · Labor_Copy.preview · Router_Layers 가져오기 도우미
- 화면: Api_Fetch 래퍼 여덟 · sangeunFromLine
- 시험: 죽은 길만 보던 796-2c · 796-2e 파일 지움 · 함수째 지움(715-3 · 733-2 · 792-1 · 796-2b · router_drawing · template_layers · structure_panel 글자 시험) · 살아 있는 결과는 [저장] 길로 고침(795-2 · 796-2b) · 813-2 = M01 parts.of_machine 바로
- 남김: Sangeun_Copy.preview(옛 엔진 셈 거울 — 걸음 2) · B07 이 쓰는 reset_project · B09 가 쓰는 _company_projects
- 검증: /openapi.json 524 → 508(뜻한 16 만) · 빌더 --check 같음 · 핵심 시험 99 통과 · 관련 시험 687 통과 · typecheck 0

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-17 11:36:15 +09:00
co-authored by Claude Opus 5.5
parent 45490575f8
commit b4f8515b5d
27 changed files with 43 additions and 1821 deletions
-37
View File
@@ -11,8 +11,6 @@ SK 사본(`M02_Sangeun_Copy` · 795-1) 한 벌 — 문서 칸 `사본` 꼴 ·
사본 정함(`settle` · 셈 · 저장 첫머리) = 받은 사본 먼저(열 복사 · 층 복사 = 원본 사본 그대로 · 판은
서버가 다시 셈) → 없으면 저장본(일위대가 = labor/<열> · SC = precombo/<키>) → [저장] 때 없으면 새로
찍음 · 사본에 없는 새 줄만 지금 M01 에서 더함 · 사본 없는 옛 문서 = 셈은 옛 길.
길(`M02_Labor_Router`) POST …/labor/{열 | SC 키}/copy/{price|regen} {doc, 수량?} →
{doc(사본할일), 전, 후, 바뀐자원 | 못얹은}(저장 없음).
짝(CLAUDE.md 5장 ①) `M02_MasterTemplete_Labor_Calc.ts` = 서버 기준 값을 받아 수량 · 반영 · 합만 —
사본은 기준 값에만 닿음(짝 안 고침 · 거울 시험 `test_795_2_sc_copy`).
"""
@@ -174,38 +172,3 @@ def combo(expand: Any, doc: dict, trail: tuple[str, ...]) -> dict[str, Any]:
def mark(ans: dict, doc: dict) -> dict:
"""셈 답 덧칸 `사본` {시점, 단가시점, M01새판, 지운키, 단가새값} — 사본 없음 = 칸 없음."""
return skc.mark(ans, doc)
# ── [단가 갱신] · [재생성] 미리 셈(저장 없음) ──────────────────────────
def _money(ans: dict) -> dict:
return {k: ans.get(k) for k in ("기준합", "반영합")}
def _lost(ans: dict) -> dict[str, dict]:
got = {}
for n, line in enumerate(ans.get("줄") or []):
for x in line.get("짝잃음") or []:
if isinstance(x, dict):
got[f"{n}|{x.get('cid')}"] = {**x, "줄": n}
return got
def preview(doc: dict, job: str, given: dict | None = None) -> dict[str, Any]:
"""{doc(할일 얹음), 전, 후, 바뀐자원 · 못얹은} — `doc` = 정리한 문서 · 재생성 ⊃ 단가갱신."""
from M02_MasterTemplete import M02_Labor_Doc as labor
new = REGEN if REGEN in (doc.get(JOB), job) else job
after_doc = {**doc, JOB: new}
before, after = labor.calc(doc, given), labor.calc(after_doc, given)
out: dict[str, Any] = {"doc": after_doc, "전": _money(before), "후": _money(after)}
if job == PRICE:
copy = skc.taken(doc.get(KEY)) or _stored(doc)
out["바뀐자원"] = skc.refresh(copy, skc.whole_())[1] if copy else []
else:
was = _lost(before)
out["못얹은"] = [
{"줄": x["줄"], "cid": x.get("cid"), "까닭": x.get("까닭") or "새 사본에 그 줄 없음"}
for c, x in _lost(after).items()
if c not in was
]
return out
-26
View File
@@ -58,32 +58,6 @@ def _calc(column: str, body: CalcBody) -> dict[str, Any]:
return {**got, "알약": labor.pills(doc)}
_JOBS = {"price": lc.PRICE, "regen": lc.REGEN}
@router.post("/layers/{layer}/labor/{column}/copy/{how}")
def labor_copy(
layer: Layer,
column: str,
how: str,
body: CalcBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""로직 사본(795-2) — price [단가 갱신] · regen [재생성] · 일위대가 열 · 사전조합 SC 키 ·
답 = 할일 얹은 doc(화면 캐시 · [저장] 때 서버가 적용) + 전 · 후 합 + 바뀐자원 | 못얹은."""
if how not in _JOBS:
raise HTTPException(status_code=404, detail="price · regen")
return _call(_root(session, layer, owner), _copy_job, column, body, _JOBS[how])
def _copy_job(column: str, body: CalcBody, job: str) -> dict[str, Any]:
"""미리 셈은 정리한 문서로 · 답 doc = 보낸 화면 문서 + 할일(SC · 일위대가 꼴 그대로)."""
got = lc.preview(_doc(column, body.doc), job, body.수량)
sent = body.doc if body.doc is not None else store.read("labor", column)["문서"]
return {**got, "doc": {**sent, lc.JOB: got["doc"][lc.JOB]}}
def _pills(column: str) -> dict[str, Any]:
return {"열": column, "알약": labor.pills(_doc(column, None))}
-7
View File
@@ -10,7 +10,6 @@ from __future__ import annotations
from fastapi import APIRouter, HTTPException
from M01_MasterData import M01_MasterData_Parts as parts
from M01_MasterData import M01_MasterData_Router as m01
from M02_MasterTemplete import M02_Machine_Hourly as machine
@@ -80,9 +79,3 @@ def get_machine_hourly(key: str) -> dict:
def get_machine_rows(keys: str) -> dict:
"""기계 창(827-1) — M01 기계 키 · 원문번호 쉼표 목록(60 까지) → 줄 값 + 시간당."""
return {"rows": machine.brief([k for k in keys.split(",") if k.strip()])}
@router.get("/machine-parts")
def get_machine_parts(no: str) -> dict:
"""줄 쌓기 기계 넣기(813-2) — 기계 원문번호 → 그 기종 작업량 틀(문서째)."""
return m01._call(parts.of_machine, no)
@@ -281,14 +281,6 @@ export interface StructureSheet {
도면: { entities: unknown[] } & Record<string, unknown>;
}
/** 시스템 층 구조물 도면 목록 */
export const listStructures = async (): Promise<TemplateInfo[]> =>
(await listTemplates("system", null)).filter((t) => t.종류 === "structure");
/** 새로 — 도번 자동 · 빈 도면 (+ 없으면 빈 면적산출 통합문서) · 이미 있으면 StaleError */
export const createStructure = (column: string): Promise<TemplateDoc> =>
scoped(`/structures/${enc(column)}`, { method: "POST" });
/** 한 열의 번호 — 도번 `SD` · 면적번 `SA` + 같은 8자리
* [종류][분류1][분류2][분류3](없는 쪽은 빈 글) */
export interface StructureNumbers {
@@ -382,11 +374,6 @@ export const clearPart = (
{ method: "POST" },
);
/** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */
export const copyStructure = async (column: string, from: string): Promise<void> => {
await scoped(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });
};
/** 면적산출 알약 하나 — 로직 물량 「이름|단위」(`로직` · `배`) · 자재 「자재|MT키」(`자재`) */
export interface LaborPill {
키: string;
@@ -401,11 +388,6 @@ export interface LaborPill {
export const fetchLaborPills = (column: string): Promise<{ 열: string; 알약: LaborPill[] }> =>
call(owned(activeLayer, `/layers/${activeLayer}/labor/${enc(column)}/pills`));
/** 다른 열(`from`) 면적산출 내용(알약 연결 포함)을 받는 열(`column`)로 가져옴 — 면적번 · 열은 그대로 */
export const copyArea = async (column: string, from: string): Promise<void> => {
await scoped(`/area/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });
};
/** 회사 · 개인 층의 집계표 항목(열 하나 + 도면 · 면적 파일)을 내 개인 층으로 복사 —
* 새 SS 키로 만들고 `본뜬` 표시 · `fromOwner` = 회사 층 회사 · 개인 층 「회사/사용자」 */
export const copyItemToPersonal = (body: {
@@ -418,27 +400,6 @@ export const copyItemToPersonal = (body: {
body: JSON.stringify({ from_layer: body.fromLayer, from_owner: body.fromOwner, key: body.key }),
});
/* --- 프로젝트 층 단추 다섯 --- */
const project = (id: string, tail: string): string => `/projects/${enc(id)}/templates/${tail}`;
const post = (path: string, body: object = {}): Promise<unknown> =>
call(path, { method: "POST", body: JSON.stringify(body) });
export const resetProject = (id: string): Promise<unknown> => post(project(id, "reset"));
export const applyToProject = (
id: string,
from: { from: Layer; user_id?: string; project_id?: string; 종류?: Kind; 이름?: string },
): Promise<unknown> => post(project(id, "apply"), from);
export const saveProjectAs = (
id: string,
to: "personal" | "company",
종류: Kind,
이름: string,
): Promise<unknown> => post(project(id, "save-as"), { to, 종류, 이름 });
export const fetchSources = (id: string): Promise<unknown> => call(`/projects/${enc(id)}/sources`);
/** 설계값을 채운 표 문서 — 서버가 그때그때 채움 · 저장 안 함 */
export const readFilled = (id: string, name: string): Promise<TemplateDoc> =>
call(`/projects/${enc(id)}/tables/${enc(name)}/filled`);
@@ -54,12 +54,6 @@ def get_logic(key: str) -> dict:
return _read(m01.logic, key)
@router.get("/logic-lib/auto", dependencies=[Depends(verify_session)])
def get_logic_auto(key: str) -> dict:
"""견본 입력 — 미리 보기용 자동값."""
return _read(m01.auto, key)
@router.get("/logic-lib/inputs", dependencies=[Depends(verify_session)])
def get_logic_inputs(keys: str = "") -> dict:
"""일위대가 입력 모달 — 로직 키들(쉼표)의 입력 목록 + 자동값(`M02_Labor_Inputs`)."""
@@ -1,97 +1,20 @@
"""M02 도면 양식 서버 길 — 외부 도각 파일 불러오기 · 자리표 키 목록 (PLAN 10-3).
"""M02 구조물 도면에 얹는 도각 길(`/structure-frame` · 56장) — B07 시스템 양식 도각을 그대로 다시 쓴다.
양식을 읽고 쓰는 길은 `M02_MasterTemplete_Router.py`(시스템 층)·`_Router_Layers.py`(층)가 맡는다.
여기는 도면 양식 편집 화면만 쓰는 두 길 — B07 의 불러오기 엔진 · 표제란 값을 그대로 다시 쓴다.
"""
import asyncio
import logging
from uuid import UUID
import ezdxf
from fastapi import APIRouter, File, UploadFile
from fastapi import APIRouter
from fastapi.responses import JSONResponse
from B07_DesignDetail.B07_DesignDetail_Engine_Frame_Import import import_frame_file
from B07_DesignDetail.B07_DesignDetail_Engine_Template import (
entities_bbox,
frame_document,
frame_entities,
frame_guide_area,
usable_bbox,
validate_template_entities,
)
from B07_DesignDetail.B07_DesignDetail_Router import title_block_fields
logger = logging.getLogger(__name__)
router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"])
# 도각 파일 상한 — A1 도각 한 장은 보통 1MB 아래다. 큰 도면 전체를 올리는 실수를 막는다.
_IMPORT_MAX_BYTES = 20 * 1024 * 1024
# 자리표 `{{키}}` 로 쓸 수 있는 키 — 도면을 그릴 때 채워지는 것만 둔다.
# 프로젝트 값은 B07 `title_block_fields` 가 · 도면 값은 도면을 그리는 엔진이 채운다.
DRAWING_FIELDS: tuple[tuple[str, str, str], ...] = (
("공사명", "프로젝트", "프로젝트 이름"),
("위치", "프로젝트", "사업 위치"),
("시행청", "프로젝트", "발주 기관"),
("연도기번", "프로젝트", "프로젝트 번호"),
("사업량", "프로젝트", "사업량"),
("설계일자", "프로젝트", "설계 일자"),
("용역회사", "프로젝트", "회사 이름"),
("설계자", "프로젝트", "설계자 이름"),
("과업책임자", "프로젝트", "과업책임자 이름"),
("분야별책임자", "프로젝트", "분야별책임자 이름"),
("회사로고", "프로젝트", "회사 로고 그림"),
("설계자서명", "프로젝트", "설계자 서명 그림"),
("과업책임자서명", "프로젝트", "과업책임자 서명 그림"),
("분야별책임자서명", "프로젝트", "분야별책임자 서명 그림"),
("도면명", "도면", "도면 이름"),
("도면번호", "도면", "도면 목록 순번"),
("축척_A1", "도면", "A1 축척 분모"),
("축척_A3", "도면", "A3 축척 분모"),
)
@router.post("/drawing-import")
async def import_drawing_file(file: UploadFile = File(...)) -> JSONResponse:
"""외부 도각 파일(DXF·DWG)을 읽어 **편집 화면에 실을 도면**으로 돌려준다 — 저장하지 않는다."""
try:
data = await file.read()
if not data:
raise ValueError("빈 파일입니다.")
if len(data) > _IMPORT_MAX_BYTES:
raise ValueError("도각 파일이 너무 큽니다(20MB 넘음).")
entities = await asyncio.to_thread(import_frame_file, file.filename or "", data)
validate_template_entities(entities)
return JSONResponse(
{
"status": "success",
"drawing": frame_document(entities),
"entity_count": len(entities),
}
)
except ValueError as exc:
return JSONResponse(status_code=400, content={"status": "error", "message": str(exc)})
except (OSError, UnicodeError, ezdxf.DXFError):
# 엉터리 파일 — 읽는 라이브러리가 ValueError 아닌 것으로 던짐(DXF 아님 · 글자 깨짐).
# 던진 글에 임시 폴더 경로가 섞여 있어 그대로 내지 않는다.
return JSONResponse(
status_code=400,
content={
"status": "error",
"message": "도각 파일을 읽지 못했습니다 — DXF 가 아니거나 깨진 파일입니다.",
},
)
except Exception:
logger.exception("M02 도각 불러오기 실패: %s", file.filename)
return JSONResponse(
status_code=500,
content={"status": "error", "message": "도각 파일을 읽지 못했습니다."},
)
# 얹은 도각 층 — 화면이 돌려줄 때 이 층을 통째로 뺌 · 불러온 DXF 층(`b08-frame`)과 갈라 둠
STRUCTURE_FRAME_LAYER = "m02-structure-frame"
@@ -138,23 +61,3 @@ def structure_frame(number: str | None = None, name: str | None = None) -> dict:
async def get_structure_frame(number: str | None = None) -> JSONResponse:
"""구조물 도면 상세 · 카드 미리보기가 얹는 도각(56장) · `number` = 장 도번(82-2)."""
return JSONResponse({"status": "success", **structure_frame(number)})
@router.get("/drawing-fields")
async def get_drawing_fields(project_id: UUID | None = None) -> JSONResponse:
"""자리표 키 목록. project_id 를 주면 그 프로젝트의 표제란 값도 함께(미리보기용)."""
try:
values = await title_block_fields(project_id) if project_id else {}
except Exception:
logger.exception("M02 자리표 값 조회 실패: project_id=%s", project_id)
values = {}
return JSONResponse(
{
"status": "success",
"fields": [
{"key": key, "source": source, "label": label}
for key, source, label in DRAWING_FIELDS
],
"values": values,
}
)
@@ -2,8 +2,7 @@
⚠ 등록은 `main.py`(로그인만) · 시스템 · 회사 · 개인 층 권한은 `M02_Layer_Access`(나무 · 항목 길과
한 벌 · PLAN 27-1c · `owner` = 회사 `{C}` · 개인 `{C}/{U}`) · 남의 층 목록 = `/layers/{층}/owners`:
project 같은 회사 프로젝트 · 작업본 쓰기 · `_initial/` 은 안 씀 ·
가져오기(apply · sources)는 같은 회사 사람 개인 층도 읽음
project 같은 회사 프로젝트 · 작업본 쓰기 · `_initial/` 은 안 씀
"""
from __future__ import annotations
@@ -15,7 +14,7 @@ from typing import Any, Literal
from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel, ConfigDict, Field
from pydantic import BaseModel
from B06_Section.B06_Section_Repository import (
get_cross_section_designs,
@@ -50,27 +49,6 @@ class SaveBody(BaseModel):
문서: dict[str, Any]
class TargetBody(BaseModel):
종류: str | None = None
이름: str | None = None
class ApplyBody(BaseModel):
model_config = ConfigDict(populate_by_name=True)
from_: Layer = Field(alias="from")
user_id: int | None = None
project_id: str | None = None
종류: str | None = None
이름: str | None = None
class SaveAsBody(BaseModel):
to: Literal["personal", "company"]
종류: str
이름: str
# ── DB (시험이 바꿔 끼움) ─────────────────────────────
@@ -89,16 +67,6 @@ async def _project_row(project_id: str) -> dict[str, Any] | None:
return dict(zip(keys, row, strict=True))
async def _user_company(user_id: int) -> int | None:
pool = get_db_pool()
async with pool.acquire() as connection, connection.cursor() as cursor:
await cursor.execute(
"SELECT company_id FROM users WHERE id = %s AND deleted_at IS NULL", (user_id,)
)
row = await cursor.fetchone()
return row[0] if row else None
async def _company_users(company_id: int) -> list[dict[str, Any]]:
pool = get_db_pool()
async with pool.acquire() as connection, connection.cursor() as cursor:
@@ -145,7 +113,6 @@ async def _cross_designs(project_id: str) -> list[dict[str, Any]]:
_is_system_admin = access.is_system_admin
_is_company_admin = access.is_company_admin
async def _project(session: dict[str, Any], project_id: str | None) -> dict[str, Any]:
@@ -170,15 +137,6 @@ def _company_of(session: dict[str, Any], project: dict[str, Any] | None) -> int:
return int(company_id)
async def _same_company_user(session: dict[str, Any], user_id: int, company_id: int) -> None:
"""남의 개인 양식 = 그 회사를 맡은 사람만(39-6 · 층 길과 한 규칙) · 그 회사 사람이어야 함."""
if user_id == session.get("user_id"):
return
access.grant(session, "personal", f"{company_id}/{user_id}")
if await _user_company(user_id) != company_id:
raise HTTPException(status_code=403, detail="같은 회사 사람의 양식만 볼 수 있습니다.")
async def _layer_dir(
session: dict[str, Any],
layer: str,
@@ -450,147 +408,6 @@ async def delete_layer_template(
# ── 프로젝트 길 ───────────────────────────────────────
@router.post("/projects/{project_id}/templates/reset")
async def reset_project_templates(
project_id: str,
body: TargetBody | None = None,
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
project = await _project(session, project_id)
target = body or TargetBody()
try:
done = await asyncio.to_thread(
layers.reset_project, project["root"], kind=target.종류, name=target.이름
)
except ValueError as error:
raise _bad(error) from error
return {"초기화": done}
@router.post("/projects/{project_id}/templates/apply")
async def apply_project_templates(
project_id: str,
body: ApplyBody,
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
"""다른 층 양식을 작업본에 덮어씀 — [회사 양식 적용] · [양식 가져오기].
`_initial/` 은 그대로 — 초기화 기준은 안 바뀜.
"""
project = await _project(session, project_id)
ref: dict[str, Any] = {}
if body.from_ == "project":
if not body.project_id or body.project_id == project_id:
raise HTTPException(status_code=400, detail="가져올 다른 프로젝트를 고르세요.")
other = await _project(session, body.project_id)
if other["company_id"] != project["company_id"]:
raise HTTPException(status_code=403, detail="같은 회사 프로젝트만 가져옵니다.")
source = layers.project_dir(other["root"])
ref = {"project_id": body.project_id, "프로젝트": other.get("name")}
elif body.from_ == "personal":
owner = body.user_id if body.user_id is not None else int(session["user_id"])
await _same_company_user(session, owner, int(project["company_id"]))
source = layers.personal_dir(project["company_id"], owner)
ref = {"user_id": owner}
elif body.from_ == "company":
source = layers.company_dir(project["company_id"])
else:
source = layers.system_dir()
try:
done = await asyncio.to_thread(
layers.copy_templates,
source,
layers.project_dir(project["root"]),
source_layer=body.from_,
kind=body.종류,
name=body.이름,
source_ref=ref,
)
except ValueError as error:
raise _bad(error) from error
if not done:
raise HTTPException(status_code=404, detail="가져올 양식이 없습니다.")
return {"적용": done, "from": body.from_}
@router.post("/projects/{project_id}/templates/save-as")
async def save_project_template_as(
project_id: str,
body: SaveAsBody,
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
"""작업본 한 벌을 [내 양식으로 저장] · [회사 공식으로 저장]."""
project = await _project(session, project_id)
if body.to == "company" and not _is_company_admin(session):
raise HTTPException(status_code=403, detail="회사 공식 양식은 회사 관리자만.")
if body.to == "company":
target = layers.company_dir(project["company_id"])
else:
target = layers.personal_dir(project["company_id"], session["user_id"])
try:
done = await asyncio.to_thread(
layers.copy_templates,
layers.project_dir(project["root"]),
target,
source_layer="project",
kind=body.종류,
name=body.이름,
source_ref={"project_id": project_id, "프로젝트": project.get("name")},
)
except ValueError as error:
raise _bad(error) from error
if not done:
raise HTTPException(status_code=404, detail="프로젝트 작업본에 그 양식이 없습니다.")
return {"저장": done, "to": body.to}
@router.get("/projects/{project_id}/sources")
async def list_sources(
project_id: str,
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
"""가져올 수 있는 것 — 시스템 · 회사 공식 · 같은 회사 사람 개인 · 같은 회사 다른 프로젝트."""
project = await _project(session, project_id)
company_id = int(project["company_id"])
def _people(users: list[dict[str, Any]]) -> list[dict[str, Any]]:
rows = []
for user in users:
found = layers.list_templates(layers.personal_dir(company_id, user["user_id"]))
if found:
rows.append({**user, "양식": found})
return rows
def _projects(projects: list[dict[str, Any]]) -> list[dict[str, Any]]:
rows = []
for other in projects:
if other["project_id"] == str(project_id) or not other.get("storage_path"):
continue
try:
root = Path(resolve_stored_project_path(other["storage_path"]))
except ValueError:
continue
found = layers.list_templates(layers.project_dir(root))
if found:
rows.append(
{"project_id": other["project_id"], "name": other["name"], "양식": found}
)
return rows
users = [ # 남의 개인 = 그 회사를 맡은 사람만(39-6)
u
for u in await _company_users(company_id)
if u["user_id"] == session.get("user_id") or access.manages(session, company_id)
]
projects = await _company_projects(company_id)
return {
"system": await asyncio.to_thread(layers.list_templates, layers.system_dir()),
"company": await asyncio.to_thread(layers.list_templates, layers.company_dir(company_id)),
"personal": await asyncio.to_thread(_people, users),
"project": await asyncio.to_thread(_projects, projects),
}
@router.get("/projects/{project_id}/tables/{name}/filled")
async def filled_table(
project_id: str,
@@ -1,8 +1,7 @@
/* =============================================================================
* M02_MasterTemplete_Sangeun_Cover.ts
* 단가산출(SK) 셈 길 부름 · 뺀 줄 띠(PLAN 717-2b · 717-3 · 724-1)
* · 셈 = `calcSangeun`(`POST /layers/{층}/sangeun/calc` · 저장 안 함 · 부르는 쪽이 최신 응답만 받음) ·
* [단가산출로 저장] = `sangeunFromLine`(`/sangeun/from-line`)
* · 셈 = `calcSangeun`(`POST /layers/{층}/sangeun/calc` · 저장 안 함 · 부르는 쪽이 최신 응답만 받음)
* · 고침 표는 공용 상세(`M01_MasterData_UI_LogicLab_Ho` · 724-1) — 여기는 뺀 줄 되살림 띠만
* ========================================================================== */
@@ -12,8 +11,7 @@ import { el } from "@ui/ui_template_elements";
import { t as L } from "@ui/ui_template_locale";
import { createText } from "@ui/ui_template_text";
import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
import { withSameAsk } from "./M02_MasterTemplete_Library_SameAsk";
import type { PatchRow, SkAnswer } from "./logic/M02_Sangeun_Cover_Model";
import type { SkAnswer } from "./logic/M02_Sangeun_Cover_Model";
import "./M02_MasterTemplete_Sangeun.css";
export interface SkScope {
@@ -37,21 +35,6 @@ export function calcSangeun<T = SkAnswer>(
});
}
/** [단가산출로 저장] — 그 층 새 SK · 답 = 새 키 + 그 SK 참조 줄 · 같은 내용이 있으면 물음(733-3 ·
* 그것을 씀 = 그 키 · 그래도 새로) · 취소 = null */
export const sangeunFromLine = (
scope: SkScope,
line: PatchRow & Record<string, unknown>,
이름: string,
단위: string,
): Promise<{ 이름: string; 줄: Record<string, unknown> } | null> =>
withSameAsk((extra) =>
call(`/layers/${scope.layer}/sangeun/from-line${q(scope)}`, {
method: "POST",
body: JSON.stringify({ 줄: line, 이름, 단위, ...extra }),
}),
);
/** 뺀 줄(cid · 이름) 띠 — 고칠 수 있으면 [되살림] */
export function removedStrip(
removed: { cid: string; 이름: string }[],
+2 -120
View File
@@ -8,22 +8,19 @@
[재생성] = 끊은 기초의 줄은 안 바꿈(자원 단가만 — 단가는 SK 사본 `단가` · [단가 갱신] 한 길).
다시 잇기 = `끊음` · `수식고침` 뗌 + 표지 `다시잇기`(서버만 · 셈·저장 첫머리 `Copy.settle` 이 그 기초가 닿는
닫힌 묶음을 지금 M01 줄로 갈음하고 표지 뗌 — 고친 것 버림).
길(`M02_Sangeun_Router`): POST …/sangeun/block/{unlink|relink} {문서, 차례} → {문서, 전, 후}(저장 없음) ·
POST …/sangeun/equation[/preview] 몸 `블록` = 더한줄 차례 → 그 끊은 기초의 수식(고침 통째 미리 셈).
화면 길(끊기 · 다시 잇기 · 끊은 기초 수식 탭)은 걷음(894) — 남은 것 = 저장 문서의 `끊음` · `수식고침` 꼴 · 셈.
저장 = SK [저장](서버가 다시 얹어 검사 · 셈 · 브라우저 값 안 받음 — 끊음 줄은 사본과 같은 `taken` 꼴 검사).
"""
from __future__ import annotations
from datetime import datetime
from typing import Any
from M02_MasterTemplete import M02_Item_Prices as prices
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
CUT, EDIT, REJOIN = "끊음", eqm.KEY, "다시잇기"
CUT, EDIT = "끊음", eqm.KEY
MANY = 400 # 끊은 기초가 닿는 줄 상한
_OWN: dict[int, tuple[Any, Any, Any]] = {}
@@ -95,118 +92,3 @@ def names(doc: Any) -> list[str]:
"""끊은 기초 이름들([단가 갱신] · [재생성] 보고)."""
adds = (doc.get("더한줄") if isinstance(doc, dict) else None) or []
return [str(x.get("이름") or x.get("로직")) for x in adds if is_block(x) and x.get(CUT)]
# ── 끊기 · 다시 잇기 ───────────────────────────────────────────────────
def _one(doc: Any, at: Any) -> dict:
adds = (doc.get("더한줄") if isinstance(doc, dict) else None) or []
if not isinstance(at, int) or isinstance(at, bool) or not 0 <= at < len(adds):
raise sd.DocError(f"더한 기초 차례 「{at}」 없음")
if not is_block(adds[at]):
raise sd.DocError("더한줄이 기초(로직) 아님")
return adds[at]
def _put(doc: dict, at: int, one: dict) -> dict:
return {**doc, "더한줄": [one if k == at else x for k, x in enumerate(doc["더한줄"])]}
def _closure(doc: dict, code: str) -> list[dict]:
"""`code` 가 닿는 닫힌 묶음(자원 단가 빼고) — 사본 있으면 사본 줄 그대로 · 없으면 지금 M01."""
over = doc[skc.KEY]["로직"] if skc.has(doc) else None
got = prices.collect([code], None, None, over)
got.pop("_빠진", None)
whole = skc.over(doc, skc.whole_())
keys = [str(r.get("키")) for data in got.values() for r in data[prices.m01.items_key(data)]]
rows = [
whole.index[k[:2]][k]
for k in keys
if k[:2] not in skc.RES and k in whole.index.get(k[:2], {})
]
return prices.to_json(rows)
def unlink(doc: Any, at: int) -> dict:
"""[연결 끊기] — 그 기초가 닿는 닫힌 묶음을 이 SK 안에 굳힘(금액 그대로)."""
one = _one(doc, at)
if one.get(CUT):
raise sd.DocError("이미 연결을 끊은 기초")
if any(one.get(k) not in (None, {}, []) for k in sd.BODY):
raise sd.DocError("넣은 SK 몸은 이미 이 SK 안 사본 — 연결 끊기 없음")
rows = _closure(skc.settle(doc), str(one["로직"]))
if not rows:
raise sd.DocError(f"기초 「{one['로직']}」 줄을 못 찾음")
cut = {"시점": datetime.now().isoformat(timespec="seconds"), "로직": rows}
return _put(doc, at, {**one, CUT: cut})
def relink(doc: Any, at: int) -> dict:
"""[다시 잇기] — 끊음 · 고침 버림 + 표지(셈·저장 때 사본을 지금 M01 줄로 갈음)."""
one = _one(doc, at)
if not one.get(CUT):
raise sd.DocError("연결된 기초")
keep = {k: v for k, v in one.items() if k not in (CUT, EDIT)}
return _put(doc, at, {**keep, REJOIN: True})
def change(doc: Any, at: Any, how: str) -> dict:
"""길 몸 — {문서, 전, 후}(전후 SK 금액 · 끊기 전후 같음)."""
from M02_MasterTemplete import M02_Sangeun_Equation_Full as full
new = (unlink if how == "unlink" else relink)(doc, at)
money = [full.total(full.answer(d, None)) for d in (doc, new)]
return {"문서": new, "전": money[0], "후": money[1]}
# ── 수식 탭 ────────────────────────────────────────────────────────────
def _setup(doc: Any, at: Any) -> tuple[dict, Any, dict]:
if not isinstance(doc, dict):
raise sd.DocError("단가산출 문서가 묶음 아님")
one = _one(doc, at)
if not one.get(CUT):
raise sd.DocError("연결된 기초 — 먼저 [연결 끊기]")
doc = skc.settle(doc)
return doc, skc.over(doc, skc.whole_()), doc["더한줄"][at]
def view(whole: Any, doc: dict, one: dict, edits: list | None, inputs: dict | None) -> tuple:
"""(수식, 못 얹은 까닭) — 고친 줄을 그대로 그림(세부 덮개 · 뺀줄 얹기 전 = 고침 주소 그대로)."""
row, why, mine = row_of(whole, one, edits)
if why:
return None, why
code = str(one["로직"])
given = {k: v for k, v in (one.get("입력값") or {}).items() if str(v).strip()}
given = {**(doc.get("입력값") or {}), **(inputs or {}), **given}
return eqm.export(mine, {**row, "키": code}, given), []
def read(doc: Any, at: Any, inputs: dict | None = None) -> dict[str, Any]:
"""{ok, 수식 | reason} — 끊은 기초 수식(자기 고침 얹음)."""
doc, whole, one = _setup(doc, at)
eq, why = view(whole, doc, one, None, inputs)
return {"ok": False, "reason": " · ".join(why)} if why else {"ok": True, "수식": eq}
def preview(doc: Any, at: Any, edits: list, inputs: dict | None = None) -> dict[str, Any]:
"""고침 통째 미리 셈(저장 없음) — {되나, 까닭, 줄, 수식, 전(기초 고침 없음), 후, 금액전, 금액후(SK)}."""
from M02_MasterTemplete import M02_Sangeun_Equation_Full as full
doc, whole, one = _setup(doc, at)
eq, why = view(whole, doc, one, edits, inputs)
if why:
return {"되나": False, "까닭": why}
bare = {k: v for k, v in one.items() if k != EDIT}
mine = {**bare, EDIT: edits} if edits else bare
plain = view(whole, doc, bare, None, inputs)[0] if edits else eq
row = row_of(whole, bare, edits)[0]
money = [full.total(full.answer(d, inputs)) for d in (doc, _put(doc, at, mine))]
return {
"되나": True,
"까닭": [],
"줄": {**row, "입력": []}, # 입력 칸 = SK 쪽 것만(끊은 기초 입력은 더한 기초 자리에서)
"수식": eq,
"전": plain["합계"],
"후": eq["합계"],
"금액전": money[0],
"금액후": money[1],
}
-22
View File
@@ -612,25 +612,3 @@ def calc_doc(doc: Any, given: dict | None = None, seen: bool = True) -> dict[str
except sd.DocError as e:
raise _fail(e) from e
return skc.mark(const.answer(got, clean, doc, given, (me,)), clean) # 790-2 · 795-1
def from_line(
line: Any, name: str, unit: str, new: bool = False, use: str | None = None
) -> dict[str, Any]:
"""[단가산출로 저장](715-3) — 일위대가 줄(바탕 · 입력값 · 고름 · 줄 덮개) → 지금 층 새 SK ·
답 = `{이름: 새 키, 줄: 그 SK 참조 줄}`(일위대가 문서는 화면 [저장] 때 바뀜) ·
같은 층 같은 내용 SK = 409(733-2) → `new` 그래도 새로 · `use` 그 SK(새로 안 만듦)."""
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_Labor_Patch as patch
from M02_MasterTemplete import M02_Library_Ask as ask
if not isinstance(line, dict):
raise store.StoreError(400, "줄이 묶음 아님")
doc = patch.to_sangeun(line, name, unit, m01.loaded()[1])
key = ask.ask(sd.KIND, doc, new, use) or refs.create(sd.KIND, doc)["이름"]
at = refs.here()
keep = {k: line[k] for k in ("별칭", "메모", "수량") if k in line}
return {
"이름": key,
"줄": {"참조": {"층": at[0], "주인": at[1], "키": key}, **keep},
}
+2 -89
View File
@@ -8,16 +8,9 @@
모든 셈 길(화면 · 저장 원값 · B09 · 펼침) 같은 줄 · 못 얹은 고침(재생성 뒤 자리 없음 등) =
고침 없는 바탕 + 짝잃음 cid `수식` · 저장(`strict`) = 400 · [재생성] = 새 사본에 같은 고침
다시 얹음(못 얹음 = 795-1 `못얹은`).
길(`M02_Sangeun_Router` · 저장 없음):
POST …/sangeun/equation {문서, inputs?} → {ok, 수식 | reason}(층 읽기)
POST …/sangeun/equation/preview {문서, inputs?, 고침} → {되나, 까닭, 줄, 수식, 전, 후}
(고침 = `수식고침` 통째 · 전 = 고침 없는 사본 합계 · 층 쓰기)
저장 = SK [저장](화면 캐시 `수식고침` → `clean_doc` 이 다시 얹어 검사 · 셈 ·
브라우저 값 안 받음).
수식 탭 화면 길(읽기 · 미리 셈 · 합계 소계)은 걷음(894) — 남은 것 = 저장 문서 `수식고침` 꼴 · 셈 · 저장 검사.
저장 = SK [저장](`clean_doc` 이 다시 얹어 검사 · 셈 · 브라우저 값 안 받음).
바탕 참조 SK(`바탕.참조`) = 수식 없음(바탕 SK 의 고침은 그 SK 가 얹음).
합계 · 소계(796-2c) = SK 셈 답 기준(`M02_Sangeun_Equation_Full` — 더한 기초 · 뺀줄 · 덮개 · 율 줄 ·
합밖) · 줄 값 = 식 덮개 · 상수 · 표값 · 변수줄을 얹은 식(고침 주소는 바탕 차례 그대로) ·
전 = 고침 없는 SK 금액.
"""
from __future__ import annotations
@@ -78,15 +71,6 @@ def _stand(row: dict) -> tuple[dict, str]:
return (row, key) if key[:2] in ("GC", "GF", "GX") else ({**row, "키": STAND}, key)
def export(whole: Any, row: dict, inputs: dict | None) -> dict:
"""수식 읽기 — 입력 = 받은 값 › 자동값(SK 셈 `run_line` 과 같음 · 기본 제안값이 안 덮음)."""
stand, key = _stand(row)
eqn = _eqn()
auto = eqn.meq.ma.values(eqn.me.swap(whole, stand), stand)
given = {**{k: v for k, v in auto.items() if v is not None}, **(inputs or {})}
return eqn.export_row(whole, stand, given) | {"열쇠": key}
def apply(row: dict, edits: list, whole: Any) -> tuple[dict, list[str]]:
"""바탕 줄 + 고침 → (새 줄, 까닭) — 같은 줄 · 같은 고침 = 메모(셈 길마다 다시 검사 안 함)."""
tag = (_hash(row), _hash(edits))
@@ -116,74 +100,3 @@ def strict(base: dict) -> None:
for x in base.get("짝잃음") or []:
if x.get("cid") == LOST and "바탕" not in x:
raise sd.DocError(x["까닭"])
# ── 길 ──────────────────────────────────────────────────────────────
def _plain(doc: Any) -> tuple[dict, Any, dict]:
"""(정한 문서, 사본 색인, 고침 없는 바탕 줄) — 바탕 참조 · 빈 SK = DocError."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if not isinstance(doc, dict):
raise sd.DocError("단가산출 문서가 묶음 아님")
base = doc.get("바탕") or {}
if "참조" in base:
raise sd.DocError("바탕 참조 단가산출 — 수식은 바탕 단가산출에서")
doc = calc.skc.settle(doc)
whole = calc.skc.over(doc, calc.labor.m01.loaded()[1])
bare = {k: v for k, v in doc.items() if k != KEY}
row = calc._base_of(bare, whole, calc.refs.read_ref, ())["줄"]
if not row.get("중간") and not row.get("호표") and not row.get("결과"):
raise sd.DocError("수식 없음 — 바탕 로직 · 가져온 식이 없는 단가산출")
return doc, whole, row
def _tree(doc: dict, whole: Any, base: dict, inputs: dict | None, ans: dict | None) -> dict:
"""수식 = 바탕 줄(+ 고침 · 식 덮개 · 상수 · 표값 · 변수줄) + SK 셈 답 합계 · 소계(796-2c)."""
from M02_MasterTemplete import M02_Sangeun_Const as const
from M02_MasterTemplete import M02_Sangeun_Equation_Full as full
try:
shown = const.formulas(base, doc)
except Exception: # noqa: BLE001 — 틀린 식 덮개 = 바탕 그대로(짝잃음은 셈 길이 알림)
shown = base
return full.attach(export(whole, shown, inputs), doc, whole, base, inputs, ans)
def read(doc: Any, inputs: dict | None = None) -> dict[str, Any]:
"""{ok, 수식} — 저장본 · 화면 캐시 고침 얹은 수식(못 얹음 = 바탕 그대로 + 까닭)."""
from M02_MasterTemplete import M02_Sangeun_Equation_Full as full
eqn = _eqn()
try:
doc, whole, row = _plain(doc)
now, lost = on(row, doc, whole)
out = {"ok": True, "수식": _tree(doc, whole, now, inputs, full.answer(doc, inputs))}
except (sd.DocError, *eqn._ERR) as e:
return {"ok": False, "reason": str(e) or type(e).__name__}
return out | ({"reason": lost[0]["까닭"]} if lost else {})
def links(doc: Any, ask: dict) -> dict[str, Any]:
"""새 기호 연결 후보(800-3) — M01 과 같은 후보 길(읽기만)."""
return _eqn().links(ask)
def preview(doc: Any, edits: list, inputs: dict | None = None) -> dict[str, Any]:
"""고침 통째 미리 셈(저장 없음) — {되나, 까닭, 줄, 수식, 전(고침 없는 사본 SK 금액), 후}."""
from M02_MasterTemplete import M02_Sangeun_Equation_Full as full
eqn = _eqn()
try:
doc, whole, row = _plain(doc)
new, why = apply(row, edits, whole) if edits else (row, [])
if why:
return {"되나": False, "까닭": why}
bare = {k: v for k, v in doc.items() if k != KEY}
mine = {**bare, KEY: edits} if edits else bare
ans = full.answer(mine, inputs)
eq = _tree(mine, whole, new, inputs, ans)
before = full.total(full.answer(bare, inputs) if edits else ans)
before = before or export(whole, row, inputs)["합계"]
except (sd.DocError, *eqn._ERR) as e:
return {"되나": False, "까닭": [f"셈 막힘 — {e}"]}
return {"되나": True, "까닭": [], "줄": new, "수식": eq, "전": before, "후": eq["합계"]}
@@ -1,240 +0,0 @@
"""M02 단가산출(SK) 수식 탭 — SK 셈 답 기준 소계 · 합계 · 고친 칸 표지(PLAN 796-2c · 요구 657).
수식 탭 줄(`M02_Sangeun_Equation`) = 바탕 사본 줄(+ 수식고침). 그 위에 SK 셈 답
(`M02_Sangeun_Calc.calc_doc` = 화면 · 저장 · B09 가 쓰는 한 벌)을 얹어 화면 금액 = SK 금액
(셈은 안 바꿈 · 보이기만):
합계 = 셈 답 `기준`(노 · 재 · 경 · 계 · 1 단위) — 바탕 줄만 셈한 합계 대신
소계 = 셈 답 `줄` → 돈 묶음(801-3 · `master_equation_group`) — 더한 · 부른 단가산출(갈래 블록) 하나씩
{cid, 이름, 상태, 수량, 노 · 재 · 경 · 계, 덮개?, 원래?, 까닭?, 나무?} + 직접 줄(인력 · 재료 · 기계 ·
덧줄 · 율) 한 묶음 {갈래 직접, 이름, 노 · 재 · 경 · 계, 낱줄?(더함 · 덮음 줄)} +
끝수(합계 − 묶음 합 · 까닭 글) · 밖(합계 밖 줄 — 엔진이 합계에서 뺌 · 이름 · 밖금액)
상태 = 바탕(그대로) · 덮음(품 · 단가 · 상수 · 표값 · 식 덮개 · 변수줄) ·
더함(더한줄) · 뺌(뺀줄 · 금액 0)
나무 = 더한 기초(더한줄 로직)의 수식(세부 덮개 · 뺀줄 얹은 줄) — 화면은 접힘 블록
표지 = 수식 탭 줄에 고친 칸 {표지[갈래], 원래, 지금, 뺌} — 줄 값 = 식 덮개 · 상수 · 표값 ·
변수줄을 얹은 식(`M02_Sangeun_Const.formulas`) · 품 · 단가 덮개는 줄 값에 안 얹고
`지금` 으로 보임(고침 주소 = 바탕 차례 그대로)
셈 답이 안 서는 SK(틀린 문서 · 돈 아닌 로직) = 바탕 줄 합계 그대로 + `답까닭`.
시험 `resources/tester/test_796_2c_m02_equation_full.py`.
"""
from __future__ import annotations
import re
from decimal import Decimal
from typing import Any
from M02_MasterTemplete import M02_Sangeun_Doc as sd
COSTS = ("노무비", "재료비", "경비")
SUMS = (*COSTS, "계")
_ADD = re.compile(r"^add:#(\d+)$")
_HEAD = {"labor": "자원", "material": "자원", "machine": "자원", "logic": "블록", "pct": "덧줄"}
_ADD_KIND = {"인력": "자원", "재료": "자원", "기계": "자원"}
_WORD = {"labor": "인력", "material": "재료", "machine": "기계"} # 직접 묶음 이름(801-3)
def _d(value: Any) -> Decimal:
return Decimal(str(value)) if value is not None else Decimal(0)
def _errors() -> tuple:
from M02_MasterTemplete import M02_MasterTemplete_Store as store
return (sd.DocError, store.StoreError, ArithmeticError, KeyError, TypeError, ValueError)
def answer(doc: dict, inputs: dict | None) -> dict | None:
"""SK 셈 답 — 못 셈(틀린 문서 · 돈 아닌 로직) = None."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
try:
got = calc.calc_doc(doc, inputs or None, False)
except _errors():
return None
return got if got.get("기준") else None
def total(ans: dict | None) -> dict | None:
return {k: _d(ans["기준"].get(k)) for k in SUMS} if ans else None
# ── 행 ────────────────────────────────────────────────────────────────
def _kind(cid: str, adds: list) -> str:
hit = _ADD.match(cid)
if not hit:
return _HEAD.get(cid.split(":", 1)[0], "자원")
one = adds[int(hit[1])] if int(hit[1]) < len(adds) else {}
if sd.is_rate(one):
return "율"
return _ADD_KIND.get(str(one.get("종류")), "블록")
def _word(cid: str, adds: list) -> str:
"""직접 줄의 자원 갈래 말 — 인력 · 재료 · 기계(그 밖 = 빈 글)."""
hit = _ADD.match(cid)
if not hit:
return _WORD.get(cid.split(":", 1)[0], "")
one = adds[int(hit[1])] if int(hit[1]) < len(adds) else {}
return str(one.get("종류")) if one.get("종류") in _ADD_KIND else ""
def _row(cid: str, kind: str, name: str, state: str, parts: dict | None, **more: Any) -> dict:
cost = {k: _d((parts or {}).get(k)) for k in COSTS}
return {
"cid": cid,
"갈래": kind,
"이름": name,
"상태": state,
**cost,
"계": sum(cost.values(), Decimal(0)),
**{k: v for k, v in more.items() if v not in (None, [], "")},
}
def rows(doc: dict, ans: dict, tree: Any, out_ids: set[str] = frozenset()) -> list[dict]:
"""셈 답 줄 → 행(셈 답 순서) + 뺀줄(금액 0) — `tree(더한줄 차례)` = 더한 기초 수식."""
adds = doc.get("더한줄") or []
spots = (ans.get("시트") or {}).get("자리") or {}
out = []
for line in ans.get("줄") or []:
cid = str(line.get("cid") or "")
hit = _ADD.match(cid)
info = spots.get(cid) or {}
cover = [k for k in info.get("덮개") or [] if k != "뺌"] or [
k for k in line.get("덮개") or []
]
k = int(hit[1]) if hit else -1
state = "더함" if hit else "덮음" if cover else "바탕"
one = adds[k] if 0 <= k < len(adds) else {}
if hit and one.get("종류") == "로직" and sd.sub_patched({**one, "끊음": None}):
cover = cover or ["세부"]
outside = cid in out_ids # 합계 밖 줄(가져온 식 `합밖` · 제외 단계) — 합에 안 듦
out.append(
_row(
cid,
_kind(cid, adds),
str(line.get("이름") or info.get("이름") or ""),
state,
None if outside else line.get("비목"),
합밖=outside or None,
밖금액=sum((_d(v) for v in (line.get("비목") or {}).values()), Decimal(0))
if outside
else None,
수량=line.get("수량"),
종류=_word(cid, adds),
덮개=cover,
원래=info.get("원래") if state == "덮음" else None,
까닭=line.get("까닭") or info.get("까닭"),
나무=tree(k) if hit and one.get("종류") == "로직" else None,
블록=k if hit and one.get("종류") == "로직" else None, # 더한 기초 차례(연결 끊기)
끊음=True if one.get("끊음") else None,
)
)
for cid in doc.get("뺀줄") or []: # 지운 줄 — 금액 0 · 원래 금액만 보임
info = spots.get(cid) or {}
out.append(
_row(
cid,
_kind(cid, adds),
str(info.get("이름") or ""),
"뺌",
None,
원래=info.get("원래"),
까닭=info.get("까닭"),
)
)
return out
def _why(ans: dict) -> str:
"""끝수 까닭 — 합계는 엔진이 비목마다 합쳐 버린 값 · 행은 줄마다 버린 값."""
text = ["줄마다 버린 값의 합 ≠ 엔진 비목 합(품셈 1-2-2 끝수)"]
if _d(ans.get("화면배") or 1) != 1:
text.append(f"단위 환산 ÷ {ans['화면배']}")
rate = ans.get("켜쌓기율")
if rate not in (None, 100):
text.append(f"켜쌓기율 {rate} %")
return " · ".join(text)
# ── 더한 기초 수식 ─────────────────────────────────────────────────────
def _basic_tree(whole: Any, doc: dict, one: dict, inputs: dict | None) -> dict | None:
"""더한줄 로직 하나의 수식 — 세부 덮개 · 뺀줄 얹은 줄 · 입력 = 줄 값 › 공통 옵션 › 자동."""
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
if any(one.get(k) not in (None, {}, []) for k in sd.BODY):
return None
if one.get("끊음"): # 끊은 기초(796-2e) = 자기 사본 줄 + 수식 고침(고침 주소 그대로)
from M02_MasterTemplete import M02_Sangeun_Block as blk
return blk.view(whole, doc, one, None, inputs)[0]
code = str(one["로직"])
mine = {k: v for k, v in (one.get("입력값") or {}).items() if str(v).strip()}
given = {**(doc.get("입력값") or {}), **(inputs or {}), **mine}
try:
row = sd.patched(whole.logic(code), one)["줄"]
return eqm.export(whole, {**row, "키": code}, given)
except Exception: # noqa: BLE001 — 엔진 FormulaError · 기초 하나가 틀려도 나머지는 그림
return None
# ── 줄 표지 ────────────────────────────────────────────────────────────
def _mark(eq: dict, base: dict, ans: dict, doc: dict) -> None:
"""수식 탭 줄에 고친 칸 표지 — 자리 = 바탕 cid(호표 · 덧줄) · `mid:이름`."""
spots = (ans.get("시트") or {}).get("자리") or {}
ids = sd.line_ids(base)
heads = len(base.get("호표") or [])
for line in eq.get("줄") or []:
if line["갈래"] == "중간":
spot = f"mid:{line['열쇠']}"
elif line["갈래"] == "호표":
spot = ids[line["차례"]] if line.get("차례", 0) < len(ids) else ""
elif line["갈래"] == "덧줄":
at = heads + line.get("차례", 0)
spot = ids[at] if at < len(ids) else ""
else:
continue
info = spots.get(spot) or {}
kinds = list(info.get("덮개") or [])
if not kinds:
continue
line["표지"] = [k for k in kinds if k != "뺌"]
line["원래"], line["지금"] = info.get("원래"), info.get("지금")
if "뺌" in kinds:
line["뺌"] = True
def _outside(base: dict) -> set[str]:
"""합계 밖 줄 cid — 엔진이 비목 합에서 빼는 줄(`master_formula_sum.skipped`)."""
import master_cut as mcut # M01 이 길을 둔 뒤(수식 탭 export 가 먼저)
if not mcut.ms.uses(base):
return set()
ids = sd.line_ids(base)
return {ids[i] for i in mcut.ms.skipped(base) if i < len(ids)}
# ── 붙이기 ────────────────────────────────────────────────────────────
def attach(
eq: dict, doc: dict, whole: Any, base: dict, inputs: dict | None, ans: dict | None
) -> dict:
"""수식 `eq` 에 SK 셈 답 합계 · 소계 · 표지를 얹음(제자리) — 답 없음 = `답까닭` 만."""
import master_equation_group as grp # M01 이 길을 둔 뒤
if ans is None:
return eq | {"답까닭": "단가산출 셈 답이 서지 않음 — 바탕 줄 합계를 보임"}
_mark(eq, base, ans, doc)
adds = doc.get("더한줄") or []
table = rows(
doc,
ans,
lambda k: _basic_tree(whole, doc, adds[k], inputs) if k >= 0 else None,
_outside(base),
)
got = grp.bundles(table) # 801-3 묶음 — 부른 · 더한 단가산출 하나씩 + 직접 줄 한 묶음
now = total(ans) or {}
rest = {k: now[k] - sum((r[k] for r in got["줄"]), Decimal(0)) for k in SUMS}
eq["합계"] = now
eq["소계"] = {"줄": got["줄"], "밖": got["밖"], "끝수": rest, "끝수까닭": _why(ans)}
return eq
-89
View File
@@ -527,92 +527,3 @@ def name_table(base: dict, clean: dict) -> list[dict]:
out += [{"글": f"번지.{x['번지']}", "갈래": "번지"} for x in lines if x.get("번지")]
out += [{"글": f"단계.'{x.get('이름')}'", "갈래": "단계"} for x in base.get("단계") or []]
return out
# ── 검사 길(시트가 칠 때마다 · 셈 없음) ──────────────────────────────
def check_doc(doc: Any, spot: str, text: str) -> dict[str, Any]:
"""식 글 하나 → {되나, 까닭, 알림, 식(엔진), 글(이름 꼴)} — 자리 = 중간 `mid:이름`(변수 줄
포함) · 호표 · 덧줄 cid · `add:#k` · 문서 = 화면 캐시(그 자리 옛 식은 빼고 봄)."""
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Sangeun_Calc as calc
text = str(text or "").strip()
out: dict[str, Any] = {"되나": False, "까닭": [], "알림": [], "식": None, "글": None}
if not text:
return out | {"까닭": ["식이 빔"]}
if bad := limits(text):
return out | {"까닭": bad}
whole, doc = _whole(), _without(doc if isinstance(doc, dict) else {}, spot)
try:
clean_ = sd.clean(doc, None, whole)
base = calc._base_of(clean_, whole, refs.read_ref, ())["줄"]
except sd.DocError as e:
return out | {"까닭": [f"문서 · {e}"]}
got, why = to_engine(text, base)
if why:
return out | {"까닭": why}
out |= {"식": got, "글": to_name(got, base)}
trial, why = _put(clean_, base, spot, got)
if why:
return out | {"까닭": [why]}
bad = [b["까닭"].removeprefix("식 — ") for b in settle(base, trial)[1] if b["cid"] == spot]
return out | {"되나": not bad, "까닭": bad, "알림": _risks(got, base, trial)}
def _without(doc: dict, spot: str) -> dict:
"""그 자리 옛 식을 뺀 문서(옛 식이 틀려도 문서 검사가 안 막게)."""
out = dict(doc)
if isinstance(out.get("식덮개"), dict):
out["식덮개"] = {k: v for k, v in out["식덮개"].items() if k != spot}
if isinstance(out.get("변수줄"), list):
out["변수줄"] = [
{**x, "식": "0"} if isinstance(x, dict) and f"mid:{x.get('이름')}" == spot else x
for x in out["변수줄"]
]
hit = _ADD.match(spot)
if hit and isinstance(out.get("더한줄"), list) and int(hit[1]) < len(out["더한줄"]):
adds = list(out["더한줄"])
adds[int(hit[1])] = {k: v for k, v in dict(adds[int(hit[1])]).items() if k != "수량식"}
out["더한줄"] = adds
return out
def _put(doc: dict, base: dict, spot: str, text: str) -> tuple[dict, str | None]:
"""문서 그 자리에 식(엔진) — (새 문서, 못 넣는 까닭)."""
names = [x["이름"] for x in doc.get("변수줄") or []]
hit = _ADD.match(spot)
if spot.startswith("mid:") and spot[4:] in names:
lines = [{**x, "식": text} if x["이름"] == spot[4:] else x for x in doc["변수줄"]]
return {**doc, "변수줄": lines}, None
if spot in _places(base):
if spot in (doc.get("상수덮개") or {}) or spot in (doc.get("표값덮개") or {}):
return doc, "상수 · 표값 덮개가 있는 줄 — [M01 원래로] 뒤 식 고침"
return {**doc, "식덮개": {**(doc.get("식덮개") or {}), spot: text}}, None
adds = doc.get("더한줄") or []
if hit and int(hit[1]) < len(adds):
one = adds[int(hit[1])]
if sd.is_rate(one) or one.get("종류") == "로직":
return doc, "율 줄 · 로직 줄 수량은 수만"
adds = [{**x, "수량식": text} if k == int(hit[1]) else x for k, x in enumerate(adds)]
return {**doc, "더한줄": adds}, None
return doc, f"없는 자리 「{spot}」"
def _risks(text: str, base: dict, doc: dict) -> list[str]:
"""0 나눔 위험 — 나누는 쪽 이름이 입력값 0 · 고르기에 0."""
mf, out = _eng(), []
given = doc.get("입력값") or {}
try:
tree = mf.parse(text)
except (mf.FormulaError, RecursionError):
return out
picks = {str(x.get("이름")): x.get("고르기") or [] for x in base.get("입력") or []}
for node in mf.walk(tree):
if node[0] == "bin" and node[1] == "/":
for n in (x[1] for x in mf.walk(node[3]) if x[0] == "name"):
zero = str(given.get(n)) in ("0", "0.0") or any(
str(c) == "0" for c in picks.get(n, [])
)
if zero and f"「{n}」" not in " ".join(out):
out.append(f"「{n}」 가 0 이면 0 나눔")
return out
-149
View File
@@ -1,17 +1,9 @@
"""M02 단가산출(SK) 셈 길(PLAN 715-1b) — `POST /api/m02/layers/{층}/sangeun/calc` ·
[단가산출로 저장](715-3) `POST /api/m02/layers/{층}/sangeun/from-line`(층 쓰기 권한) ·
일위대가 [+ 줄] M01 기초 = 그 층 SK 사본(811-1 · `M02_Labor_SkRow`) `…/sangeun/from-logic`(층 쓰기) ·
식 칸 검사(792-1) `POST /api/m02/layers/{층}/sangeun/formula-check`(셈 없음 · 층 읽기 권한) ·
가져온 식(793-2 · `M02_Sangeun_Imported`) `…/sangeun/imported`(만들기 · 층 쓰기) · `/price` ·
`/link`(화면 캐시 문서 고침 · 저장 없음 · 층 읽기 · 기초로 바꾸기 없음 · 809-1) ·
불러오기 단산 블록 → 가져온 식(793-3b · `M02_Sangeun_FromHopyo`) `…/sangeun/from-hopyo`
(늘 개인 층 쓰기 · 몸 `문서` = 미리 보기에서 고친 문서) · 미리 보기 `…/from-hopyo/preview`(층 읽기 · 안 씀 · 835-1).
로직 사본(795-1 · `M02_Sangeun_Copy`) `…/sangeun/copy/price` [단가 갱신] · `/regen` [재생성]
(화면 캐시 문서에 할일 얹음 · 저장 없음 · 층 읽기).
수식 탭(796-2b · `M02_Sangeun_Equation`) `…/sangeun/equation`(층 읽기) · `/preview`(고침 미리 셈 ·
층 쓰기) — 저장 없음 · 고침 = 화면 캐시 `수식고침` → [저장].
더한 기초 [연결 끊기](796-2e · `M02_Sangeun_Block`) `…/sangeun/block/unlink` · `/relink`(화면 캐시 문서 고침 ·
저장 없음 · 층 읽기) · 끊은 기초 수식 = 같은 equation 길 몸 `블록`(더한줄 차례).
저장 안 함 · 로그인 사용자 · 층 읽기 권한(`Router_Items._root`) · 화면은 최신 응답만.
몸 = `문서`(저장 전 화면 문서) 또는 `키`(그 층 저장본) + `입력값`(열린입력 · 시험 값) ·
@@ -30,12 +22,8 @@ from pydantic import BaseModel
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_San_MatPick as mat_pick
from M02_MasterTemplete import M02_Sangeun_Block as blk
from M02_MasterTemplete import M02_Sangeun_Calc as calc
from M02_MasterTemplete import M02_Sangeun_Copy as skc
from M02_MasterTemplete import M02_Sangeun_Doc as sd
from M02_MasterTemplete import M02_Sangeun_Equation as eqm
from M02_MasterTemplete import M02_Sangeun_Formula as fx
from M02_MasterTemplete import M02_Sangeun_FromHopyo as from_hopyo
from M02_MasterTemplete import M02_Sangeun_Imported as imp
from M02_MasterTemplete import M02_Sangeun_QtyLinks as qty
@@ -60,26 +48,6 @@ def _calc(body: SangeunCalcBody) -> dict[str, Any]:
return calc.calc_doc(doc, body.입력값, body.보기)
class FromLineBody(BaseModel):
줄: dict[str, Any]
이름: str
단위: str
새로: bool = False # 같은 내용 409 뒤 — 그래도 새로(733-2)
씀: str | None = None # 같은 내용 409 뒤 — 그 SK 씀
@router.post("/layers/{layer}/sangeun/from-line")
def sangeun_from_line(
layer: Layer,
body: FromLineBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""[단가산출로 저장](715-3) — 일위대가 줄 → 그 층 새 단가산출 · 답 = 새 키 + 바꿀 참조 줄."""
folder = _root(session, layer, owner, write=True)
return _call(folder, calc.from_line, body.줄, body.이름, body.단위, body.새로, body.씀)
class FromLogicBody(BaseModel):
로직: str
새로: bool = False
@@ -113,23 +81,6 @@ def calc_sangeun(
return _call(_root(session, layer, owner), _calc, body)
class FormulaCheckBody(BaseModel):
문서: dict[str, Any]
자리: str
식: str
@router.post("/layers/{layer}/sangeun/formula-check")
def check_formula(
layer: Layer,
body: FormulaCheckBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""식 칸 검사(792-1) — {되나, 까닭, 알림, 식(엔진), 글(이름 꼴)} · 셈 · 저장 없음."""
return _call(_root(session, layer, owner), fx.check_doc, body.문서, body.자리, body.식)
class ImportedBody(BaseModel):
로직: dict[str, Any]
원본: dict[str, Any] | None = None
@@ -256,103 +207,3 @@ def sangeun_imported_edit(
raise HTTPException(status_code=404, detail="price · link · qty · qty-pick · qty-drop")
fn, *args = _EDIT[how](body)
return _call(_root(session, layer, owner), _sd(fn), *args)
class CopyBody(BaseModel):
문서: dict[str, Any]
입력값: dict[str, Any] | None = None
_JOBS = {"price": skc.PRICE, "regen": skc.REGEN}
@router.post("/layers/{layer}/sangeun/copy/{how}")
def sangeun_copy(
layer: Layer,
how: str,
body: CopyBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""로직 사본(795-1) — price [단가 갱신] · regen [재생성] · 답 = 할일 얹은 문서(화면 캐시 ·
[저장] 때 서버가 적용) + 전 · 후 금액 + 바뀐자원 | 못얹은."""
if how not in _JOBS:
raise HTTPException(status_code=404, detail="price · regen")
args = (body.문서, _JOBS[how], body.입력값)
return _call(_root(session, layer, owner), _sd(skc.preview), *args)
class EquationBody(BaseModel):
문서: dict[str, Any]
inputs: dict[str, Any] | None = None
고침: list[Any] | None = None
블록: int | None = None # 끊은 더한 기초 차례(796-2e) — 없으면 바탕 줄
@router.post("/layers/{layer}/sangeun/equation")
def sangeun_equation(
layer: Layer,
body: EquationBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""수식 탭 읽기(796-2b) — 사본(가져온 식) 줄 + 문서 `수식고침` → {ok, 수식 | reason}."""
if body.블록 is not None:
return _call(_root(session, layer, owner), _sd(blk.read), body.문서, body.블록, body.inputs)
return _call(_root(session, layer, owner), _sd(eqm.read), body.문서, body.inputs)
class LinksBody(BaseModel):
문서: dict[str, Any] | None = None
갈래: str
검색: str = ""
분류: str = "인력"
블록: int | None = None
@router.post("/layers/{layer}/sangeun/equation/links")
def sangeun_equation_links(
layer: Layer,
body: LinksBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""새 기호 연결 후보(800-3) — 표 · 요소 · 로직 이름 찾기(읽기만)."""
ask = {k: getattr(body, k) for k in ("갈래", "검색", "분류")}
return _call(_root(session, layer, owner), _sd(eqm.links), body.문서 or {}, ask)
@router.post("/layers/{layer}/sangeun/equation/preview")
def sangeun_equation_preview(
layer: Layer,
body: EquationBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""수식 고침 미리 셈(796-2b · 층 쓰기 · 저장 없음) — 고침 = `수식고침` 통째 →
{되나, 까닭, 줄, 수식, 전, 후}."""
folder = _root(session, layer, owner, write=True)
if body.블록 is not None:
args = (body.문서, body.블록, body.고침 or [], body.inputs)
return _call(folder, _sd(blk.preview), *args)
return _call(folder, _sd(eqm.preview), body.문서, body.고침 or [], body.inputs)
class BlockBody(BaseModel):
문서: dict[str, Any]
차례: int
@router.post("/layers/{layer}/sangeun/block/{how}")
def sangeun_block(
layer: Layer,
how: str,
body: BlockBody,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""더한 기초 연결(796-2e) — unlink [연결 끊기] · relink [다시 잇기] · 답 = 고친 문서(화면 캐시 ·
[저장] 때 서버가 다시 셈) + 전 · 후 SK 금액."""
if how not in ("unlink", "relink"):
raise HTTPException(status_code=404, detail="unlink · relink")
return _call(_root(session, layer, owner), _sd(blk.change), body.문서, body.차례, how)