From c0a76b844de1d4b832f56479e6a5a7dc1631d9b4 Mon Sep 17 00:00:00 2001 From: umsangdon Date: Wed, 30 Sep 2026 18:53:57 +0900 Subject: [PATCH] =?UTF-8?q?feat(M02):=20=EC=9D=BC=EC=9C=84=EB=8C=80?= =?UTF-8?q?=EA=B0=80=20=EC=A1=B0=ED=95=A9=20=EC=B8=B5=20=EC=82=AC=EC=9D=B4?= =?UTF-8?q?=20=EB=B3=B5=EC=82=AC=20=C2=B7=20=EC=97=AC=EB=9F=AC=20=EA=B0=9C?= =?UTF-8?q?=20=EC=98=AE=EA=B8=B0=EA=B8=B0=20=C2=B7=20=EC=A7=80=EC=9A=B0?= =?UTF-8?q?=EA=B8=B0=20=EC=84=9C=EB=B2=84(PLAN=2030-3)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - POST /api/m02/layers/{layer}/combos/paste — 원본 층(읽기) 조합 · 폴더 → 이 층(쓰기) 경로 폴더에 새 키(UA · UC · UP) · 본뜬키 = 원본(마스터는 UA 만) · 같은 이름 「이름 (2)」 · 폴더는 안 조합 · 빈 폴더까지 · 깊이 2 넘으면 422 - POST /api/m02/layers/{layer}/combos/tree-many — 나무 고침 여럿 차례대로 · 저장 한 번 · 하나라도 막히면 안 씀 - 새 M02_MasterTemplete_Combo_Copy · Combo_Store edit_tree 를 edit_tree_many · commit 한 길로 - Labor_Api 에 pasteCombos · editComboTreeMany - 시험 test_m02_combo_layers 네 건 더함 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01BU9gbNE3aWFUvE61pS2WGt --- .../M02_MasterTemplete_Combo_Copy.py | 98 +++++++++++++++++++ .../M02_MasterTemplete_Combo_Store.py | 33 +++++-- .../M02_MasterTemplete_Labor_Api.ts | 24 +++++ .../M02_MasterTemplete_Router_Combos.py | 44 +++++++++ resources/tester/test_m02_combo_layers.py | 80 +++++++++++++++ 5 files changed, 272 insertions(+), 7 deletions(-) create mode 100644 M02_MasterTemplete/M02_MasterTemplete_Combo_Copy.py diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo_Copy.py b/M02_MasterTemplete/M02_MasterTemplete_Combo_Copy.py new file mode 100644 index 00000000..85b5d499 --- /dev/null +++ b/M02_MasterTemplete/M02_MasterTemplete_Combo_Copy.py @@ -0,0 +1,98 @@ +"""일위대가 조합 층 사이 복사(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} diff --git a/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py b/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py index 042c76e5..52a84654 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Combo_Store.py @@ -367,25 +367,44 @@ def _apply(doc: dict, body: dict) -> tuple[dict, list[str]]: 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}) - new, gone = _apply(doc, body) + 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: - if body.get("op") == "rename" and body.get("키"): - one = _find(new, str(body["키"])) - if errors := _name_errors(new, one): - raise store.StoreError(422, {"errors": errors}) + 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 {**listing(), "지운조합": gone} + 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) - return {**listing(), "지운조합": gone} def _write_master_folders(folders: list[list[str]], version: str) -> None: diff --git a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts index fd3cb672..4dfb87e8 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts +++ b/M02_MasterTemplete/M02_MasterTemplete_Labor_Api.ts @@ -203,6 +203,30 @@ export const editComboTree = ( scope: LaborScope = SYSTEM_SCOPE, ): Promise => request(at(scope, "/tree"), "POST", body); +/** 여러 개 옮기기 · 지우기(PLAN 30-3) — 나무 고침 여럿을 차례대로 · 저장 한 번 */ +export const editComboTreeMany = ( + ops: Omit[], + 판: string, + scope: LaborScope = SYSTEM_SCOPE, +): Promise => + 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 => + request(at(scope, "/paste"), "POST", { + from_layer: from.layer, + from_owner: from.owner, + ...pick, + 경로, + 판, + }); + /** 보기만 — 수량(inputs)은 이 부름에만 실림 · 저장 안 함 */ export const previewCombo = ( combo: Combo | string, diff --git a/M02_MasterTemplete/M02_MasterTemplete_Router_Combos.py b/M02_MasterTemplete/M02_MasterTemplete_Router_Combos.py index 05970da7..71232ea4 100644 --- a/M02_MasterTemplete/M02_MasterTemplete_Router_Combos.py +++ b/M02_MasterTemplete/M02_MasterTemplete_Router_Combos.py @@ -19,6 +19,7 @@ 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 @@ -41,6 +42,25 @@ class ComboTreeBody(BaseModel): 판: 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` 는 로직마다.""" @@ -148,6 +168,30 @@ def post_tree( 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, diff --git a/resources/tester/test_m02_combo_layers.py b/resources/tester/test_m02_combo_layers.py index d6fecefd..c8113cd7 100644 --- a/resources/tester/test_m02_combo_layers.py +++ b/resources/tester/test_m02_combo_layers.py @@ -309,3 +309,83 @@ def test_담을_로직_읽기는_로그인이면_됨(world): assert user.get("/api/m02/logic-lib/logic", params={"key": "GF999999"}).status_code == 404 assert user.get("/api/m02/logic-lib/subs").json()["subs"] assert user.get("/api/m02/logic-lib/auto", params={"key": A}).status_code == 200 + + +# ── 층 사이 복사 · 여러 개 옮기기(PLAN 30-3) ───────────────────────────── +def _paste(client: TestClient, layer: str, body: dict, want: int = 200, **params) -> dict: + body.setdefault("판", _list(client, layer, **params)["판"] if want != 403 else "") + res = client.post(URL.format(layer) + "/paste", json=body, params=params) + assert res.status_code == want, res.text + return res.json() + + +def test_마스터_조합_셋을_개인에_붙임_새_키_본뜬키_같은_이름은_2(world): + user = _as(world) + master = _list(user, "system")["줄"][:3] + keys = [r["키"] for r in master] + got = _paste(user, "personal", {"from_layer": "system", "키": keys}) + assert [p["새키"] for p in got["새키"]] == ["UP42-000001", "UP42-000002", "UP42-000003"] + rows = {r["키"]: r for r in got["줄"]} + for pair, src in zip(got["새키"], master): + one = rows[pair["새키"]] + assert (one["본뜬키"], one["이름"], one["count"]) == (src["키"], src["이름"], src["count"]) + assert (one["구분"], one["상세구분"]) == (None, None) # 붙인 자리 = 맨 위 + again = _paste(user, "personal", {"from_layer": "system", "키": keys[:1]}) + assert next(r for r in again["줄"] if r["키"] == "UP42-000004")["이름"].endswith(" (2)") + _paste(user, "company", {"from_layer": "system", "키": keys}, 403) # 회사 쓰기 권한 없음 + _paste(user, "personal", {"from_layer": "personal", "from_owner": "8/9", "키": keys}, 403) + _paste(user, "personal", {"from_layer": "system", "키": ["UA999999"]}, 404) + stale = {"from_layer": "system", "키": keys, "판": "낡은판"} + assert user.post(URL.format("personal") + "/paste", json=stale).status_code == 409 + + +def test_회사관리자_개인_폴더를_회사에_붙임_깊이_2_넘으면_422(world): + admin = _as(world, "ADMIN") + for name, where in (("가", ["석축"]), ("나", ["석축", "찰쌓기"])): + _new(admin, "personal", _combo(name, 구분=where[0], 상세구분=(where + [None])[1])) + _tree(admin, "personal", op="add-folder", 경로=["석축"], 이름="빈 곳") + body = {"from_layer": "personal", "폴더": [["석축"]]} + got = _paste(admin, "company", body) + assert [p["새키"] for p in got["새키"]] == ["UC7-000001", "UC7-000002"] + assert sorted(got["폴더"]) == [["석축"], ["석축", "빈 곳"], ["석축", "찰쌓기"]] + by = {r["이름"]: (r["구분"], r["상세구분"], r["본뜬키"]) for r in got["줄"]} + assert by["가"] == ("석축", None, "UP42-000001") and by["나"][:2] == ("석축", "찰쌓기") + _tree(admin, "company", op="add-folder", 경로=[], 이름="다른 곳") + deep = {"from_layer": "personal", "폴더": [["석축"]], "경로": ["다른 곳"]} + assert "2 단까지" in _paste(admin, "company", deep, 422)["detail"] + one = {"from_layer": "personal", "폴더": [["석축", "찰쌓기"]], "경로": ["다른 곳"]} + got = _paste(admin, "company", one) # 한 단 폴더는 들어감 + assert ["다른 곳", "찰쌓기"] in got["폴더"] + + +def test_여러_개_옮기기_지우기_한_번에(world): + me = _as(world) + keys = [_new(me, "personal", _combo(n))["키"] for n in ("가", "나", "다")] + _tree(me, "personal", op="add-folder", 경로=[], 이름="석축") + 판 = _list(me, "personal")["판"] + ops = [{"op": "move", "키": k, "새경로": ["석축"]} for k in keys[:2]] + res = me.post(URL.format("personal") + "/tree-many", json={"판": 판, "ops": ops}) + assert res.status_code == 200, res.text + assert [r["구분"] for r in res.json()["줄"]] == ["석축", "석축", None] + bad = {"판": res.json()["판"], "ops": [*ops[:1], {"op": "move", "키": "UP42-999999"}]} + assert me.post(URL.format("personal") + "/tree-many", json=bad).status_code == 404 + assert [r["구분"] for r in _list(me, "personal")["줄"]] == ["석축", "석축", None] # 안 씀 + 판 = _list(me, "personal")["판"] + ops = [{"op": "delete", "키": k} for k in keys[1:]] + got = me.post(URL.format("personal") + "/tree-many", json={"판": 판, "ops": ops}).json() + assert got["지운조합"] == keys[1:] and [r["키"] for r in got["줄"]] == keys[:1] + stale = {"판": "낡은판", "ops": ops} + assert me.post(URL.format("personal") + "/tree-many", json=stale).status_code == 409 + + +def test_시스템_관리자_개인_조합을_마스터에_붙임_본뜬키는_UA_만(world, master_copy): + admin = _as(world, "SYSTEM_ADMIN") + up = _new(admin, "personal", _combo("개인 것"))["키"] + before = len(_list(admin, "system")["줄"]) + got = _paste(admin, "system", {"from_layer": "personal", "키": [up]}) + new = got["새키"][0]["새키"] + assert new.startswith("UA") and len(got["줄"]) == before + 1 + row = next(r for r in got["줄"] if r["키"] == new) + assert row["본뜬키"] is None and row["이름"] == "개인 것" + doc = json.loads((master_copy / combos.FILE).read_text(encoding="utf-8")) + assert m01.cm.check_form(combos.FILE, doc) == []