refactor(M02): 일위대가 조합 나무 서버 길 지움 — /tree · /tree-many · /paste(39-2)
- Combo_Store 나무 고침 함수(_apply · edit_tree(_many) · commit · _write_master_folders · _set_path) 지움 · 목록 폴더는 읽기만 - Combo_Copy.py(층 사이 붙여넣기) 지움 · Labor_Api 나무 · 붙여넣기 함수 지움 - 옛 나무 · 붙여넣기 시험을 「길 없음」 검사로 갈음 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01BVPp2o6Mh2FZJr72yW3ofZ
This commit is contained in:
Claude Opus 5.5
@@ -1,98 +0,0 @@
|
||||
"""일위대가 조합 층 사이 복사(PLAN 30-3) — 읽을 수 있는 층의 조합 · 폴더를 쓸 수 있는 층에 붙여넣기.
|
||||
|
||||
정함(30장): 복사본 = 대상 층의 새 키(마스터 UA · 회사 UC · 개인 UP) · 본뜬키 = 원본 키 ·
|
||||
같은 이름이면 「이름 (2)」 · 담은 로직 그대로 · 폴더 복사는 안의 조합 · 빈 폴더까지.
|
||||
붙는 자리 = `경로`(대상 폴더 · 깊이 2 안) — 고른 조합은 그 폴더에 · 고른 폴더는 그 아래 한 단으로.
|
||||
마스터에 붙이면 M01 저장 길(대장 UA) · 본뜬키는 UA 만(마스터 틀) — 다른 층 원본이면 비움.
|
||||
권한은 라우터 몫(원본 층 읽기 · 대상 층 쓰기) · 대상 층 = `store.at(대상)`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any
|
||||
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Combo_Store as combos
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Store as store
|
||||
|
||||
|
||||
def _free_name(name: str, taken: set[str]) -> str:
|
||||
out, n = name, 2
|
||||
while out in taken:
|
||||
out, n = f"{name} ({n})", n + 1
|
||||
taken.add(out)
|
||||
return out
|
||||
|
||||
|
||||
def _paths(value: Any, what: str) -> list[list[str]]:
|
||||
if not isinstance(value, list) or not all(isinstance(p, list) for p in value):
|
||||
raise store.StoreError(422, f"「{what}」 이 폴더 경로 목록이 아님")
|
||||
return [[str(x) for x in p] for p in value]
|
||||
|
||||
|
||||
def picked(source: dict, keys: list[str], folders: list[list[str]], where: list[str]):
|
||||
"""(붙일 조합 [(원본 줄, 새 경로)], 새 빈 폴더) — 깊이 2 넘으면 422 · 없는 키 · 폴더 404."""
|
||||
have = combos.folders_of(source)
|
||||
rows = {str(r.get("키")): r for r in source.get("줄") or []}
|
||||
out: dict[str, tuple[dict, list[str]]] = {}
|
||||
made: list[list[str]] = []
|
||||
for folder in folders:
|
||||
if folder not in have:
|
||||
raise store.StoreError(404, f"없는 폴더 「{' › '.join(folder)}」")
|
||||
cut = len(folder) - 1 # 고른 폴더부터 대상 아래로
|
||||
made += [where + f[cut:] for f in have if f[: len(folder)] == folder]
|
||||
for key, row in rows.items():
|
||||
path = combos.path_of(row)
|
||||
if path[: len(folder)] == folder:
|
||||
out[key] = (row, where + path[cut:])
|
||||
for key in keys:
|
||||
if key not in rows:
|
||||
raise store.StoreError(404, f"없는 조합 「{key}」")
|
||||
out.setdefault(key, (rows[key], list(where)))
|
||||
if any(len(p) > combos.DEPTH for p in [*made, *(p for _, p in out.values())]):
|
||||
raise store.StoreError(422, f"폴더는 {combos.DEPTH} 단까지 — 더 얕은 폴더에 붙여 넣음")
|
||||
return list(out.values()), made
|
||||
|
||||
|
||||
def paste(source: dict, body: dict) -> dict[str, Any]:
|
||||
"""`source` = 원본 층 표(부르는 쪽이 원본 층에서 읽음) · `body` = `{키?, 폴더?, 경로?, 판}` →
|
||||
`{…대상 층 목록, 새키: [원본 → 새 키]}`."""
|
||||
keys = [str(k) for k in body.get("키") or []]
|
||||
folders = _paths(body.get("폴더") or [], "폴더")
|
||||
where = [str(x) for x in body.get("경로") or []]
|
||||
if not keys and not folders:
|
||||
raise store.StoreError(422, "붙여 넣을 조합 · 폴더가 없음")
|
||||
doc, have = combos._load()
|
||||
if have != (body.get("판") or ""):
|
||||
raise store.StoreError(409, {"stale": [combos.FILE], "판": have})
|
||||
if where and where not in combos.folders_of(doc):
|
||||
raise store.StoreError(404, f"없는 폴더 「{' › '.join(where)}」")
|
||||
items, made = picked(source, keys, folders, where)
|
||||
taken = {str(r.get("이름") or "").strip() for r in doc["줄"]}
|
||||
master = combos.heads()[-1] == combos.MASTER
|
||||
rows = []
|
||||
for row, path in items:
|
||||
one = {k: row.get(k) for k in combos.mcb.COLS if k != "키"}
|
||||
one["이름"] = _free_name(str(row.get("이름") or "").strip(), taken)
|
||||
one["본뜬키"] = str(row.get("키"))
|
||||
if master and not one["본뜬키"].startswith(combos.MASTER):
|
||||
one["본뜬키"] = None # 마스터 틀은 UA 계보만
|
||||
combos._set_path(one, path)
|
||||
rows.append(one)
|
||||
folders_after = combos.folders_of({**doc, "폴더": [*combos.folders_of(doc), *made]})
|
||||
if master:
|
||||
new = [combos.create(one)["키"] for one in rows] # M01 저장 길(검사 · 대장) — 하나씩
|
||||
_, version = combos._load()
|
||||
combos._write_master_folders(folders_after, version)
|
||||
else:
|
||||
number = int(doc.get("다음") or 1)
|
||||
fixed = []
|
||||
for at, one in enumerate(rows):
|
||||
fixed.append(combos._clean(one, f"{combos.heads()[-1]}{number + at:06d}"))
|
||||
new_doc = {**doc, "다음": number + len(fixed), "폴더": folders_after}
|
||||
new_doc["줄"] = [*doc["줄"], *fixed]
|
||||
for one in fixed:
|
||||
combos._check(new_doc, one)
|
||||
combos._save(new_doc, have)
|
||||
new = [one["키"] for one in fixed]
|
||||
pairs = [{"원본": str(row.get("키")), "새키": key} for (row, _), key in zip(items, new)]
|
||||
return {**combos.listing(), "새키": pairs}
|
||||
@@ -7,13 +7,12 @@
|
||||
개인 `storage/{회사}/{사용자}/templates/일위대가조합.json` · 키 `UP{사용자}-######`
|
||||
회사 · 개인 파일 = 마스터와 같은 머리 · 열 한 벌 + 머리 `다음`(키 장부 · 지운 키는 다시 안 씀).
|
||||
지금 층 = `store.at(층 폴더)`(`store.root()`) — 키 머리도 그 자리에서 셈 · 권한은 라우터 몫.
|
||||
나무 = 폴더 [구분] · [구분, 상세구분] 깊이 2 · 머리 `폴더` = 폴더 전부(빈 폴더 포함).
|
||||
목록 `폴더` = [구분] · [구분, 상세구분](읽기만 · 나무 고침 · 붙여넣기 길은 39-2 에서 지움).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
@@ -127,18 +126,13 @@ def _find(doc: dict, key: str) -> dict[str, Any]:
|
||||
return row
|
||||
|
||||
|
||||
# ── 나무 폴더 ─────────────────────────────────────────────────────────
|
||||
# ── 폴더(읽기만) ───────────────────────────────────────────────────────
|
||||
def path_of(row: dict) -> list[str]:
|
||||
"""조합의 폴더 — [구분] · [구분, 상세구분] · 구분이 없으면 뿌리."""
|
||||
a, b = (str(row.get(k) or "").strip() for k in ("구분", "상세구분"))
|
||||
return [a, b] if a and b else [a] if a else []
|
||||
|
||||
|
||||
def _set_path(row: dict, path: list[str]) -> None:
|
||||
row["구분"] = path[0] if path else None
|
||||
row["상세구분"] = path[1] if len(path) > 1 else None
|
||||
|
||||
|
||||
def folders_of(doc: dict) -> list[list[str]]:
|
||||
"""폴더 전부 — 적어 둔 것 + 조합 자리 · 부모까지."""
|
||||
out: list[list[str]] = []
|
||||
@@ -312,128 +306,3 @@ def delete(key: str, version: str) -> dict[str, Any]:
|
||||
_find(doc, key)
|
||||
_refuse_used([key])
|
||||
return {"판": _save({**doc, "줄": [r for r in doc["줄"] if r.get("키") != key]}, version)}
|
||||
|
||||
|
||||
# ── 나무 고침 ─────────────────────────────────────────────────────────
|
||||
def _moved(path: list[str], old: list[str], new: list[str]) -> list[str]:
|
||||
return new + path[len(old) :] if path[: len(old)] == old else path
|
||||
|
||||
|
||||
def _folder(folders: list[list[str]], path: list[str] | None, what: str) -> list[str]:
|
||||
path = [str(x) for x in path or []]
|
||||
if not path or path not in folders:
|
||||
raise store.StoreError(404, f"{what} 폴더 「{' › '.join(path)}」 없음")
|
||||
return path
|
||||
|
||||
|
||||
def _fresh(name: Any) -> str:
|
||||
text = str(name or "").strip()
|
||||
if not text or "›" in text or len(text) > mcb.MAX_이름:
|
||||
raise store.StoreError(422, "폴더 이름 — 빈 이름 · 「›」 · 너무 긴 이름은 못 씀")
|
||||
return text
|
||||
|
||||
|
||||
def _apply(doc: dict, body: dict) -> tuple[dict, list[str]]:
|
||||
"""나무 고침 한 번 → (새 표, 지운 조합 키) · 조합 더하기 · 담은 로직은 `create` · `edit` 몫."""
|
||||
op, key = body.get("op"), body.get("키")
|
||||
folders, rows = folders_of(doc), [dict(r) for r in doc.get("줄") or []]
|
||||
gone: list[str] = []
|
||||
target = [str(x) for x in body.get("새경로") or []]
|
||||
if op in ("move", "add-folder") and target and target not in folders:
|
||||
raise store.StoreError(404, f"없는 폴더 「{' › '.join(target)}」")
|
||||
if op == "add-folder":
|
||||
made = [*[str(x) for x in body.get("경로") or []], _fresh(body.get("이름"))]
|
||||
if len(made) > DEPTH or (made[:-1] and made[:-1] not in folders):
|
||||
raise store.StoreError(422, f"폴더는 {DEPTH} 단까지 · 있는 폴더 아래에만")
|
||||
if made in folders:
|
||||
raise store.StoreError(409, f"이미 있는 폴더 「{' › '.join(made)}」")
|
||||
folders.append(made)
|
||||
elif op == "rename" and key:
|
||||
_find({"줄": rows}, str(key))["이름"] = _fresh(body.get("이름"))
|
||||
elif op == "move" and key:
|
||||
_set_path(_find({"줄": rows}, str(key)), target)
|
||||
elif op == "delete" and key:
|
||||
_find({"줄": rows}, str(key))
|
||||
gone = [str(key)]
|
||||
elif op in ("rename", "move", "delete"):
|
||||
old = _folder(folders, body.get("경로"), "고칠")
|
||||
if op == "delete":
|
||||
gone = [str(r["키"]) for r in rows if path_of(r)[: len(old)] == old]
|
||||
folders = [f for f in folders if f[: len(old)] != old]
|
||||
else:
|
||||
new = [*old[:-1], _fresh(body.get("이름"))] if op == "rename" else [*target, old[-1]]
|
||||
deepest = max(len(f) for f in folders if f[: len(old)] == old)
|
||||
if new[: len(old)] == old or deepest - len(old) + len(new) > DEPTH:
|
||||
raise store.StoreError(422, f"폴더는 {DEPTH} 단까지 · 제 안으로 못 옮김")
|
||||
if new in folders:
|
||||
raise store.StoreError(409, f"이미 있는 폴더 「{' › '.join(new)}」")
|
||||
folders = [_moved(f, old, new) for f in folders]
|
||||
for r in rows:
|
||||
if path_of(r)[: len(old)] == old:
|
||||
_set_path(r, _moved(path_of(r), old, new))
|
||||
else:
|
||||
raise store.StoreError(
|
||||
422, f"모르는 나무 고침 「{op}」 — add-folder · rename · move · delete"
|
||||
)
|
||||
rows = [r for r in rows if str(r.get("키")) not in gone]
|
||||
return {**doc, "폴더": folders, "줄": rows}, gone
|
||||
|
||||
|
||||
def edit_tree(body: dict) -> dict[str, Any]:
|
||||
"""폴더 더하기 · 이름 바꾸기(폴더 · 조합) · 옮기기(폴더 · 조합) · 지우기(폴더 = 안 조합까지 ·
|
||||
조합) → 새 목록 · 쓰이는 조합이 들면 409 · 판 다르면 409 · 조합 이름 겹침 422."""
|
||||
return edit_tree_many({"판": body.get("판"), "ops": [body]})
|
||||
|
||||
|
||||
def edit_tree_many(body: dict) -> dict[str, Any]:
|
||||
"""나무 고침 여럿을 한 번에(PLAN 30-3 · 여러 개 옮기기 · 지우기) — `{판, ops: [고침 …]}` ·
|
||||
차례대로 적용 · 하나라도 막히면 아무것도 안 씀 · 저장 한 번."""
|
||||
doc, have = _load()
|
||||
if have != (body.get("판") or ""):
|
||||
raise store.StoreError(409, {"stale": [FILE], "판": have})
|
||||
ops = body.get("ops")
|
||||
if not isinstance(ops, list) or not ops:
|
||||
raise store.StoreError(422, "나무 고침 목록(ops)이 비었음")
|
||||
new, gone = doc, []
|
||||
for op in ops:
|
||||
new, got = _apply(new, op if isinstance(op, dict) else {})
|
||||
gone += got
|
||||
_refuse_used(gone)
|
||||
renamed = [str(op["키"]) for op in ops if op.get("op") == "rename" and op.get("키")]
|
||||
commit(doc, have, new, gone, renamed)
|
||||
return {**listing(), "지운조합": gone}
|
||||
|
||||
|
||||
def commit(doc: dict, have: str, new: dict, gone: list[str], checked: list[str] = ()) -> None:
|
||||
"""고친 표 한 벌 저장 — 회사 · 개인 = 파일 한 번(`checked` 조합은 이름 검사) ·
|
||||
마스터 = 줄은 M01 저장 길 · 머리 `폴더` 따로."""
|
||||
if heads()[-1] != MASTER:
|
||||
for key in checked:
|
||||
if key in {str(r.get("키")) for r in new["줄"]}:
|
||||
if errors := _name_errors(new, _find(new, key)):
|
||||
raise store.StoreError(422, {"errors": errors})
|
||||
_save(new, have)
|
||||
return
|
||||
was = {str(r["키"]): r for r in doc["줄"]}
|
||||
changes = [{"op": "delete", "key": k} for k in gone] + [
|
||||
{"op": "edit", "key": str(r["키"]), "row": r} for r in new["줄"] if was[str(r["키"])] != r
|
||||
]
|
||||
version = _m01(combo_store._write, changes, have)["version"] if changes else have
|
||||
_write_master_folders(new["폴더"], version)
|
||||
|
||||
|
||||
def _write_master_folders(folders: list[list[str]], version: str) -> None:
|
||||
"""마스터 조합 파일 머리 `폴더` — 줄은 안 건드림(줄 고침은 M01 저장 길)."""
|
||||
path = Path(m01.FOLDER) / FILE
|
||||
with m01._LOCK:
|
||||
doc, have = m01.read(FILE)
|
||||
if have != version:
|
||||
raise store.StoreError(409, {"stale": [FILE], "판": have})
|
||||
if doc.get("폴더") == folders:
|
||||
return
|
||||
head = {k: v for k, v in doc.items() if k != "줄"}
|
||||
text = m01.dump({**head, "폴더": folders, "줄": doc.get("줄") or []})
|
||||
temporary = path.with_name(f".{FILE}.tmp")
|
||||
temporary.write_text(text, encoding="utf-8", newline="\n")
|
||||
os.replace(temporary, path)
|
||||
m01.cache.stale([FILE])
|
||||
|
||||
@@ -95,15 +95,6 @@ export interface ComboLayerList extends ComboList {
|
||||
layer: LaborScope["layer"];
|
||||
owner: string | null;
|
||||
}
|
||||
export interface ComboTreeEdit {
|
||||
op: "add-folder" | "rename" | "move" | "delete";
|
||||
경로?: string[];
|
||||
이름?: string;
|
||||
새경로?: string[];
|
||||
키?: string;
|
||||
판: string;
|
||||
}
|
||||
|
||||
async function request<T>(url: string, method = "GET", body?: unknown): Promise<T> {
|
||||
const response = await fetch(`${API_BASE_URL}/m02${url}`, {
|
||||
method,
|
||||
@@ -197,36 +188,6 @@ export const deleteCombo = (
|
||||
scope: LaborScope = SYSTEM_SCOPE,
|
||||
): Promise<unknown> => request(at(scope, `/${enc(key)}`, { 판: version }), "DELETE");
|
||||
|
||||
/** 나무 고침 — 폴더 더하기 · 이름 · 옮기기(폴더 · 조합) · 지우기 → 새 목록 */
|
||||
export const editComboTree = (
|
||||
body: ComboTreeEdit,
|
||||
scope: LaborScope = SYSTEM_SCOPE,
|
||||
): Promise<ComboList & { 지운조합: string[] }> => request(at(scope, "/tree"), "POST", body);
|
||||
|
||||
/** 여러 개 옮기기 · 지우기(PLAN 30-3) — 나무 고침 여럿을 차례대로 · 저장 한 번 */
|
||||
export const editComboTreeMany = (
|
||||
ops: Omit<ComboTreeEdit, "판">[],
|
||||
판: string,
|
||||
scope: LaborScope = SYSTEM_SCOPE,
|
||||
): Promise<ComboList & { 지운조합: string[] }> =>
|
||||
request(at(scope, "/tree-many"), "POST", { 판, ops });
|
||||
|
||||
/** 층 사이 복사(PLAN 30-3) — `from` 층의 조합 · 폴더를 이 층 `경로` 폴더에 새 키로 */
|
||||
export const pasteCombos = (
|
||||
from: LaborScope,
|
||||
pick: { 키?: string[]; 폴더?: string[][] },
|
||||
경로: string[],
|
||||
판: string,
|
||||
scope: LaborScope = SYSTEM_SCOPE,
|
||||
): Promise<ComboList & { 새키: { 원본: string; 새키: string }[] }> =>
|
||||
request(at(scope, "/paste"), "POST", {
|
||||
from_layer: from.layer,
|
||||
from_owner: from.owner,
|
||||
...pick,
|
||||
경로,
|
||||
판,
|
||||
});
|
||||
|
||||
/** 보기만 — 수량(inputs)은 이 부름에만 실림 · 저장 안 함 */
|
||||
export const previewCombo = (
|
||||
combo: Combo | string,
|
||||
|
||||
@@ -19,7 +19,6 @@ from pydantic import BaseModel
|
||||
from common_util.common_util_auth import verify_session
|
||||
from M01_MasterData import M01_MasterData_Store as m01
|
||||
from M02_MasterTemplete import M02_Layer_Access as access
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Combo_Copy as combo_copy
|
||||
from M02_MasterTemplete import M02_MasterTemplete_Combo_Store as combos
|
||||
from M02_MasterTemplete.M02_MasterTemplete_Router_Items import Layer, Session, _call, _root
|
||||
|
||||
@@ -31,36 +30,6 @@ class ComboBody(BaseModel):
|
||||
판: str | None = None # 새로 만들 때 빈 글 = 지금 판 · 고칠 때 어긋나면 409
|
||||
|
||||
|
||||
class ComboTreeBody(BaseModel):
|
||||
"""`{op: add-folder|rename|move|delete, 경로?, 이름?, 새경로?, 키?, 판}` — 폴더 깊이 2."""
|
||||
|
||||
op: str
|
||||
경로: list[str] | None = None
|
||||
이름: str | None = None
|
||||
새경로: list[str] | None = None
|
||||
키: str | None = None
|
||||
판: str
|
||||
|
||||
|
||||
class TreeManyBody(BaseModel):
|
||||
"""여러 개 옮기기 · 지우기(PLAN 30-3) — `ops` = 나무 고침(`ComboTreeBody` 모양) · 저장 한 번."""
|
||||
|
||||
판: str
|
||||
ops: list[dict[str, Any]]
|
||||
|
||||
|
||||
class PasteBody(BaseModel):
|
||||
"""층 사이 복사(PLAN 30-3) — 원본 층(`from_layer` · `from_owner`)의 조합 `키` · 폴더 `폴더` →
|
||||
이 층 `경로` 폴더에 새 키로. `판` = 이 층 조합 표 판."""
|
||||
|
||||
from_layer: Layer
|
||||
from_owner: str | None = None
|
||||
키: list[str] = []
|
||||
폴더: list[list[str]] = []
|
||||
경로: list[str] = []
|
||||
판: str = ""
|
||||
|
||||
|
||||
class PreviewBody(BaseModel):
|
||||
"""저장 전 미리 보기 — `combo` 는 조합 줄 통째 또는 그 층 키 · `inputs` 는 로직마다."""
|
||||
|
||||
@@ -166,41 +135,6 @@ def delete_practice(판: str = "", session: Session = Depends(verify_session)) -
|
||||
return _call(_root(session, "system", None, write=True), combos.drop_practice, 판)
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/combos/tree")
|
||||
def post_tree(
|
||||
layer: Layer,
|
||||
body: ComboTreeBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
folder = _root(session, layer, owner, write=True)
|
||||
return _call(folder, combos.edit_tree, body.model_dump())
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/combos/tree-many")
|
||||
def post_tree_many(
|
||||
layer: Layer,
|
||||
body: TreeManyBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
folder = _root(session, layer, owner, write=True)
|
||||
return _call(folder, combos.edit_tree_many, body.model_dump())
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/combos/paste")
|
||||
def post_paste(
|
||||
layer: Layer,
|
||||
body: PasteBody,
|
||||
owner: str | None = None,
|
||||
session: Session = Depends(verify_session),
|
||||
):
|
||||
"""원본 층 읽기 권한 · 이 층 쓰기 권한(M02_Layer_Access) — 마스터 붙이기 = 시스템 관리자."""
|
||||
source = _call(_root(session, body.from_layer, body.from_owner), lambda: combos._load()[0])
|
||||
folder = _root(session, layer, owner, write=True)
|
||||
return _call(folder, combo_copy.paste, source, body.model_dump())
|
||||
|
||||
|
||||
@router.post("/layers/{layer}/combos/preview")
|
||||
def post_preview(
|
||||
layer: Layer,
|
||||
|
||||
Reference in New Issue
Block a user