Files
Aislo/M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py
T
eomsangdonandClaude Opus 5.5 b4f8515b5d 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>
2026-11-17 11:36:15 +09:00

438 lines
19 KiB
Python

"""M02 양식 층 API — 계약 `tmp/M02_분석/6_계약.md` 「층 (sub4)」.
⚠ 등록은 `main.py`(로그인만) · 시스템 · 회사 · 개인 층 권한은 `M02_Layer_Access`(나무 · 항목 길과
한 벌 · PLAN 27-1c · `owner` = 회사 `{C}` · 개인 `{C}/{U}`) · 남의 층 목록 = `/layers/{층}/owners`:
project 같은 회사 프로젝트 · 작업본 쓰기 · `_initial/` 은 안 씀
"""
from __future__ import annotations
import asyncio
import logging
from pathlib import Path
from typing import Any, Literal
from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException, Query
from pydantic import BaseModel
from B06_Section.B06_Section_Repository import (
get_cross_section_designs,
get_workflow_route_context,
)
from common_util import common_util_spreadsheet as spreadsheet
from common_util.common_util_auth import verify_session
from common_util.common_util_storage import resolve_stored_project_path
from config.config_db import get_db_pool, run_with_connection
from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Layer_Index as index
from M02_MasterTemplete import M02_Library_Flat as flat
from M02_MasterTemplete import M02_MasterTemplete_Items as items_store
from M02_MasterTemplete import M02_MasterTemplete_Router_Items as items_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Table_Fill as fill
from M02_MasterTemplete import M02_Template_Layers as layers
from M02_MasterTemplete.M02_Table_Fill_Spec import soil_tiers_from_designs
logger = logging.getLogger(__name__)
router = APIRouter(
prefix="/api/m02", tags=["M02 MasterTemplete Layers"], route_class=items_router.NotedRoute
)
Layer = Literal["system", "company", "personal", "project"]
class SaveBody(BaseModel):
판: str | None = None
문서: dict[str, Any]
# ── DB (시험이 바꿔 끼움) ─────────────────────────────
async def _project_row(project_id: str) -> dict[str, Any] | None:
pool = get_db_pool()
async with pool.acquire() as connection, connection.cursor() as cursor:
await cursor.execute(
"""SELECT id, name, company_id, user_id, storage_path FROM projects
WHERE id = %s AND deleted_at IS NULL""",
(str(project_id),),
)
row = await cursor.fetchone()
if not row:
return None
keys = ("id", "name", "company_id", "user_id", "storage_path")
return dict(zip(keys, row, strict=True))
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:
await cursor.execute(
"SELECT id, name FROM users WHERE company_id = %s AND deleted_at IS NULL ORDER BY id",
(company_id,),
)
rows = await cursor.fetchall()
return [{"user_id": row[0], "name": row[1]} for row in rows]
async def _company_projects(company_id: int) -> list[dict[str, Any]]:
pool = get_db_pool()
async with pool.acquire() as connection, connection.cursor() as cursor:
await cursor.execute(
"""SELECT id, name, storage_path FROM projects
WHERE company_id = %s AND deleted_at IS NULL ORDER BY created_at DESC""",
(company_id,),
)
rows = await cursor.fetchall()
return [{"project_id": str(row[0]), "name": row[1], "storage_path": row[2]} for row in rows]
async def _companies() -> list[dict[str, Any]]:
pool = get_db_pool()
async with pool.acquire() as connection, connection.cursor() as cursor:
await cursor.execute("SELECT id, name FROM companies WHERE deleted_at IS NULL ORDER BY id")
rows = await cursor.fetchall()
return [{"company_id": row[0], "name": row[1]} for row in rows]
async def _cross_designs(project_id: str) -> list[dict[str, Any]]:
"""최신 노선의 B06 횡단 설계 — 못 읽으면 빈 목록(관 연장이 빈칸으로 섬 · 0 아님)."""
try:
context = await run_with_connection(get_workflow_route_context, UUID(str(project_id)))
route_id = int((context or {}).get("route_id") or 0)
return await run_with_connection(get_cross_section_designs, route_id) if route_id else []
except Exception:
logger.exception("M02 채운 표 — 횡단 설계 조회 실패: project_id=%s", project_id)
return []
# ── 권한 · 자리 ───────────────────────────────────────
_is_system_admin = access.is_system_admin
async def _project(session: dict[str, Any], project_id: str | None) -> dict[str, Any]:
"""같은 회사 프로젝트 한 건 + `root`(실경로). 아니면 403/404."""
if not project_id:
raise HTTPException(status_code=400, detail="project_id 가 필요합니다.")
row = await _project_row(project_id)
if row is None:
raise HTTPException(status_code=404, detail="프로젝트를 찾을 수 없습니다.")
if not _is_system_admin(session) and row["company_id"] != session.get("company_id"):
raise HTTPException(status_code=403, detail="다른 회사의 프로젝트입니다.")
if not row.get("storage_path"):
raise HTTPException(status_code=404, detail="프로젝트 저장 경로를 찾을 수 없습니다.")
row["root"] = Path(resolve_stored_project_path(row["storage_path"]))
return row
def _company_of(session: dict[str, Any], project: dict[str, Any] | None) -> int:
company_id = project["company_id"] if project else session.get("company_id")
if company_id is None: # 회사 없는 사용자는 없음(21-0) — 회사 · 개인 층은 회사부터
raise HTTPException(status_code=409, detail="회사부터 등록 — 회사 연결이 필요합니다.")
return int(company_id)
async def _layer_dir(
session: dict[str, Any],
layer: str,
*,
project_id: str | None,
user_id: int | None = None,
owner: str | None = None,
write: bool = False,
) -> Path:
"""층 폴더 — 권한은 `M02_Layer_Access` 한 벌(나무 · 항목 길과 같음 · PLAN 27-1c) ·
`owner` 없으면 프로젝트(없으면 세션) 회사의 회사 층 · 개인 층(`user_id` 또는 본인)."""
if layer == "project":
return layers.project_dir((await _project(session, project_id))["root"])
if layer == "system":
access.require(session, layer, write=write)
return layers.system_dir()
if not owner:
project = await _project(session, project_id) if project_id else None
company_id = _company_of(session, project)
who = session["user_id"] if user_id is None else user_id
owner = str(company_id) if layer == "company" else f"{company_id}/{who}"
got = access.require(session, layer, owner, write=write)
folder = access.folder(got, create=write)
if got.mine:
return _ensured(folder)
if write: # 남의 층 쓰기(맡은 회사 · 39-6) — 구조물 길과 한 벌
await items_router.others_write(session, got, folder)
return folder
def _ensured(folder: Path) -> Path:
"""회사 · 개인 층 첫 진입 — 빈 구조물집계표 뼈대(PLAN 21-2 · `Items.ensure`)."""
items_store.ensure(folder)
return folder
def _bad(error: ValueError) -> HTTPException:
return HTTPException(status_code=400, detail=str(error))
# ── 층 길 ─────────────────────────────────────────────
@router.get("/layers/{layer}/owners")
async def list_owners(
layer: Literal["company", "personal"],
company: int | None = Query(None),
session: dict[str, Any] = Depends(verify_session),
) -> list[dict[str, Any]]:
"""남의 층 목록(PLAN 27-1c · 펼칠 때 부름) — `[{owner, name}]`.
회사 = SYSTEM_ADMIN 만 · 층 자리가 있는 것만(자기 회사는 늘) ·
개인 = 그 회사를 맡은 사람(39-6)만 · 회사 사람 전부(나 맨 위 · 집계표 없으면 `비어있음`)."""
if layer == "company":
if not access.is_system_admin(session):
raise HTTPException(status_code=403, detail="회사 목록은 시스템 관리자만 봄.")
rows = [(str(r["company_id"]), r["name"]) for r in await _companies()]
else:
target = session.get("company_id") if company is None else company
if target is None:
raise HTTPException(status_code=409, detail=access.NO_COMPANY)
if not access.manages(session, target):
raise HTTPException(status_code=403, detail="같은 회사 사람 목록은 회사 관리자만 봄.")
me = session.get("user_id")
users = await _company_users(int(target))
users.sort(key=lambda u: u["user_id"] != me) # 나 맨 위
return [
{"owner": owner, "name": u["name"], "비어있음": _empty(owner)}
for u in users
for owner in [f"{target}/{u['user_id']}"]
]
found = []
for owner, name in rows:
got = access.Grant(layer, owner, False, owner == access.own_owner(session, layer))
try:
access.folder(got)
except HTTPException:
continue
found.append({"owner": owner, "name": name})
return found
def _empty(owner: str) -> bool:
"""개인 층에 집계표가 없음 — 사람 나무 「비어 있음」(폴더를 안 만듦)."""
company, user = owner.split("/")
table = layers.personal_dir(company, user) / "table" / f"{store.STRUCTURE_TABLE}.json"
return not table.is_file()
@router.get("/layers/{layer}/templates")
async def list_layer(
layer: Layer,
project_id: str | None = Query(None),
user_id: int | None = Query(None),
owner: str | None = Query(None),
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
folder = await _layer_dir(session, layer, project_id=project_id, user_id=user_id, owner=owner)
rows = await asyncio.to_thread(index.list_rows, folder) # 판 = 자국 기억(826-1)
manifest = await asyncio.to_thread(layers.read_manifest, folder)
for row in rows:
row["출처"] = manifest.get(f"{row['종류']}/{row['이름']}")
if (row["종류"], row["이름"]) in store.IN_USE: # 화면이 지우기 확인 창 전에 막음
row["쓰는곳"] = store.IN_USE[(row["종류"], row["이름"])]
# 서고(50-3) — 보이는 이름 · 단위 · 기준 금액(51-4)
await asyncio.to_thread(index.summaries, folder, rows) # 요약 색인(826-1)
return {"층": layer, "양식": rows}
@router.get("/layers/{layer}/templates/{kind}/{name}")
async def read_layer_template(
layer: Layer,
kind: str,
name: str,
project_id: str | None = Query(None),
user_id: int | None = Query(None),
owner: str | None = Query(None),
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
folder = await _layer_dir(session, layer, project_id=project_id, user_id=user_id, owner=owner)
try:
found = await asyncio.to_thread(layers.read_template, folder, kind, name)
except ValueError as error:
raise _bad(error) from error
if found is None and layer == "project":
# 옛 프로젝트(사본 없음) — 시스템 양식으로 떨어짐 · 저장하면 그때 작업본이 생김
found = await asyncio.to_thread(layers.read_template, layers.system_dir(), kind, name)
if found is not None:
found.update({"층": "system", "판": None})
return found
if found is None:
raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.")
found["층"] = layer
found["출처"] = layers.read_manifest(folder).get(f"{kind}/{name}")
found["문서"] = refs.filled(kind, found["문서"]) # 옛 서고 문서 구분 · 상세구분(51-12)
if layer != "project": # 옛 단가승격 참조 줄 = 새 꼴(134-2 · 프로젝트 사본은 그대로)
found["문서"] = await asyncio.to_thread(refs.unpromote, kind, found["문서"])
found["문서"] = await asyncio.to_thread(flat.flat_doc, kind, found["문서"]) # 740-1
return found
@router.put("/layers/{layer}/templates/{kind}/{name}")
async def save_layer_template(
layer: Layer,
kind: str,
name: str,
body: SaveBody,
project_id: str | None = Query(None),
user_id: int | None = Query(None),
owner: str | None = Query(None),
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
folder = await _layer_dir(
session, layer, project_id=project_id, user_id=user_id, owner=owner, write=True
)
document = body.문서
if layer == "project" and kind in layers.LIBRARY_KINDS:
raise HTTPException(status_code=400, detail="프로젝트는 서고 문서를 안 둠 — 굳힌 사본만")
try:
layers.check_skeleton(kind, document) # 빈 `{}` · 뼈대 없는 문서는 파일 안 씀
except ValueError as error:
raise _bad(error) from error
if kind == "table" and fill.is_fillable(document):
# 채운 표가 와도 설계값은 안 받아 적음 — 양식 + 손 값만(5장 · 브라우저 값을 믿지 않음)
document = fill.strip_design(document)
if layer != "project":
# 시스템 · 회사 · 개인 층 = 마스터 저장소 규칙 그대로(집계표 저장 때 새 열 파일 ·
# 번호 · SS 장부 ·
# 계산값 서버 풀이 · 번호 칸 보존 — `M02_MasterTemplete_Store.write`)
return await asyncio.to_thread(
_store_save, folder, kind, name, body.판 or "", document, layer
)
cancels: list[str] = []
if kind == "area":
document, cancels = await asyncio.to_thread(_apply_cancels, folder, name, document)
# 면적산출 계산값은 서버가 같은 TS 엔진을 Node 로 돌려 새로 적음
# (브라우저 값 버림 · 5장 ②)
try:
document = await asyncio.to_thread(spreadsheet.with_server_values, document)
except spreadsheet.RecalcError as error:
raise HTTPException(status_code=503, detail=str(error)) from error
try:
version = await asyncio.to_thread(
layers.write_template,
folder,
kind,
name,
document,
version=body.판,
check_version=True,
)
except layers.StaleTemplate as error:
raise HTTPException(
status_code=409, detail={"message": str(error), "판": error.current}
) from error
except ValueError as error:
raise _bad(error) from error
if kind == "area": # 그 열 도면 연결표 칸 글도(41-1 · 시스템 · 회사 · 개인 층은 Store.write 가)
await asyncio.to_thread(_refresh_drawing, folder, name, cancels)
return {"종류": kind, "이름": name, "판": version, "층": layer}
def _apply_cancels(folder: Path, column: str, doc: Any) -> tuple[Any, list[str]]:
"""면적 저장 문서의 `보내기취소[]`(112-2)를 떼고 그 이름을 이름정의에서 뺌."""
from M02_MasterTemplete import M02_Area_Table as area_table
with store.at(folder):
return area_table.apply_cancels(column, doc)
def _refresh_drawing(folder: Path, column: str, unlink: list[str] | tuple[()] = ()) -> None:
from M02_MasterTemplete import M02_Area_Table as area_table
with store.at(folder):
area_table.refresh_drawing(column, unlink)
def _store_save(folder: Path, kind: str, name: str, version: str, doc: Any, layer: str) -> dict:
with store.at(folder):
try:
info = store.write(kind, name, version, doc, screen=True) # 화면 [저장](26-7e)
except store.StoreError as error:
raise HTTPException(status_code=error.status, detail=error.detail) from error
return {"종류": kind, "이름": name, "판": info["판"], "층": layer}
@router.delete("/layers/{layer}/templates/{kind}/{name}")
async def delete_layer_template(
layer: Layer,
kind: str,
name: str,
판: str | None = Query(None),
project_id: str | None = Query(None),
owner: str | None = Query(None),
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
"""개인 = 본인만 · 회사 = 회사 관리자만 · 시스템 = 시스템 관리자 · 프로젝트 층은 거절 ·
판이 다르면 409 · 프로그램이 이름으로 부르는 양식(`store.IN_USE` — 구조물집계표 등)은 409."""
if layer == "project":
raise HTTPException(
status_code=403, detail="개인 · 회사 · 시스템 층 양식만 지울 수 있습니다."
)
folder = await _layer_dir(session, layer, project_id=project_id, owner=owner, write=True)
if (kind, name) in store.IN_USE:
raise HTTPException(status_code=409, detail=f"쓰는 양식이라 못 지움 「{name}」")
try:
layers.check_kind(kind)
layers.check_name(name)
except ValueError as error:
raise _bad(error) from error
try: # 서고 문서를 담은 일위대가 · 사전조합이 있으면 409(50-3)
await asyncio.to_thread(refs.refuse_used, folder, kind, name)
except store.StoreError as error:
raise HTTPException(status_code=error.status, detail=error.detail) from error
if not 판:
raise HTTPException(status_code=400, detail="지울 양식의 판이 필요합니다.")
try:
found = await asyncio.to_thread(
layers.delete_template, folder, kind, name, version=판, check_version=True
)
except layers.StaleTemplate as error:
raise HTTPException(
status_code=409, detail={"message": str(error), "판": error.current}
) from error
if not found:
raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.")
return {"종류": kind, "이름": name, "층": layer, "지움": True}
# ── 프로젝트 길 ───────────────────────────────────────
@router.get("/projects/{project_id}/tables/{name}/filled")
async def filled_table(
project_id: str,
name: str,
session: dict[str, Any] = Depends(verify_session),
) -> dict[str, Any]:
"""설계값을 채운 표 문서 — 저장 안 함(5장 ③ 서버 단독) · `결과` = 계산 열(없으면 null)."""
project = await _project(session, project_id)
try:
found = await asyncio.to_thread(
layers.read_template, layers.project_dir(project["root"]), "table", name
)
if found is None:
found = await asyncio.to_thread(
layers.read_template, layers.system_dir(), "table", name
)
except ValueError as error:
raise _bad(error) from error
if found is None:
raise HTTPException(status_code=404, detail="양식을 찾을 수 없습니다.")
designs = await _cross_designs(project_id)
lengths = fill.pipe_lengths_from_designs(designs)
document = await asyncio.to_thread(
fill.fill_table, project["root"], found["문서"], lengths, soil_tiers_from_designs(designs)
)
result = await asyncio.to_thread(fill.recalc, document)
return {"이름": name, "판": found["판"], "문서": document, "결과": result}