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:
@@ -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
|
||||
|
||||
@@ -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))}
|
||||
|
||||
|
||||
@@ -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 }[],
|
||||
|
||||
@@ -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],
|
||||
}
|
||||
|
||||
@@ -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},
|
||||
}
|
||||
|
||||
@@ -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
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user