Merge remote-tracking branch 'origin/sub_laptop_1' into main_laptop_1
This commit is contained in:
@@ -1,17 +1,14 @@
|
||||
"""D 예정노선 2단계 노선 정본 — 손으로 그은 직선 · 갈래 · 구역
|
||||
(요구 389 6 · 11 · 13 · 14 · 391 · PLAN 562-2).
|
||||
(요구 389 6 · 11 · 13 · 14 · 391 · 452 · PLAN 562-2 · 590-1).
|
||||
|
||||
- `GET /api/projects/{id}/plan/network` — 정본(`plan_networks`) + 서버가 다시 센 길이 ·
|
||||
측점 · 조각 · 저장 없으면 옛 연도 노선(`plan_route_years.route_json.planned`)을 한 선으로 바꿔
|
||||
보임(legacy)
|
||||
- `GET /api/projects/{id}/plan/network` — 설계 내용 파일(`D03_PlanAnalysis_Store`) + 서버가 다시 센
|
||||
길이 · 측점 · 조각 · 파일이 없으면 옛 DB 칸을 옮겨 보임(쓰지 않음)
|
||||
- `PUT …/plan/network` — [저장] · [초기화](빈 선) — 선 · 마크 · 조각 연도만 받아 서버가 정본으로
|
||||
다시 셈 → `plan_networks` · 조각마다 한 줄(`plan_route_pieces`) · 연도 행(`plan_route_years`) ·
|
||||
사업연도 끝
|
||||
다시 셈 → 파일(원자 쓰기) · 연도 상태 줄(`plan_route_years` 지문 · 확정) · 사업연도 끝
|
||||
|
||||
길이 · 측점 · 높이는 저장하지 않음(늘 다시 셈 · 높이는 지형에서). 측점 = 선마다 No.0 부터.
|
||||
조각 = 선의 마크 사이 구간(구역 × 갈래) · 업체 지정은 조각 단위(`plan_route_assignees.piece_id`).
|
||||
지점 목록(`base` · 585-1) = D02 정본(`plan_base.load_base`) — 비어 옛 연도 행을 접어 보이던 것은
|
||||
[저장] 전에 칸에 굳힘(연도 행이 바뀌어도 그대로).
|
||||
지점 목록(`base`) = 같은 파일의 `points`(D02 `base_view`).
|
||||
계산 자리 = ① 파이썬·TS 짝(`D03_PlanAnalysis_Draw`) — 화면은 그리는 즉시 · [저장]은 여기서 다시 셈.
|
||||
"""
|
||||
|
||||
@@ -23,14 +20,15 @@ import math
|
||||
from typing import Any
|
||||
from uuid import UUID
|
||||
|
||||
import aiomysql
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel, Field
|
||||
|
||||
from common_util.common_util_auth import is_forest_service, require_company
|
||||
from common_util.common_util_save_guard import project_lock
|
||||
from config.config_db import get_db_pool
|
||||
from D02_PlanBase import D02_PlanBase_Router as plan_base
|
||||
from D03_PlanAnalysis import D03_PlanAnalysis_Draw as draw
|
||||
from D03_PlanAnalysis import D03_PlanAnalysis_Store as store
|
||||
|
||||
router = APIRouter(prefix="/api/projects", tags=["D03 Plan Network"])
|
||||
|
||||
@@ -166,8 +164,8 @@ def derive(network: dict[str, Any], year_from: int | None = None) -> dict[str, A
|
||||
|
||||
|
||||
def year_rows(pieces: list[dict[str, Any]]) -> dict[int, dict[str, Any]]:
|
||||
"""조각 → 연도 행(`plan_route_years`) — `planned` = 첫 조각(옛 읽는 곳 그대로) ·
|
||||
`pieces` = 그 연도 전부."""
|
||||
"""조각 → 연도 묶음 — `planned` = 첫 조각 · `pieces` = 그 연도 전부 · `fingerprint` = 연도 상태
|
||||
줄(`plan_route_years`) 지문."""
|
||||
by_year: dict[int, list[dict[str, Any]]] = {}
|
||||
for piece in pieces:
|
||||
by_year.setdefault(piece["year"], []).append(piece)
|
||||
@@ -251,150 +249,69 @@ def legacy_network(rows: list[dict[str, Any]]) -> dict[str, Any] | None:
|
||||
}
|
||||
|
||||
|
||||
async def _load(connection: Any, project_id: UUID) -> tuple[dict[str, Any] | None, bool]:
|
||||
"""(정본 · 옛 연도 노선을 바꾼 것인가) — 둘 다 없으면 (None, False)."""
|
||||
async with connection.cursor(aiomysql.DictCursor) as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT network_json FROM plan_networks WHERE project_id = %s", (str(project_id),)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
if row:
|
||||
return _json(row["network_json"]), False
|
||||
await cursor.execute(
|
||||
"SELECT year, epsg, route_json FROM plan_route_years"
|
||||
" WHERE project_id = %s ORDER BY year",
|
||||
(str(project_id),),
|
||||
)
|
||||
legacy = legacy_network(list(await cursor.fetchall()))
|
||||
return legacy, legacy is not None
|
||||
|
||||
|
||||
def _view(
|
||||
network: dict[str, Any] | None, legacy: bool, base: dict[str, Any], year_start: int | None
|
||||
) -> dict[str, Any]:
|
||||
def _view(plan: dict[str, Any], year_start: int | None) -> dict[str, Any]:
|
||||
network = {key: plan[key] for key in ("epsg", "lines", "marks", "pieces")}
|
||||
return {
|
||||
"status": "success",
|
||||
"base": base,
|
||||
"base": plan_base.base_view(plan),
|
||||
"year_start": year_start,
|
||||
"network": network,
|
||||
"derived": derive(network) if network else None,
|
||||
"legacy": legacy,
|
||||
"network": network if plan["lines"] else None,
|
||||
"derived": derive(network) if plan["lines"] else None,
|
||||
"legacy": False,
|
||||
}
|
||||
|
||||
|
||||
async def _year_start(project_id: UUID) -> int | None:
|
||||
async with get_db_pool().acquire() as connection, connection.cursor() as cursor:
|
||||
await cursor.execute("SELECT project_year FROM projects WHERE id = %s", (str(project_id),))
|
||||
row = await cursor.fetchone()
|
||||
return row[0] if row else None
|
||||
|
||||
|
||||
@router.get("/{project_id}/plan/network", response_model=None)
|
||||
async def get_plan_network(project_id: UUID) -> dict[str, Any]:
|
||||
base = await plan_base.load_base(project_id)
|
||||
async with get_db_pool().acquire() as connection:
|
||||
network, legacy = await _load(connection, project_id)
|
||||
async with connection.cursor(aiomysql.DictCursor) as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT project_year FROM projects WHERE id = %s", (str(project_id),)
|
||||
)
|
||||
row = await cursor.fetchone()
|
||||
_, plan = await store.load_plan(project_id)
|
||||
try:
|
||||
return _view(network, legacy, base, row["project_year"] if row else None)
|
||||
return _view(plan, await _year_start(project_id))
|
||||
except NetworkError as error:
|
||||
raise HTTPException(status_code=409, detail=f"저장된 노선이 틀립니다 — {error}") from error
|
||||
|
||||
|
||||
async def _store(
|
||||
connection: Any, project_id: UUID, network: dict[str, Any], derived: dict[str, Any]
|
||||
async def _store_status(
|
||||
connection: Any, project_id: UUID, pieces: list[dict[str, Any]], years: dict[int, Any]
|
||||
) -> None:
|
||||
"""연도 상태 줄 — 있는 연도만(지문이 바뀐 연도만 확정 풂) · 없는 연도 줄 지움 · 사업연도 끝."""
|
||||
pid = str(project_id)
|
||||
epsg = network["epsg"]
|
||||
years = year_rows(derived["pieces"])
|
||||
async with connection.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT DISTINCT piece_id FROM plan_route_assignees"
|
||||
" WHERE project_id = %s AND piece_id IS NOT NULL",
|
||||
(pid,),
|
||||
)
|
||||
assigned = {r[0] for r in await cursor.fetchall()}
|
||||
await cursor.execute(
|
||||
"SELECT DISTINCT year FROM plan_route_assignees"
|
||||
" WHERE project_id = %s AND piece_id IS NULL",
|
||||
(pid,),
|
||||
)
|
||||
assigned_years = {int(r[0]) for r in await cursor.fetchall()}
|
||||
lost = sorted(assigned - {p["id"] for p in derived["pieces"]})
|
||||
lost_years = sorted(assigned_years - set(years))
|
||||
if lost or lost_years:
|
||||
lost = sorted({r[0] for r in await cursor.fetchall()} - {p["id"] for p in pieces})
|
||||
if lost:
|
||||
raise HTTPException(
|
||||
status_code=409,
|
||||
detail=f"업체가 지정된 조각 · 연도를 지울 수 없습니다: {lost + lost_years}",
|
||||
)
|
||||
await cursor.execute(
|
||||
"INSERT INTO plan_networks (project_id, network_json) VALUES (%s, %s)"
|
||||
" ON DUPLICATE KEY UPDATE network_json = VALUES(network_json)",
|
||||
(pid, json.dumps(network, ensure_ascii=False)),
|
||||
)
|
||||
await cursor.execute("DELETE FROM plan_route_pieces WHERE project_id = %s", (pid,))
|
||||
for p in derived["pieces"]:
|
||||
route = {"planned": p["planned"], "stations": p["stations"]}
|
||||
await cursor.execute(
|
||||
"INSERT INTO plan_route_pieces (project_id, piece_id, line_id, year, from_m, to_m,"
|
||||
" length_m, epsg, route_json, fingerprint)"
|
||||
" VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
|
||||
(
|
||||
pid,
|
||||
p["id"],
|
||||
p["line"],
|
||||
p["year"],
|
||||
p["from_m"],
|
||||
p["to_m"],
|
||||
p["length_m"],
|
||||
epsg,
|
||||
json.dumps(route),
|
||||
_sha1(route),
|
||||
),
|
||||
status_code=409, detail=f"업체가 지정된 조각을 지울 수 없습니다: {lost}"
|
||||
)
|
||||
for year, row in years.items():
|
||||
# 내용이 바뀐 연도만 확정 풂(confirmed_at 을 fingerprint 보다 먼저 셈)
|
||||
# confirmed_at 을 fingerprint 보다 먼저 셈
|
||||
await cursor.execute(
|
||||
"INSERT INTO plan_route_years (project_id, year, start_x, start_y, end_x, end_y,"
|
||||
" epsg, route_json, fingerprint) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)"
|
||||
" ON DUPLICATE KEY UPDATE start_x = VALUES(start_x), start_y = VALUES(start_y),"
|
||||
" end_x = VALUES(end_x), end_y = VALUES(end_y), epsg = VALUES(epsg),"
|
||||
" route_json = VALUES(route_json),"
|
||||
"INSERT INTO plan_route_years (project_id, year, fingerprint) VALUES (%s, %s, %s)"
|
||||
" ON DUPLICATE KEY UPDATE"
|
||||
" confirmed_at = IF(fingerprint <=> VALUES(fingerprint), confirmed_at, NULL),"
|
||||
" fingerprint = VALUES(fingerprint)",
|
||||
(
|
||||
pid,
|
||||
year,
|
||||
*row["start"],
|
||||
*row["end"],
|
||||
epsg,
|
||||
json.dumps(row["route"], ensure_ascii=False),
|
||||
row["fingerprint"],
|
||||
),
|
||||
(pid, year, row["fingerprint"]),
|
||||
)
|
||||
marks = ", ".join(["%s"] * len(years))
|
||||
await cursor.execute(
|
||||
"DELETE FROM plan_route_years WHERE project_id = %s"
|
||||
+ (f" AND year NOT IN ({marks})" if years else ""),
|
||||
(pid, *years),
|
||||
)
|
||||
if years:
|
||||
marks = ", ".join(["%s"] * len(years))
|
||||
await cursor.execute(
|
||||
"UPDATE plan_route_years SET route_json = NULL, fingerprint = NULL,"
|
||||
f" confirmed_at = NULL WHERE project_id = %s AND year NOT IN ({marks})",
|
||||
(pid, *years),
|
||||
)
|
||||
await cursor.execute(
|
||||
"UPDATE projects SET project_year_end = %s WHERE id = %s", (max(years), pid)
|
||||
)
|
||||
else:
|
||||
await cursor.execute(
|
||||
"UPDATE plan_route_years SET route_json = NULL, fingerprint = NULL,"
|
||||
" confirmed_at = NULL WHERE project_id = %s",
|
||||
(pid,),
|
||||
)
|
||||
|
||||
|
||||
async def _freeze_base(connection: Any, project_id: UUID, base: dict[str, Any]) -> None:
|
||||
"""옛 연도 행을 접은 지점 → D02 정본 칸(비었을 때만)."""
|
||||
stored = {"epsg": base["epsg"], "points": [{"x": p["x"], "y": p["y"]} for p in base["points"]]}
|
||||
async with connection.cursor() as cursor:
|
||||
await cursor.execute(
|
||||
"UPDATE projects SET plan_base_json = %s WHERE id = %s AND plan_base_json IS NULL",
|
||||
(json.dumps(stored), str(project_id)),
|
||||
)
|
||||
|
||||
|
||||
@router.put("/{project_id}/plan/network", response_model=None)
|
||||
@@ -403,31 +320,32 @@ async def put_plan_network(
|
||||
payload: Network,
|
||||
session: dict[str, Any] = Depends(require_company),
|
||||
) -> dict[str, Any]:
|
||||
"""[저장] · [초기화](lines 빈 것) — 서버가 정본으로 다시 셈 → 정본 · 조각 행 · 연도 행."""
|
||||
"""[저장] · [초기화](lines 빈 것) — 서버가 정본으로 다시 셈 → 파일 · 연도 상태 줄.
|
||||
|
||||
파일은 DB 커밋 직전에 씀 — 파일 쓰기가 깨지면 DB 되돌림 · 커밋이 깨지면 다음 [저장]이 바로잡음
|
||||
(확정은 지문이 같을 때만 보이므로 노선이 틀리게 확정으로 보이지 않음)."""
|
||||
if not is_forest_service(session):
|
||||
raise HTTPException(status_code=403, detail="예정노선은 산림청만 고칠 수 있습니다.")
|
||||
network = payload.model_dump()
|
||||
base = await plan_base.load_base(project_id) # 예정노선 프로젝트가 아니면 404 · 400
|
||||
if base["epsg"] is not None and int(base["epsg"]) != network["epsg"]:
|
||||
raise HTTPException(status_code=400, detail="좌표계가 기준 지정과 다릅니다.")
|
||||
async with get_db_pool().acquire() as connection:
|
||||
async with connection.cursor(aiomysql.DictCursor) as cursor:
|
||||
await cursor.execute(
|
||||
"SELECT project_year, plan_base_json FROM projects WHERE id = %s",
|
||||
(str(project_id),),
|
||||
)
|
||||
project = await cursor.fetchone()
|
||||
async with project_lock(str(project_id)):
|
||||
root, plan = await store.load_plan(project_id) # 없음 404 · 예정노선 아님 400
|
||||
if plan["epsg"] is not None and plan["epsg"] != network["epsg"]:
|
||||
raise HTTPException(status_code=400, detail="좌표계가 기준 지정과 다릅니다.")
|
||||
year_start = await _year_start(project_id)
|
||||
try:
|
||||
derived = derive(network, project["project_year"])
|
||||
derived = derive(network, year_start)
|
||||
except NetworkError as error:
|
||||
raise HTTPException(status_code=400, detail=str(error)) from error
|
||||
await connection.begin()
|
||||
try:
|
||||
if project["plan_base_json"] is None and base["points"]:
|
||||
await _freeze_base(connection, project_id, base)
|
||||
await _store(connection, project_id, network, derived)
|
||||
await connection.commit()
|
||||
except Exception:
|
||||
await connection.rollback()
|
||||
raise
|
||||
return {**_view(network, False, base, project["project_year"]), "derived": derived}
|
||||
plan = {**plan, **network}
|
||||
async with get_db_pool().acquire() as connection:
|
||||
await connection.begin()
|
||||
try:
|
||||
await _store_status(
|
||||
connection, project_id, derived["pieces"], year_rows(derived["pieces"])
|
||||
)
|
||||
store.save_plan(root, plan)
|
||||
await connection.commit()
|
||||
except Exception:
|
||||
await connection.rollback()
|
||||
raise
|
||||
return {**_view(plan, year_start), "derived": derived}
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
"""D 예정노선 설계 내용 한 파일 — `<프로젝트>/D03_PlanAnalysis/plan_network.json`
|
||||
(요구 452 · 453 · PLAN 590-1).
|
||||
|
||||
- 꼴 = `{version, epsg, points: [{x, y}], lines, marks, pieces: [{id, line, from_m, to_m, year}]}` —
|
||||
좌표계 = 머리 한 곳 · 연도 = 조각의 `year` 뿐(빈 연도 줄 없음) · 길이 · 측점 · 조각 좌표 ·
|
||||
연도 지문은 읽을 때 `plan_state` 가 셈(저장 안 함).
|
||||
- DB 에 남는 것 = 등록 칸 · 연도 상태(`plan_route_years` 의 year · fingerprint · confirmed_at) ·
|
||||
업체 줄(`plan_route_assignees` 조각 번호 · 업체 · 메일 시각 · 연결 — 연도는 이 파일에서).
|
||||
- 옮김 = 파일이 없으면 옛 DB 칸(`projects.plan_base_json` · `plan_networks` · `plan_route_years`)을
|
||||
메모리에서 새 꼴로(`migrate`) · 파일은 첫 쓰기 때 생김 · 옛 칸은 손대지 않음(590-3 에서 지움).
|
||||
- 쓰기 = `project_lock(project_id)` 안에서 `save_plan`(같은 폴더 임시 파일 → 바꿔치기 · 반쯤 쓴
|
||||
파일이 안 보임) · 읽기는 잠금 없음.
|
||||
- 확정 = 연도 상태 줄 지문이 파일 지문과 같을 때만(파일만 바뀌고 DB 가 못 따라간 틈 =
|
||||
풀린 것으로 봄).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from uuid import UUID
|
||||
|
||||
import aiomysql
|
||||
from fastapi import HTTPException
|
||||
|
||||
from common_util.common_util_crs import lonlat_to_tm, tm_to_lonlat
|
||||
from common_util.common_util_json import atomic_write_json
|
||||
from common_util.common_util_storage import resolve_stored_project_path
|
||||
from config.config_db import get_db_pool
|
||||
from D03_PlanAnalysis import D03_PlanAnalysis_Network as network
|
||||
from D04_PlanConfirm.D04_PlanConfirm_Repository import line_names
|
||||
|
||||
FILE = Path("D03_PlanAnalysis") / "plan_network.json"
|
||||
VERSION = 1
|
||||
KEYS = ("epsg", "points", "lines", "marks", "pieces")
|
||||
|
||||
|
||||
def empty_plan(epsg: int | None = None) -> dict[str, Any]:
|
||||
return {"version": VERSION, "epsg": epsg, "points": [], "lines": [], "marks": [], "pieces": []}
|
||||
|
||||
|
||||
def plan_path(root: str | Path) -> Path:
|
||||
return Path(root) / FILE
|
||||
|
||||
|
||||
def _clean(plan: dict[str, Any]) -> dict[str, Any]:
|
||||
out = empty_plan()
|
||||
out.update({key: plan[key] for key in KEYS if plan.get(key) is not None})
|
||||
out["epsg"] = int(out["epsg"]) if out["epsg"] is not None else None
|
||||
return out
|
||||
|
||||
|
||||
def read_plan(root: str | Path) -> dict[str, Any] | None:
|
||||
"""파일 — 없으면 None · 이 코드보다 새 판이면 거절(덮어써 잃지 않게)."""
|
||||
path = plan_path(root)
|
||||
if not path.is_file():
|
||||
return None
|
||||
plan = json.loads(path.read_text("utf-8"))
|
||||
if int(plan.get("version") or 0) > VERSION:
|
||||
raise HTTPException(status_code=409, detail="새 판 노선 파일입니다 — 서버를 새로 받으세요.")
|
||||
return _clean(plan)
|
||||
|
||||
|
||||
def save_plan(root: str | Path, plan: dict[str, Any]) -> None:
|
||||
atomic_write_json(plan_path(root), _clean(plan))
|
||||
|
||||
|
||||
def _parsed(value: Any) -> Any:
|
||||
if isinstance(value, (str, bytes)):
|
||||
try:
|
||||
return json.loads(value)
|
||||
except ValueError:
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
def _old_points(base: dict[str, Any] | None, rows: list[dict[str, Any]]) -> tuple[Any, list]:
|
||||
"""옛 지점 칸 → (epsg, [{x, y}]) — points · 옛 starts/ends 목록 · 더 옛 start/end 한 점 ·
|
||||
칸이 비면 [첫 연도 시점, 마지막 연도 종점]으로 접음."""
|
||||
if base:
|
||||
items = base.get("points")
|
||||
if items is None:
|
||||
starts = base.get("starts", [base["start"]] if base.get("start") else [])
|
||||
ends = base.get("ends", [base["end"]] if base.get("end") else [])
|
||||
items = [*starts, *ends]
|
||||
epsg = base.get("epsg")
|
||||
else:
|
||||
dated = [r for r in rows if r.get("start_x") is not None or r.get("end_x") is not None]
|
||||
if not dated:
|
||||
return None, []
|
||||
first, last = dated[0], dated[-1]
|
||||
epsg = first.get("epsg")
|
||||
items = [
|
||||
{"x": first.get("start_x"), "y": first.get("start_y")},
|
||||
{"x": last.get("end_x"), "y": last.get("end_y")},
|
||||
]
|
||||
points = [
|
||||
{"x": float(p["x"]), "y": float(p["y"])}
|
||||
for p in items
|
||||
if p and p.get("x") is not None and p.get("y") is not None
|
||||
]
|
||||
return (epsg if points else None), points
|
||||
|
||||
|
||||
def migrate(base_json: Any, network_json: Any, year_rows: list[dict[str, Any]]) -> dict[str, Any]:
|
||||
"""옛 DB 칸 → 새 꼴(메모리) — 노선 = `plan_networks` · 없으면 옛 연도 노선을 한 선으로."""
|
||||
rows = sorted(year_rows, key=lambda r: int(r["year"]))
|
||||
epsg, points = _old_points(_parsed(base_json), rows)
|
||||
net = _parsed(network_json) or network.legacy_network(rows)
|
||||
plan = empty_plan(int(epsg) if epsg is not None else None)
|
||||
plan["points"] = points
|
||||
if net and net.get("lines"):
|
||||
net_epsg = int(net["epsg"]) if net.get("epsg") is not None else plan["epsg"]
|
||||
if points and plan["epsg"] is not None and net_epsg != plan["epsg"]:
|
||||
plan["points"] = [
|
||||
dict(
|
||||
zip(
|
||||
("x", "y"),
|
||||
lonlat_to_tm(*tm_to_lonlat(p["x"], p["y"], plan["epsg"]), net_epsg),
|
||||
)
|
||||
)
|
||||
for p in points
|
||||
]
|
||||
plan.update(
|
||||
epsg=net_epsg,
|
||||
lines=net.get("lines", []),
|
||||
marks=net.get("marks", []),
|
||||
pieces=net.get("pieces", []),
|
||||
)
|
||||
return plan
|
||||
|
||||
|
||||
async def _project(cursor: Any, project_id: UUID | str) -> dict[str, Any]:
|
||||
await cursor.execute(
|
||||
"SELECT project_kind, project_year, storage_path, plan_base_json FROM projects"
|
||||
" WHERE id = %s AND deleted_at IS NULL",
|
||||
(str(project_id),),
|
||||
)
|
||||
project = await cursor.fetchone()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="프로젝트를 찾을 수 없습니다.")
|
||||
if project["project_kind"] != "PLAN" or project["project_year"] is None:
|
||||
raise HTTPException(status_code=400, detail="예정노선 프로젝트가 아닙니다.")
|
||||
if not project["storage_path"]:
|
||||
raise HTTPException(status_code=404, detail="프로젝트 저장 경로를 찾을 수 없습니다.")
|
||||
return project
|
||||
|
||||
|
||||
async def load_plan(project_id: UUID | str) -> tuple[Path, dict[str, Any]]:
|
||||
"""(프로젝트 실경로, 설계 내용) — 파일 · 없으면 옛 DB 칸을 옮긴 것(쓰지 않음)."""
|
||||
pid = str(project_id)
|
||||
async with (
|
||||
get_db_pool().acquire() as connection,
|
||||
connection.cursor(aiomysql.DictCursor) as cursor,
|
||||
):
|
||||
project = await _project(cursor, pid)
|
||||
root = Path(resolve_stored_project_path(project["storage_path"]))
|
||||
plan = read_plan(root)
|
||||
if plan is not None:
|
||||
return root, plan
|
||||
await cursor.execute("SELECT network_json FROM plan_networks WHERE project_id = %s", (pid,))
|
||||
row = await cursor.fetchone()
|
||||
await cursor.execute(
|
||||
"SELECT year, start_x, start_y, end_x, end_y, epsg, route_json FROM plan_route_years"
|
||||
" WHERE project_id = %s ORDER BY year",
|
||||
(pid,),
|
||||
)
|
||||
years = list(await cursor.fetchall())
|
||||
return root, migrate(project["plan_base_json"], row and row["network_json"], years)
|
||||
|
||||
|
||||
def plan_units(plan: dict[str, Any]) -> list[dict[str, Any]]:
|
||||
"""조각마다 {id · line · line_name · year · epsg · from_m · to_m · length_m · planned ·
|
||||
stations}
|
||||
— 연도 · 선 차례 · 선 위 거리 차례 · 틀리면 `NetworkError`."""
|
||||
pieces = network.derive(plan)["pieces"] if plan["lines"] else []
|
||||
names = dict(zip((line["id"] for line in plan["lines"]), line_names(plan["lines"])))
|
||||
for piece in pieces:
|
||||
piece.update(line_name=names.get(piece["line"], "갈래"), epsg=plan["epsg"])
|
||||
pieces.sort(key=lambda p: p["year"]) # 같은 연도 안 = derive 차례(선 · 거리) 그대로
|
||||
return pieces
|
||||
|
||||
|
||||
async def year_status(project_id: UUID | str) -> dict[int, dict[str, Any]]:
|
||||
"""연도 상태 줄 — {연도: {fingerprint, confirmed_at}}."""
|
||||
async with (
|
||||
get_db_pool().acquire() as connection,
|
||||
connection.cursor(aiomysql.DictCursor) as cursor,
|
||||
):
|
||||
await cursor.execute(
|
||||
"SELECT year, fingerprint, confirmed_at FROM plan_route_years WHERE project_id = %s",
|
||||
(str(project_id),),
|
||||
)
|
||||
return {int(r["year"]): r for r in await cursor.fetchall()}
|
||||
|
||||
|
||||
async def plan_state(project_id: UUID | str) -> dict[str, Any]:
|
||||
"""{root, plan, units, years} — `years` = `year_rows` + `confirmed_at`(지문이 같을 때만) ·
|
||||
단위마다 `confirmed_at` · 노선이 틀리면 409."""
|
||||
root, plan = await load_plan(project_id)
|
||||
try:
|
||||
units = plan_units(plan)
|
||||
except network.NetworkError as error:
|
||||
raise HTTPException(status_code=409, detail=f"저장된 노선이 틀립니다 — {error}") from error
|
||||
years = network.year_rows(units)
|
||||
status = await year_status(project_id)
|
||||
for year, row in years.items():
|
||||
saved = status.get(year)
|
||||
same = saved is not None and saved["fingerprint"] == row["fingerprint"]
|
||||
row["confirmed_at"] = saved["confirmed_at"] if same else None
|
||||
for unit in units:
|
||||
unit["confirmed_at"] = years[unit["year"]]["confirmed_at"]
|
||||
return {"root": root, "plan": plan, "units": units, "years": years}
|
||||
Reference in New Issue
Block a user