Merge remote-tracking branch 'origin/dev' into sub_laptop_1

This commit is contained in:
2026-11-18 08:58:38 +09:00
19 changed files with 287 additions and 236 deletions
+13 -11
View File
@@ -152,11 +152,8 @@ def line(whole: Any, doc: dict, one: dict) -> dict[str, Any]:
docs = dc.closure(whole, dc.calls(base), None) if base else {}
if base is None:
return {"기준": None, "줄": [], "재료": [], "까닭": f"수식 문서 없음 「{code}」"}
row = whole.logic(code)
mats = [] if isinstance(row.get("흐름"), dict) else row.get("호표") or []
apart = dc.apart_of(
one.get("자재표시"), [{"차례": n} for n, x in enumerate(mats) if x.get("종류") == "재료"]
)
mats = dc.prices._mat_lines(base) # 재료 금액 줄(855 L2 ⓑ-3 — 로직 줄 호표 안 읽음)
apart = dc.apart_of(one.get("자재표시"), [{"차례": n} for n, _, _ in mats])
given = dc.given_of(whole, code, one.get("입력값"))
body = dc.line_doc(base, rate, picks, apart)
ans = _traced(body, whole, docs, given, copy)
@@ -186,12 +183,12 @@ def _traced(doc: dict, whole: Any, docs: dict, given: dict, copy: dict) -> dict:
}
def _mats(items: list, ans: dict, picks: Any) -> list[dict[str, Any]]:
"""로직 자재(103-1) — 맨 위 재료 줄(호표 차례 = 문서 금액 줄 차례)마다 셈 기록이 읽은 품목 키 ·
수량 · 단가 · 금액(별도계상 · 같은 품목 400 · 호표 들이기 `_inside` 가 읽음)."""
def _mats(mats: list, ans: dict, picks: Any) -> list[dict[str, Any]]:
"""로직 자재(103-1) — 재료 금액 줄(`_mat_lines` · 단위 = 연결 단위 = 로직 원문 표기)마다
셈 기록이 읽은 품목 키 · 수량 · 단가 · 금액(별도계상 · 같은 품목 400 · `_inside` 가 읽음)."""
calls, lines, out = ans.get("부름") or [], ans.get("줄") or [], []
for n, item in enumerate(items):
if item.get("종류") != "재료" or n >= len(lines):
for n, line, link in mats:
if n >= len(lines):
continue
read = [calls[j] for j in lines[n].get("부름") or [] if j < len(calls)]
keys = [c.get("품목") for c in read] + [
@@ -200,7 +197,12 @@ def _mats(items: list, ans: dict, picks: Any) -> list[dict[str, Any]]:
key = next((k for k in keys if k), None)
head = {k: lines[n].get(k) for k in ("수량", "단가", "금액", "까닭")}
out.append(
{"차례": n, "이름": item.get("이름") or "", "단위": item.get("단위") or "", **head}
{
"차례": n,
"이름": line.get("이름") or "",
"단위": link.get("단위") or line.get("단위") or "",
}
| head
| {"품목": {"키": key} if key else None, "고름": str(n) in (picks or {})}
)
return out
+13 -12
View File
@@ -34,8 +34,8 @@ from M02_MasterTemplete import M02_Template_Layers as layers
if TYPE_CHECKING:
from M02_MasterTemplete.M02_Labor_Expand import Expand
PREFIX = {"precombo": "SC", "sangeun": "SK"}
TITLE = {"precombo": "사전조합", "sangeun": "단가산출"}
PREFIX = {k: layers.SHELF[k]["머리"] for k in layers.LIBRARY_KINDS} # 종류 표 한 벌(858 5-6)
TITLE = {k: layers.SHELF[k]["이름"] for k in layers.LIBRARY_KINDS}
DEPTH = 8 # 참조 깊이 상한(저장 · 계산 둘 다)
REF_HEAD = "참조|"
_KEY = re.compile(r"^(SP|SC|SK)-(\d{6})$")
@@ -352,11 +352,12 @@ def _no_loop(ref: Ref, trail: list[Ref]) -> None:
_no_loop(child, [*trail, child])
#: 층 뿌리 번호 장부 {종류: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻)
#: 층 뿌리 번호 장부 {칸: 발급한 가장 큰 번호} — 지운 끝 번호를 다시 안 씀(854-1 · M01 키대장 규칙과 같은 뜻) ·
#: 칸 = 종류 표 `번호`(SK · SC · 내 기계 · 858 5-6)
ISSUED = "_번호.json"
def _issued() -> dict[str, Any]:
def issued() -> dict[str, Any]:
try:
got = json.loads((store.root() / ISSUED).read_bytes())
except (OSError, ValueError):
@@ -368,18 +369,18 @@ def next_key(kind: str) -> str:
"""지금 층 그 종류의 다음 키(파일 · 장부 가운데 가장 큰 번호 + 1)."""
folder = store.root() / kind
have = [int(m.group(2)) for p in folder.glob("*.json") if (m := _KEY.match(p.stem))]
return f"{PREFIX[kind]}-{max(*have, int(_issued().get(kind) or 0), 0) + 1:06d}"
book = int(issued().get(layers.SHELF[kind]["번호"]) or 0)
return f"{PREFIX[kind]}-{max(*have, book, 0) + 1:06d}"
def _keep_issued(kind: str, key: str) -> None:
"""장부에 발급한 번호(더 클 때만)."""
def keep_issued(book: str, n: int) -> None:
"""장부 `book` 칸에 발급한 번호(더 클 때만)."""
from common_util.common_util_json import atomic_write_json
n = int(_KEY.match(key).group(2))
with store._LOCK:
got = _issued()
if int(got.get(kind) or 0) < n:
atomic_write_json(store.root() / ISSUED, {**got, kind: n})
got = issued()
if int(got.get(book) or 0) < n:
atomic_write_json(store.root() / ISSUED, {**got, book: n})
def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
@@ -392,7 +393,7 @@ def create(kind: str, doc: dict[str, Any]) -> dict[str, Any]:
if e.status != 409 or not isinstance(e.detail, dict):
raise
else:
_keep_issued(kind, key)
keep_issued(layers.SHELF[kind]["번호"], int(_KEY.match(key).group(2)))
return got
raise _bad("새 키를 못 잡음 — 다시 누름", 409)
+1 -64
View File
@@ -2,7 +2,7 @@
문서 읽기 · 쓰기는 양식 길(`GET/PUT /api/m02/layers/{층}/templates/labor/{열}`) 그대로 ·
여기는 저장하지 않는 셈만 + 서고(단가승격 · 사전조합 · 50-3) 새로 · 복사(키는 서버가 줌 · 고침 ·
지우기는 양식 길 그대로) + 개인 자재 목록 · 추가(148-2 · 개인 층만 · 품번은 서버) +
지우기는 양식 길 그대로) + 내 재료 길은 `M02_MyMachine_Router`(858 5-6) +
서고 나무 자유 폴더(158-1 · 716-4 `{종류}-tree` · `M02_Precombo_Folders` · 읽기 = 층 읽기 ·
고침 = 층 쓰기) +
일위대가 실무자료 길 = `M02_Hopyo_Router`(785-5).
@@ -24,7 +24,6 @@ from M02_MasterTemplete import M02_Labor_Ref as refs
from M02_MasterTemplete import M02_Layer_Access as access
from M02_MasterTemplete import M02_Library_Ask as library_ask
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Material_Own as own
from M02_MasterTemplete import M02_Precombo_Folders as pre_folders
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import (
Layer,
@@ -162,65 +161,3 @@ def paste_library_tree(
target = _root(session, layer, owner, write=True)
source = _root(session, body.from_layer, body.from_owner)
return _call(target, pre_folders.paste, source, body.대상, body.경로, kind)
@router.get("/layers/{layer}/materials")
def own_materials(
layer: Layer,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록 · 줄마다 쓰는 곳(840-4)."""
if layer != "personal":
return {"줄": []}
folder = _root(session, layer, owner)
rows = own.rows(folder)
from M02_MasterTemplete import M02_Library_Uses as library_uses
used = library_uses.materials(folder, [str(r.get("키")) for r in rows])
return {"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows]}
@router.post("/layers/{layer}/materials")
def new_material(
layer: Layer,
body: dict[str, Any],
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""신규 자재(148-2) — `{이름, 규격, 단위, 값}` → 새 줄(품번 `PM` + 6자리 서버 일련) ·
개인 층만."""
if layer != "personal":
raise HTTPException(status_code=400, detail="신규 자재는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
return _call(folder, own.add, folder, body)
@router.put("/layers/{layer}/materials/{key}")
def edit_material(
layer: Layer,
key: str,
body: dict[str, Any],
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""내 재료 고침(840-4) — `{이름, 규격, 단위, 값}` · 키 그대로 · 개인 층만."""
if layer != "personal":
raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
return _call(folder, own.update, folder, key, body)
@router.delete("/layers/{layer}/materials/{key}")
def drop_material(
layer: Layer,
key: str,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""내 재료 지움(840-4) — 쓰는 곳 있으면 409 · 개인 층만."""
if layer != "personal":
raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
_call(folder, own.remove, folder, key)
return {"ok": True}
@@ -474,8 +474,8 @@ export function openFindPicker(opt: FindPickOptions): void {
.catch(fail);
if (opt.mineMat && ok("material"))
void listMyMaterials(opt.mineMat.owner)
.then((rows) => {
mats = rows;
.then((got) => {
mats = got.줄;
draw();
})
.catch(fail);
+17 -4
View File
@@ -9,6 +9,8 @@
840-4 내 재료 = M01 재료 DB 에 없는 자재를 등록하는 자리 — M01 과 이름 · 규격 · 단위가 같으면 막음(409) ·
고치기 · 지우기(쓰는 곳 있으면 막음) · 단가산출 셈 색인에 M01 재료처럼 얹음(`whole` · `M02_Sangeun_Copy.whole_`)
→ 프로젝트 층 밖 SK 는 값이 바뀌면 자동 따라옴(836-2 `M02_Sk_AutoRenew`) · 프로젝트 층 = 사본 값.
858 5-6 — 자리 · 머리 = 서고 종류 표(`Template_Layers.SHELF`) · 판 = 파일 바이트 지문(`version`) · 고칠 때 연 판이
다르면 409 {stale, 판, 까닭}(한 파일 + 판 · 브레인 정함) · 길 = `M02_MyMachine_Router`(내 기계와 한 묶음).
"""
from __future__ import annotations
@@ -23,8 +25,7 @@ from common_util.common_util_json import atomic_write_json
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
FILE = "개인자재.json"
PREFIX = "PM"
FILE, PREFIX = layers.SHELF["my-material"]["자리"], layers.SHELF["my-material"]["머리"]
KEY = re.compile(rf"^{PREFIX}(\d{{6}})$")
FIND = re.compile(rf"(?<![A-Za-z0-9]){PREFIX}\d{{6}}(?!\d)")
COLS = ("이름", "규격", "단위")
@@ -122,9 +123,21 @@ def add(folder: str | Path, body: dict[str, Any]) -> dict[str, Any]:
return got
def update(folder: str | Path, key: str, body: dict[str, Any]) -> dict[str, Any]:
"""내 재료 한 줄 고침(키 그대로) — 없는 키 = 404 · 검사는 새로 만들기와 같음."""
def version(folder: str | Path) -> str:
"""내 재료 파일 판(바이트 지문 · 없으면 빈 글)."""
path = Path(folder) / FILE
return store.version_of(path.read_bytes()) if path.is_file() else ""
def update(
folder: str | Path, key: str, body: dict[str, Any], ver: str | None = None
) -> dict[str, Any]:
"""내 재료 한 줄 고침(키 그대로) — 없는 키 = 404 · 검사는 새로 만들기와 같음 · `ver`(화면이 연 판)가
지금 판과 다르면 409 {stale, 판, 까닭}(None = 대조 없음)."""
with store._LOCK:
if ver is not None and (have := version(folder)) != ver:
why = "다른 곳에서 먼저 고침 — 목록을 다시 읽고 고침"
raise store.StoreError(409, {"stale": [key], "판": have, "까닭": why})
doc = read(folder)
at = next((i for i, r in enumerate(doc["줄"]) if r.get("키") == key), None)
if at is None:
+7 -12
View File
@@ -11,7 +11,7 @@
import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
import { openModal } from "@ui/ui_template_modal";
import { searchMaterials } from "../M01_MasterData/M01_MasterData_Api_Fetch";
import { call } from "./M02_MasterTemplete_Api_Fetch";
import { addMyMaterial, listMyMaterials } from "./M02_MyMaterial_Api";
import { createUnitPick, NO_UNIT } from "@ui/ui_template_unit_pick";
import { createBadge } from "@ui/ui_template_badge";
import { createText } from "@ui/ui_template_text";
@@ -60,8 +60,6 @@ const TEXT = {
needName: "품명 · 단위는 꼭 적음",
};
const ownPath = (own: OwnLayer): string =>
`/layers/personal/materials${own.owner ? `?owner=${encodeURIComponent(own.owner)}` : ""}`;
const toItem = (r: OwnRow): MaterialItem => ({
코드: r.키,
이름: r.이름,
@@ -78,7 +76,7 @@ const matches = (r: OwnRow, words: string[]): boolean => {
export function pickMaterial(done: (item: MaterialItem) => void, own?: OwnLayer): void {
let mine: OwnRow[] = [];
const loaded = own
? call<{ 줄: OwnRow[] }>(ownPath(own))
? listMyMaterials(own.owner)
.then((d) => void (mine = d.줄))
.catch(() => undefined)
: Promise.resolve();
@@ -225,14 +223,11 @@ function newForm(
const raw = price.input.value.trim();
try {
saved(
await call<OwnRow>(ownPath(own), {
method: "POST",
body: JSON.stringify({
이름,
규격: spec.input.value.trim(),
단위: unit,
값: raw === "" ? null : Number(raw),
}),
await addMyMaterial(own.owner, {
이름,
규격: spec.input.value.trim(),
단위: unit,
값: raw === "" ? null : Number(raw),
}),
);
} catch (e) {
+20 -41
View File
@@ -1,7 +1,7 @@
"""M02 내 기계(PLAN 821-1 · 요구 795 · 요구서_796 3 · 7 장) — 개인 층 기계 줄 목록 · 서버 단독.
저장 = 층 뿌리 폴더 `내기계/` — 한 대 한 파일 `<키>.json`(줄) + `_다음.json` {다음: 수}(826-2 ·
옛 `내기계.json` {줄, 다음} 은 읽을 때 한 번 옮기고 지움) — 줄 = M01 기계 줄 꼴
저장 = 층 뿌리 폴더 `내기계/` — 한 대 한 파일 `<키>.json`(줄 · 826-2) · 번호 = 층 번호 장부 `_번호.json`
「내기계」 칸(서고 종류 표 `Template_Layers.SHELF` · `Labor_Ref.issued` · 858 5-6) — 줄 = M01 기계 줄 꼴
{키 `EQP{사용자}-####`, 원문번호 「개인 {키}」, 원문 · 구분 · 출처 = 개인, 상세구분 · 이름, 규격,
단위, 값, 비고, 방식 바로|품셈|직접, 시간당?(직접 {노무비, 재료비, 경비}), 넣은날, 고친날, 본뜬?}
값 칸 이름 = M01 기계 줄과 같음 · 바로 = 손료계수 한 칸 · 품셈 = 비율 다섯 → 계수 넷(저장 때 서버가
@@ -23,7 +23,6 @@ from __future__ import annotations
import json
import os
import re
import threading
from collections.abc import Callable
from contextvars import ContextVar
from datetime import datetime
@@ -34,9 +33,10 @@ from typing import Any
from common_util.common_util_json import atomic_write_json
from M01_MasterData import M01_MasterData_Store as m01
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Template_Layers as layers
FILE, DIR, NEXT = "내기계.json", "내기계", "_다음.json" # FILE = 옛 한 파일(옮기기만)
PREFIX, NO = "EQP", "개인 "
_SHELF = layers.SHELF["my-machine"] # 서고 종류 표(858 5-6)
DIR, PREFIX, NUMBER, NO = _SHELF["자리"], _SHELF["머리"], _SHELF["번호"], "개인 "
FIND = re.compile(rf"{NO}({PREFIX}\d+-\d+)") # 문서 안 기계 입력 「개인 EQP…」
EASY, BOOK, DIRECT = "바로", "품셈", "직접"
COSTS = ("노무비", "재료비", "경비")
@@ -57,9 +57,9 @@ POWER, POWER_CREW, DIRECT_KEY = "GC001196", "GC001197", "GC001199"
FUEL_POWER, FUEL_POWER_CREW = "GC001200", "GC001201" # 연료 + 전력(+ 조종원) — 경쟁사 구성(822-2b)
#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 자기 잠금(`store._LOCK` 안에서 불려도 교착 없게)
# ponytail: 프로세스 안 잠금 · 서버를 여럿 띄우면 파일 잠금으로
_LOCK = threading.RLock()
#: 번호 발급 · 고치기 · 지우기 한 번에 하나(854-1) — 서고 쓰기 잠금 한 벌(`store._LOCK` · RLock · 858 5-6 —
#: 층 번호 장부를 SK · SC 와 같이 씀 · `Store.write` 안 불러오기가 `create` 를 불러도 교착 없음)
_LOCK = store._LOCK
#: 단가산출 기계 창 초안(827-1 · `M02_MyMachine_Draft`) — 셈 꼴 줄 · 미리 셈 · 저장 한 요청 안만 `whole()` 위에 얹음
@@ -96,21 +96,6 @@ def _order(path: Path) -> tuple:
return (head, int(n) if n.isdigit() else 0, path.stem)
def _move(folder: Path | None = None) -> None:
"""옛 한 파일 `내기계.json` → 폴더(한 번 · 내용 같음 · 옛 파일 지움)."""
old = Path(folder or store.root()) / FILE
if not old.is_file():
return
got = _load(old)
base = _dir(folder)
for row in got.get("줄") or []:
if isinstance(row, dict) and mine(row.get("키")):
atomic_write_json(base / f"{row['키']}.json", row)
had = int(_load(base / NEXT).get("다음") or 1) # 옛 코드 창이 다시 쓴 옛 파일도 — 번호는 큰 쪽
atomic_write_json(base / NEXT, {"다음": max(had, int(got.get("다음") or 1))})
old.unlink()
def _put(row: dict) -> None:
atomic_write_json(_dir() / f"{row['키']}.json", row)
@@ -122,33 +107,28 @@ def version(key: str) -> str:
def add(build: Callable[[str], dict]) -> dict:
"""새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — `_다음` 번호 · 이미 있는 파일 번호는 건너뜀(덮어쓰기 없음) ·
`build(키)` = 저장 줄."""
"""새 번호 발급 + 쓰기를 한 잠금 안에서(854-1) — 층 번호 장부 다음 번호 · 이미 있는 파일 번호는 건너뜀
(덮어쓰기 없음) · 지운 끝 번호 안 다시 씀 · `build(키)` = 저장 줄."""
from M02_MasterTemplete import M02_Labor_Ref as refs
with _LOCK:
_move()
user, n = _user(), int(_load(_dir() / NEXT).get("다음") or 1)
user, n = _user(), int(refs.issued().get(NUMBER) or 0) + 1
while (_dir() / f"{PREFIX}{user}-{n:04d}.json").exists():
n += 1
row = build(f"{PREFIX}{user}-{n:04d}")
atomic_write_json(_dir() / NEXT, {"다음": n + 1}) # 번호 먼저 — 겹쳐 쓰지 않게
refs.keep_issued(NUMBER, n) # 번호 먼저 — 겹쳐 쓰지 않게
_put(row)
return row
def _read(folder: Path | None = None) -> dict[str, Any]:
_move(folder)
base = _dir(folder)
rows = []
for path in sorted(base.glob(f"{PREFIX}*.json"), key=_order):
def rows(folder: Path | None = None) -> list[dict]:
"""지금 층 내 기계 줄(저장 꼴 · 넣은 차례)."""
out = []
for path in sorted(_dir(folder).glob(f"{PREFIX}*.json"), key=_order):
row = _load(path)
if isinstance(row, dict) and mine(row.get("키")) and path.stem == row["키"]:
rows.append(row)
return {"줄": rows, "다음": int(_load(base / NEXT).get("다음") or 1)}
def rows(folder: Path | None = None) -> list[dict]:
"""지금 층 내 기계 줄(저장 꼴)."""
return _read(folder)["줄"]
out.append(row)
return out
# ── 셈 색인 ──────────────────────────────────────────────────────────
@@ -184,7 +164,6 @@ def _whole(base: Any = None) -> Any:
from M02_MasterTemplete import M02_Sangeun_Copy as skc
base = m01.loaded()[1] if base is None else base
_move()
path = _dir()
try:
with os.scandir(path) as it: # 폴더 자국 — 대마다 (이름, 시각, 크기)
+17 -9
View File
@@ -3,10 +3,11 @@
* M02 내 기계 · 내 품목 서버 호출(PLAN 821-3) — 개인 층만.
* 내 기계 = `/layers/personal/my-machines`(821-1 · `M02_MyMachine_Router`) — 목록 · 하나 · 만들기 · 고치기 · 지우기
* 양식 목록 · 비슷한 기계 찾기 · 내 품목 = `M02_MyMachine_Look`(읽기만)
* 길 = 「종류 + 층」 한 함수 `shelfPath`(858 5-6 · 내 재료 `M02_MyMaterial_Api` 도 씀)
* ========================================================================== */
import type { MachinePick, MachineValues } from "../common_util/common_util_machine_sheet";
import { call } from "./M02_MasterTemplete_Api_Fetch";
import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
import type { M01Element } from "./M02_MasterTemplete_Find_Pick";
export type MachineHow = "바로" | "품셈" | "직접";
@@ -91,14 +92,21 @@ export interface MyItem {
쓰는곳: Use[];
}
const at = (owner: string | null, tail = "", q: Record<string, string> = {}): string => {
/** 내 기계 · 내 재료 길 종류(서버 `M02_MyMachine_Router` · `M02_MyMachine_Look`) */
export type ShelfKind = "my-machines" | "materials" | "my-machine-find" | "my-items";
/** 「종류 + 층」 길 한 함수 — `owner` = 남의 층(없으면 내 층) · `tail` = `/키` 등 · 층 = 지금은 개인 층만 */
export const shelfPath = (
kind: ShelfKind,
owner: string | null,
tail = "",
q: Record<string, string> = {},
layer: Layer = "personal",
): string => {
const ask = new URLSearchParams({ ...q, ...(owner ? { owner } : {}) }).toString();
return `/layers/personal/my-machines${tail}${ask ? `?${ask}` : ""}`;
};
const look = (owner: string | null, path: string, q: Record<string, string> = {}): string => {
const ask = new URLSearchParams({ ...q, ...(owner ? { owner } : {}) }).toString();
return `/layers/personal/${path}${ask ? `?${ask}` : ""}`;
return `/layers/${layer}/${kind}${tail}${ask ? `?${ask}` : ""}`;
};
const at = (owner: string | null, tail = ""): string => shelfPath("my-machines", owner, tail);
const key = (k: string): string => `/${encodeURIComponent(k)}`;
export const listMyMachines = async (owner: string | null): Promise<MyMachineRow[]> =>
@@ -148,10 +156,10 @@ export const fetchMyMachineLists = (): Promise<MachineLists> =>
}));
export const findSimilar = async (owner: string | null, q: string): Promise<SimilarRow[]> =>
(await call<{ rows: SimilarRow[] }>(look(owner, "my-machine-find", { q }))).rows;
(await call<{ rows: SimilarRow[] }>(shelfPath("my-machine-find", owner, "", { q }))).rows;
export const listMyItems = async (owner: string | null): Promise<MyItem[]> =>
(await call<{ rows: MyItem[] }>(look(owner, "my-items"))).rows;
(await call<{ rows: MyItem[] }>(shelfPath("my-items", owner))).rows;
/** 단가산출 줄 기계 입력 글(줄 쌓기 `기계='개인 EQP…'`) */
export const machineArg = (no: string): string => `'${no}'`;
+71 -2
View File
@@ -5,6 +5,9 @@ POST 만들기 몸 {줄?, 본뜬?: M01 · 내 기계 키(「비슷한 기계에
PUT `/{키}` 몸 {줄, 판?}(판 = 연 판 · 다르면 409 {stale, 판} · 854-1) ·
POST `/{키}/impact` 몸 {줄} = 저장 전 영향(848-5 · 쓰기 없음) · DELETE `/{키}`(답 = 쓰는곳 — 그 단가산출은 사본의 마지막 값 그대로) ·
옛 POST `/draft`(기계 창 [확인] · 화면 0)은 853-3 에서 지움 — 확인 셈 `M02_MyMachine_Draft.check` 는 시험 827-1 기준값으로 남김.
내 재료 길(858 5-6 · `M02_Material_Own` · 길 글자 그대로) = `/api/m02/layers/{층}/materials`(/{키}) — GET 목록
{줄(줄마다 쓰는곳), 판} · POST 만들기 · PUT 고치기 몸 {이름, 규격, 단위, 값, 판?}(판 다르면 409) · DELETE 지우기
(쓰는 곳 있으면 409) · 개인 층만(회사 · 마스터 = 빈 목록 · 쓰기 400).
권한 = 층 권한 한 벌(`Router_Items._root` — 본인 개인 층 · 맡은 회사 관리자) · 개인 층만(그 밖 404).
⚠ 등록은 `main.py`(로그인만).
"""
@@ -13,13 +16,15 @@ from __future__ import annotations
from typing import Any
from fastapi import APIRouter, Depends
from fastapi import APIRouter, Depends, HTTPException
from pydantic import BaseModel
from common_util.common_util_auth import verify_session
from M02_MasterTemplete import M02_Library_Uses as library_uses
from M02_MasterTemplete import M02_Material_Own as own
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete import M02_MyMachine_Impact as impact
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Session, _call, _root
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root
router = APIRouter(prefix="/api/m02", tags=["M02 My Machine"])
PATH = "/layers/{layer}/my-machines"
@@ -85,3 +90,67 @@ def my_machine_delete(
layer: str, key: str, owner: str | None = None, session: Session = Depends(verify_session)
):
return _call(_folder(session, layer, owner, True), mym.delete, key)
# ── 내 재료(858 5-6 · `Labor_Router` 에서 옮김) ──────────────────────────
@router.get("/layers/{layer}/materials")
def own_materials(
layer: Layer,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""개인 자재 목록(148-2) — 개인 층만 · 회사 · 마스터 = 빈 목록 · 줄마다 쓰는 곳(840-4)."""
if layer != "personal":
return {"줄": []}
folder = _root(session, layer, owner)
rows = own.rows(folder)
used = library_uses.materials(folder, [str(r.get("키")) for r in rows])
return {
"줄": [{**r, "쓰는곳": used[str(r.get("키"))]} for r in rows],
"판": own.version(folder),
}
@router.post("/layers/{layer}/materials")
def new_material(
layer: Layer,
body: dict[str, Any],
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""신규 자재(148-2) — `{이름, 규격, 단위, 값}` → 새 줄(품번 `PM` + 6자리 서버 일련) ·
개인 층만."""
if layer != "personal":
raise HTTPException(status_code=400, detail="신규 자재는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
return _call(folder, own.add, folder, body)
@router.put("/layers/{layer}/materials/{key}")
def edit_material(
layer: Layer,
key: str,
body: dict[str, Any],
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""내 재료 고침(840-4) — `{이름, 규격, 단위, 값, 판?}` · 키 그대로 · 개인 층만 · 판 다르면 409(858 5-6)."""
if layer != "personal":
raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
return _call(folder, own.update, folder, key, body, body.get("판"))
@router.delete("/layers/{layer}/materials/{key}")
def drop_material(
layer: Layer,
key: str,
owner: str | None = None,
session: Session = Depends(verify_session),
) -> dict:
"""내 재료 지움(840-4) — 쓰는 곳 있으면 409 · 개인 층만."""
if layer != "personal":
raise HTTPException(status_code=400, detail="내 재료는 개인 층에서만")
folder = _root(session, layer, owner, write=True)
_call(folder, own.remove, folder, key)
return {"ok": True}
+20 -9
View File
@@ -1,10 +1,13 @@
/* =============================================================================
* M02_MyMaterial_Api.ts
* M02 내 재료(개인 자재 PM · PLAN 840-4) 서버 호출 — 개인 층만 · 서버 `M02_Labor_Router` 의 /layers/personal/materials
* 목록(줄마다 쓰는 곳) · 만들기 · 고치기 · 지우기(쓰는 곳 있으면 409) · M01 재료 DB 와 같은 이름 · 규격 · 단위 = 409
* M02 내 재료(개인 자재 PM · PLAN 840-4) 서버 호출 — 개인 층만 · 서버 `M02_MyMachine_Router` 의 /layers/personal/materials
* (길 = 내 기계와 한 함수 `shelfPath` · 858 5-6)
* 목록(줄마다 쓰는 곳 + 파일 판) · 만들기 · 고치기(연 판 · 다르면 409 `StaleError`) · 지우기(쓰는 곳 있으면 409)
* · M01 재료 DB 와 같은 이름 · 규격 · 단위 = 409
* ========================================================================== */
import { call } from "./M02_MasterTemplete_Api_Fetch";
import { shelfPath } from "./M02_MyMachine_Api";
export interface MyMaterialUse {
종류: string;
@@ -23,13 +26,17 @@ export interface MyMaterial {
export type MyMaterialBody = Pick<MyMaterial, "이름" | "규격" | "단위" | "값">;
const path = (owner: string | null, key = ""): string =>
`/layers/personal/materials${key ? `/${encodeURIComponent(key)}` : ""}${
owner ? `?owner=${encodeURIComponent(owner)}` : ""
}`;
/** 목록 + 파일 판(고칠 때 보냄 · 858 5-6) */
export interface MyMaterialList {
줄: MyMaterial[];
판?: string;
}
export const listMyMaterials = (owner: string | null): Promise<MyMaterial[]> =>
call<{ 줄: MyMaterial[] }>(path(owner)).then((d) => d.줄);
const path = (owner: string | null, key = ""): string =>
shelfPath("materials", owner, key ? `/${encodeURIComponent(key)}` : "");
export const listMyMaterials = (owner: string | null): Promise<MyMaterialList> =>
call<MyMaterialList>(path(owner));
export const addMyMaterial = (owner: string | null, body: MyMaterialBody): Promise<MyMaterial> =>
call<MyMaterial>(path(owner), { method: "POST", body: JSON.stringify(body) });
@@ -38,8 +45,12 @@ export const editMyMaterial = (
owner: string | null,
key: string,
body: MyMaterialBody,
ver?: string,
): Promise<MyMaterial> =>
call<MyMaterial>(path(owner, key), { method: "PUT", body: JSON.stringify(body) });
call<MyMaterial>(path(owner, key), {
method: "PUT",
body: JSON.stringify({ ...body, 판: ver ?? null }),
});
export const dropMyMaterial = (owner: string | null, key: string): Promise<unknown> =>
call(path(owner, key), { method: "DELETE" });
+12 -3
View File
@@ -5,6 +5,7 @@
* 표 = 이름 · 규격 · 단위 · 값 · 쓰는 곳 · 키 · 줄 누름 = 아래 칸에서 고치기 · [새 자재] = 빈 칸
* [저장] = 서버(M01 과 이름 · 규격 · 단위 같으면 서버가 막음 — 까닭 그대로 알림) · [지우기] = 쓰는 곳 있으면 서버가 막음
* 값을 고치면 그 재료를 쓰는 개인 층 단가산출이 따라옴(836-2 자동 따라옴 · 프로젝트 층 = 사본 값)
* [저장] 고치기 = 목록 때 받은 판을 같이 보냄 — 다른 탭이 먼저 고쳤으면 서버 409 → 까닭 알림 · 칸 닫고 다시 읽음(858 5-6)
* 남의 층(owner 있음) = 읽기만
* ========================================================================== */
@@ -13,6 +14,7 @@ import { createDataTable } from "@ui/ui_template_data_table";
import { createInputField, el, showConfirmDialog, showToast } from "@ui/ui_template_elements";
import { createText } from "@ui/ui_template_text";
import { createUnitPick, NO_UNIT } from "@ui/ui_template_unit_pick";
import { StaleError } from "./M02_MasterTemplete_Api_Fetch";
import {
addMyMaterial,
dropMyMaterial,
@@ -50,6 +52,7 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement {
const canWrite = opt.owner === null;
let rows: MyMaterial[] = [];
let editing: MyMaterial | null = null;
let ver: string | undefined; // 목록 때 받은 파일 판(858 5-6)
let unit = "";
const table = createDataTable({
caption: TEXT.title,
@@ -128,10 +131,12 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement {
form.hidden = true;
}
async function load(): Promise<void> {
rows = await listMyMaterials(opt.owner).catch((e) => {
const got = await listMyMaterials(opt.owner).catch((e) => {
showToast(e instanceof Error ? e.message : String(e), "error");
return [];
return { 줄: [] as MyMaterial[], 판: undefined };
});
rows = got.줄;
ver = got.판;
table.setRows(rows.map((r) => ({ ...r, 쓰는곳: r.쓰는곳?.length ?? 0 })));
}
async function save(): Promise<void> {
@@ -146,13 +151,17 @@ export function buildMyMaterialBlock(opt: MyMaterialBlockOptions): HTMLElement {
};
saveBtn.disabled = true;
try {
if (editing) await editMyMaterial(opt.owner, editing.키, body);
if (editing) await editMyMaterial(opt.owner, editing.키, body, ver);
else await addMyMaterial(opt.owner, body);
showToast(TEXT.saved, "success");
close();
await load();
} catch (e) {
showToast(e instanceof Error ? e.message : String(e), "error");
if (e instanceof StaleError && (e.detail as { 판?: string } | null)?.판 !== undefined) {
close(); // 옛 판 — 다른 곳 고침을 덮지 않게 다시 읽음
await load();
}
} finally {
saveBtn.disabled = false;
}
+22 -11
View File
@@ -5,7 +5,7 @@
뺀줄 · 더한줄 · 수식고침 · 식 칸) = 못 셈 + 까닭 하나 · 굳힌 사본(B09 · 구조물 사본 GX9) = 옛 길(`_frozen` ·
`resolve` 바탕 사슬 · `_bundles` · `_rated` 율 더한줄 — B9 걸음 몫 · `Doc_Import._ctx` 도 고친 줄 도구를 씀).
계산 자리(CLAUDE.md 5장 ③) = 서버 단독 · 화면은 셈 길(저장 안 함 · 최신 응답만).
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 + 서버가 `바탕판` · `M01판` 적음.
저장(`clean_doc`) = 꼴 검사 + 참조 위 층 · 있는 문서 · 순환 422 · 바탕 머리 = 기초 문서(855 L2 ⓑ-3).
SK 단위 환산(728-2) = 배 = 바탕 기준단위(「100본」) → SK 단위(`master_unit.swap` ·
「식」 · 빈 단위 = 앞 수 뗀 바탕 단위) · 다른 성격 = 문서 `환산` {계수 | 단위중량 {종별, 형상}} ·
없으면 셈 막음(까닭) · 화면 셈 길 줄 · 계 = SK 1 단위 몫(`per_unit`).
@@ -247,9 +247,9 @@ def _bundled(item: dict, sub: dict) -> dict:
def tag_of(whole: Any, code: str) -> str:
"""꼬리표 = 기초 원문번호(「9-12-1」) · 없으면 키."""
"""꼬리표 = 기초 원문번호(「9-12-1」 · 문서 이름표 855 L2 ⓑ-3) · 없으면 키."""
try:
return str(whole.logic(code).get("원문번호") or code)
return str(sd.doc_row(whole, code).get("원문번호") or code)
except Exception: # noqa: BLE001
return code
@@ -279,10 +279,11 @@ def _bundles(row: dict, whole: Any, expand: Any, trail: tuple) -> None:
def _row_of(doc: dict, whole: Any) -> dict:
"""배 · 바탕판이 읽는 바탕 줄(셈 아님) — 바탕 로직 = 그 줄 · 없음 = 빈 줄(가져온 식 = 그 줄)."""
"""배가 읽는 바탕 머리(셈 아님) — 바탕 로직 = 기초 문서 머리(`sd.doc_row` · 855 L2 ⓑ-3) ·
없음 = 빈 줄(가져온 식 = 그 줄)."""
key = (doc.get("바탕") or {}).get("로직")
try:
return whole.logic(key) if key else sd.empty_row(doc)
return sd.doc_row(whole, key) if key else sd.empty_row(doc)
except Exception as e: # noqa: BLE001 — 없는 로직
raise sd.DocError(f"바탕 로직 · {e}") from e
@@ -311,7 +312,7 @@ def run(
copy = dsk.copy_of(doc, whole)
if copy is None:
why = dsk.OLD_WHY if dsk.own(doc) else dsk.REF_WHY
none = {"기준": None, "1단위": None, "배": Decimal(1), "바탕판": "", "줄": [], "정체": []}
none = {"기준": None, "1단위": None, "배": Decimal(1), "줄": [], "정체": []}
return {**head, **none, "까닭": why, "수식셈": {"셈됨": False, "따로": False, "까닭": why}}
row = _row_of(doc, whole)
times = ratio_of(doc, row, whole)
@@ -331,7 +332,6 @@ def run(
"기준": total,
"1단위": {k: v / times for k, v in total.items()} if total else None,
"배": times,
"바탕판": fingerprint(row),
"줄": lines,
"정체": [x["cid"] for x in lines],
"끝수": got.get("끝수"),
@@ -496,21 +496,32 @@ def _check_refs(doc: dict, here_: refs.Here) -> None:
refs._no_loop(ref, [me, ref])
def _head_of(doc: dict, whole: Any) -> dict[str, Any]:
"""저장 검사가 읽는 바탕 — 로직 바탕 · 옛 칸 고침 없음 = 기초 문서 머리(입력 이름 · 결과단위 ·
855 L2 ⓑ-3 로직 줄 안 읽음) · 그 밖(가져온 식 · 참조 · 옛 칸) = 바탕 사슬(`_base_of`)."""
if "로직" in (doc.get("바탕") or {}) and not dsk.patched(doc):
try:
return {"줄": sd.doc_row(whole, doc["바탕"]["로직"]), "짝잃음": []}
except Exception as e: # noqa: BLE001 — 엔진 FormulaError(없는 기초)
raise sd.DocError(f"바탕 로직 · {e}") from e
return _base_of(doc, whole, refs.read_ref, ())
def clean_doc(doc: Any, here_: refs.Here) -> dict[str, Any]:
"""저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 서버가 `바탕판` · `M01판` ·
옛 칸 덮개 · 둘째 기초 `원값` 적기는 걷음(옛 칸 셈 은퇴 · 855 2-C1)."""
"""저장 꼴(`Labor_Ref.clean_doc` 가 부름) — 검사 · 참조 · 순환 · 가져온 식 검산 · 서버가 적던
`바탕판` · `M01판` · 옛 칸 덮개 · 둘째 기초 `원값` 은 걷음(855 2-C1 · 2-D · L2 ⓑ-3)."""
raw, job = doc, doc.get(skc.JOB) if isinstance(doc, dict) else None # 수식 사본(802-4a)
whole = skc.over(doc := skc.settle(doc, True), skc.whole_()) # 사본(795-1) · 내 기계(821-1)
try:
rough = sd.clean(doc, None, whole)
_check_refs(rough, here_)
eqm.strict(base := _base_of(rough, whole, refs.read_ref, ())) # 수식 고침(796-2b)
eqm.strict(base := _head_of(rough, whole)) # 수식 고침(796-2b)
blk.strict(rough, whole) # 끊은 기초 수식 고침(796-2e)
out = sd.clean(doc, base["줄"], whole)
out["바탕"], out["더한줄"] = rough["바탕"], rough["더한줄"]
for one in out["더한줄"]: # 처음수량(744-1) = 넣을 때 수량 · 없으면 지금 수량
one.setdefault("처음수량", one["수량"])
out |= const.stamp(base["줄"], out) # 바탕판 · M01판(790-2) · 식 칸 엔진 식(792-1)
const.stamp(out) # 가져온 식 검산(793-2)
ratio_of(out, base["줄"], whole) # 단위 못 바꿈(계수 없음) = 저장 막음(728-2)
out = dsk.settle(out, whole, job, raw)
except sd.DocError as e:
+4 -8
View File
@@ -90,16 +90,12 @@ def clean_more(raw: Any, out: dict) -> dict:
return imp.clean(raw, out) # 가져온 식(793-2)
def stamp(row: dict, doc: dict | None = None) -> dict[str, Any]:
"""저장 때 서버 칸 — 바탕판(바탕 줄 지문 · 화면 「기초가 바뀜」) · 가져온 식 검산 ·
옛 `M01판`(자리마다 지문 — 읽던 시트 걷음)은 안 적음(855 2-D)."""
from M02_MasterTemplete import M02_Sangeun_Calc as calc
if doc is not None and imp.is_imported(doc): # 가져온 식 검산(793-2) = 서버가 다시
def stamp(doc: dict) -> None:
"""저장 때 서버 칸 — 가져온 식 검산(793-2 · 서버가 다시) · 옛 `바탕판`(바탕 줄 지문 · 읽는 곳 0 ·
855 L2 ⓑ-3) · 옛 `M01판`(855 2-D)은 안 적음."""
if imp.is_imported(doc):
doc[imp.KEY]["검산"] = imp.check(doc)
return {"바탕판": calc.fingerprint(row)}
# ── 고치기 ──────────────────────────────────────
def restore(doc: dict) -> dict:
+24 -4
View File
@@ -268,19 +268,39 @@ def _added_names(whole: Any, adds: Any) -> set[str]:
for one in adds or []:
if isinstance(one, dict) and one.get("종류") == "로직":
try:
out |= {
str(s.get("이름")) for s in whole.logic(str(one.get("로직"))).get("입력") or []
}
out |= {str(s.get("이름")) for s in doc_row(whole, str(one.get("로직")))["입력"]}
except Exception: # noqa: BLE001
continue
return out
def doc_row(whole: Any, code: str) -> dict:
"""기초 머리(855 L2 ⓑ-3 · 로직 줄 안 읽음) — M01 수식 문서의 이름 · 결과단위 · 원문번호 · 입력 이름
(입력 · 선택 변수 열쇠) · M01 문서 없는 키(굳힌 사본 줄 등) = 색인 줄 그대로(없으면 엔진 틀림)."""
from M02_MasterTemplete import M02_Doc_Copy as dc # 늦게 — dc 가 이 파일을 부름
doc = dc.folder().get(str(code))
if doc is None:
return whole.logic(code)
names = [
v["열쇠"]
for v in doc.get("변수") or []
if (v.get("연결") or {}).get("갈래") in ("입력", "선택") and v.get("열쇠")
]
return {
"키": str(code),
"이름": doc.get("이름"),
"결과단위": doc.get("결과단위"),
"원문번호": dc.md.tags_of(doc).get("원문번호"),
"입력": [{"이름": n} for n in names],
}
def _logic(whole: Any, code: str, where: str) -> dict | None:
if whole is None:
return None
try:
return whole.logic(code)
return doc_row(whole, code)
except Exception as e: # noqa: BLE001 — 엔진 FormulaError(가져오기 둘레 피함)
raise DocError(f"{where} · {e}") from e
+10 -1
View File
@@ -30,7 +30,16 @@ LAYERS = ("system", "company", "personal", "project")
# labor = 일위대가(구조물 열마다 · `M02_Labor_Doc`)
# precombo = 사전조합(SC-) — 일위대가 사전조합 서고(`M02_Labor_Ref` · 옛 단가승격 promote 는 134-2 에서 뺌)
# sangeun = 단가산출(SK- · 715-2 · 꼴 `M02_Sangeun_Doc`)
LIBRARY_KINDS = ("precombo", "sangeun")
#: 서고 종류 표(858 5-6 · 설계 2-2) — 자리 = 층 안 폴더 · 파일 / 머리 = 키 머리 / 이름 = 화면 이름 /
#: 번호 = 층 `_번호.json` 칸(지운 끝 번호 안 다시 씀 · 없음 = 전 층 최대 + 파일 `마지막`) / 나무 = `{종류}_폴더.json` ·
#: 내 기계 · 내 재료 = 개인 층만
SHELF: dict[str, dict[str, Any]] = {
"precombo": {"자리": "precombo", "머리": "SC", "이름": "사전조합", "번호": "precombo", "나무": True},
"sangeun": {"자리": "sangeun", "머리": "SK", "이름": "단가산출", "번호": "sangeun", "나무": True},
"my-machine": {"자리": "내기계", "머리": "EQP", "이름": "내 기계", "번호": "내기계", "나무": False},
"my-material": {"자리": "개인자재.json", "머리": "PM", "이름": "내 재료", "번호": None, "나무": False},
} # fmt: skip
LIBRARY_KINDS = tuple(k for k, v in SHELF.items() if v["나무"]) # ("precombo", "sangeun")
KINDS = ("table", "drawing", "structure", "labor", "area", *LIBRARY_KINDS)
TEMPLATES_DIRNAME = "templates"
INITIAL_DIRNAME = "_initial"
@@ -20,7 +20,7 @@
"sangeun.복사": "40edbd4d0644186f",
"sangeun.붙여넣기": "57cfb7bb522a80d3",
"sangeun.쓰는곳": "2c9ec1824709481f",
"sangeun.읽기": "19662ccd4c5ae0c0",
"sangeun.읽기": "670646670a5685b4",
"sangeun.중복": "2c9378c6e9c61251",
"sangeun.지우기": "db8b1e8ad9bef9eb",
"sangeun.합치기": "b8f7720e8a1e1bbb",
@@ -31,9 +31,9 @@
"공유.요청": "762ba10d5af57643",
"권한.같은회사남": "2d3d50a90583497d",
"권한.남의회사관리": "a1213c908c70528f",
"권한.시스템": "504e7d86285faeb9",
"권한.일반": "10c970d97dc81571",
"권한.회사관리": "d1435cf9f015fbc7",
"권한.시스템": "62482b9feacef35d",
"권한.일반": "1c5a65215f7e254e",
"권한.회사관리": "c08e29bffd8dd114",
"내기계.고치기": "3f00365dbfb77cee",
"내기계.만들기": "20f5562f02c276f8",
"내기계.목록": "064102da4c9740d6",
@@ -43,7 +43,7 @@
"내기계.찾기": "feca2de012a206ee",
"내재료.고치기": "60c0d3337d7dde06",
"내재료.만들기": "9fec4ce2a9bbfb82",
"내재료.목록": "9c5929426719e9ae",
"내재료.목록": "c653f76fd62ed174",
"내재료.지우기": "9c194d1b5367920e",
"항목.나무": "abb5815352e81102",
"항목.목록": "f7ff1a6372bf308f",
@@ -2,7 +2,6 @@
① 폴더 → 옛 한 파일 꼴(머리 · 줄 · 키 차례) · 옮기는 빌더 왕복 같음 · 두 번 써도 안 바뀜
② 한 대 고침 = 파일 하나만 · 새 기계 = 파일 하나 더함(끝) · 지움 = 파일 하나 지움 · 판 충돌 409
③ 내 기계 — 옛 `내기계.json` 은 읽을 때 폴더로 한 번 옮김(내용 · 다음 번호 같음 · 옛 파일 지움)
④ 저장 검사 좁히기 — 옛 길(폴더 두 번 읽고 전체 검사 두 번)과 같은 오류 목록(견본 고침 스물)
기본 = 갈래(기계 · 자재 · 인력 · 유가 · 표 · 로직 · 조합)마다 하나 이상 아홉(`SAMPLE`) · 전수 = `AISLO_TEST_ALL=1`
"""
@@ -19,7 +18,6 @@ import pytest
from M01_MasterData import M01_MasterData_Store as store
from M01_MasterData import M01_MasterData_Store_Cache as cache
from M02_MasterTemplete import M02_MyMachine as mym
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "resources" / "master_data" / "scripts"))
@@ -115,22 +113,6 @@ def test_one_machine_one_file(master: Path) -> None:
assert e.value.status == 409 and e.value.detail == {"stale": [M]}
# ③ 내 기계 옮김 ───────────────────────────────────────────────────────
def test_my_machine_moves_once(tmp_path: Path) -> None:
rows = [{"키": f"EQP42-{n:04d}", "이름": f"sub1임시{n}", "값": {"가격": n}} for n in (1, 2, 10)]
old = {"줄": rows, "다음": 11}
(tmp_path / mym.FILE).write_text(json.dumps(old, ensure_ascii=False), encoding="utf-8")
got = mym._read(tmp_path)
assert got == old and not (tmp_path / mym.FILE).exists() # 내용 · 차례 같음 · 옛 파일 지움
assert sorted(p.name for p in (tmp_path / mym.DIR).iterdir()) == [
"EQP42-0001.json", "EQP42-0002.json", "EQP42-0010.json", mym.NEXT,
] # fmt: skip
assert mym._read(tmp_path) == old and mym.rows(tmp_path) == rows
assert mym._read(tmp_path / "없음") == {"줄": [], "다음": 1}
(tmp_path / mym.FILE).write_text(json.dumps({"줄": [], "다음": 5}), encoding="utf-8")
assert mym._read(tmp_path)["다음"] == 11 # 옛 코드가 다시 쓴 옛 파일 — 번호 뒤로 안 감
# ④ 저장 검사 좁히기 = 옛 길과 같은 오류 ─────────────────────────────────
def _old_check(files: dict, changed: list[str], book: dict, narrowed) -> list[str]:
"""826-2 전 `Store_Cache.check_saved` 그대로 — 폴더 전부 색인 · 틀 · 조합 · 모든 층 문서."""
+11 -4
View File
@@ -2,7 +2,8 @@
"""854-1 안전 고침 — 내 기계 저장 잠금 · 판 대조 · 번호 겹침 없음(임시 storage · M01 정본 안 고침).
① 스레드 여럿이 동시에 만들기 → 번호 겹침 0 · 파일 수 = 요청 수 ② 옛 판으로 고치기 = 409 · 새 판 = 됨
③ `_다음` 이 뒤처져도 있는 파일 번호를 덮지 않음.
③ 번호 장부(층 `_번호.json` 「내기계」 칸 · 858 5-6)가 뒤처져도 있는 파일 번호를 덮지 않음 ·
⑤ 끝 번호를 지운 뒤 새로 만들면 새 번호(SK · PM · 내 기계).
"""
from __future__ import annotations
@@ -15,6 +16,7 @@ import pytest
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_MyMachine as mym
from M02_MasterTemplete.M02_Labor_Ref import ISSUED
from resources.tester.test_m02_labor_ref import world # noqa: F401 — 같은 임시 층
N = 8
@@ -48,7 +50,7 @@ def test_parallel_create_no_clash(world, monkeypatch):
assert len(files) == N
names = {json.loads(p.read_bytes())["이름"] for p in files}
assert names == {f"sub4임시{i}" for i in range(N)}
assert json.loads((me / mym.DIR / mym.NEXT).read_bytes())["다음"] == N + 1
assert json.loads((me / ISSUED).read_bytes())[mym.NUMBER] == N # 층 번호 장부(858 5-6)
def test_stale_version_409(world):
@@ -68,10 +70,10 @@ def test_stale_version_409(world):
def test_counter_behind_skips_file(world):
"""③ `_다음` 이 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
"""③ 번호 장부가 옛 번호를 가리켜도 있는 파일은 안 덮음 — 다음 빈 번호."""
me = world["personal"]
first = _at(me, mym.create, _easy("sub4임시처음"))["줄"]["키"]
(me / mym.DIR / mym.NEXT).write_text('{"다음": 1}', encoding="utf-8")
(me / ISSUED).write_text(json.dumps({mym.NUMBER: 0}), encoding="utf-8")
second = _at(me, mym.create, _easy("sub4임시둘째"))["줄"]["키"]
assert second != first
assert _at(me, mym.one, first)["줄"]["이름"] == "sub4임시처음"
@@ -117,3 +119,8 @@ def test_deleted_last_key_not_reused(world):
assert keys == ["PM000001", "PM000002"]
own.remove(me, keys[-1])
assert own.add(me, {**bolt, "규격": "M24"})["키"] == "PM000003"
machines = [_at(me, mym.create, _easy(f"sub4임시기계{i}"))["줄"]["키"] for i in range(2)]
_at(me, mym.delete, machines[-1])
again = _at(me, mym.create, _easy("sub4임시기계3"))["줄"]["키"]
assert again not in machines and again.endswith("-0003") # 내 기계도(858 5-6)
+18 -16
View File
@@ -4,6 +4,7 @@
- 품번 = 모든 사람 통틀어 한 줄 번호(두 사람 · 두 회사 안 겹침) · 화면이 보낸 키는 안 받음
- 품명 · 단위 빈 = 400 · 단가 = 0 이상 수 또는 빈 값 · 같은 품명 + 규격 + 단위 = 409
- 개인 층만(회사 = 빈 목록 · 추가 400) · 남의 개인 층 = 403
- 고치기 판(858 5-6) — 목록 판으로 고침 = 됨 · 옛 판 = 409 {stale, 판, 까닭} · 막힌 고침은 안 적힘
층은 임시 폴더(마스터 · storage).
"""
@@ -18,9 +19,9 @@ from fastapi.testclient import TestClient
from common_util.common_util_auth import verify_session
from config import config_system
from M02_MasterTemplete import M02_Labor_Router as labor_router
from M02_MasterTemplete import M02_MasterTemplete_Store as store
from M02_MasterTemplete import M02_Material_Own as own
from M02_MasterTemplete import M02_MyMachine_Router as machine_router
from M02_MasterTemplete import M02_Template_Layers as layers
from resources.tester.test_m02_structure import write_sample_table
@@ -39,7 +40,7 @@ def world(tmp_path, monkeypatch) -> dict[str, Any]:
monkeypatch.setattr(config_system, "STORAGE_BASE_DIR", str(tmp_path / "storage"))
session: dict[str, Any] = {"user_id": 42, "company_id": 7, "role": "USER", "is_master": False}
app = FastAPI()
app.include_router(labor_router.router)
app.include_router(machine_router.router) # 내 재료 길 = 내 기계 묶음(858 5-6)
app.dependency_overrides[verify_session] = lambda: session
return {"client": TestClient(app), "session": session}
@@ -100,6 +101,21 @@ def test_회사_층은_빈_목록_추가_400_남의_개인_403(world):
assert other.post(URL.format("personal") + "?owner=7/42", json=BOLT).status_code == 403
def test_옛_판으로_고치면_409_고침_안_적힘(world):
c = _as(world, 42)
key = c.post(URL.format("personal"), json=BOLT).json()["키"]
old = c.get(URL.format("personal")).json()["판"]
one = c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 1500, "판": old})
assert one.status_code == 200, one.text
new = c.get(URL.format("personal")).json()["판"]
assert new and new != old
two = c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 9999, "판": old})
assert two.status_code == 409
assert two.json()["detail"]["stale"] == [key] and two.json()["detail"]["판"] == new
assert c.get(URL.format("personal")).json()["줄"][0]["값"] == 1500
assert c.put(f"{URL.format('personal')}/{key}", json={**BOLT, "값": 7}).status_code == 200
# ── 148-3 — 저장 검사 · 셈 · 사본 · 층 사이 · 개인에 저장 ──────────────
@@ -215,17 +231,3 @@ def test_개인에_저장은_사본_개인_줄을_내_목록에_같은_키(world
doc = store.read("labor", made["열"])["문서"]
assert doc["자재"][0]["코드"] == key
assert own.rows(b) == own.rows(a)
def test_화면_신규_자재는_머리_단추_개인_층만():
"""148-3 — [신규 자재] = 공용 모달 `actions`(개인 층만) · 품번은 안 보냄 · 상세는 개인 층에만 넘김."""
import os
here = os.path.join(os.path.dirname(__file__), "..", "..", "M02_MasterTemplete")
pick = open(os.path.join(here, "M02_Material_Pick.ts"), encoding="utf-8").read()
assert "...(own ? { actions: [newButton] } : {})" in pick
assert (
"`/layers/personal/materials" in pick and "키:" not in pick.split("JSON.stringify")[1][:200]
)
detail = open(os.path.join(here, "M02_MasterTemplete_Labor_Detail.ts"), encoding="utf-8").read()
assert "addMaterialButton" not in detail # 736-1 [자재 추가] 단추 걷음 — 재료는 찾아 넣기 창