"""자산·보고서·이력을 함께 저장합니다. DB 생성은 사용자가 서버에서 SQL로 진행합니다.""" from __future__ import annotations import uuid from datetime import date, datetime from decimal import Decimal from psycopg.rows import dict_row from psycopg.types.json import Jsonb from psycopg_pool import ConnectionPool from .store import AssetConflict, transition from .media import MAX_PHOTOS from .monitors import compatible_monitor, monitor_devices FIELDS = ("tag", "name", "category", "manufacturer", "model", "serial", "location", "department", "purchased_on", "purchase_cost", "vendor", "warranty_until", "notes") SORTS = {"updated": "a.updated_at DESC", "name": "a.name ASC", "tag": "a.tag ASC", "cost": "a.purchase_cost DESC NULLS LAST", "warranty": "a.warranty_until ASC NULLS LAST"} def serialize(row): if row is None: return None return {k: (v.isoformat() if isinstance(v, (date, datetime)) else str(v) if isinstance(v, Decimal) else v) for k, v in row.items()} def filters(q="", category="", status="", location="", assignee="", warranty=False, group=""): conditions, params = ["a.deleted_at IS NULL"], [] if q: # %와 _도 입력한 글자 그대로 검색합니다. 검색어는 SQL과 분리해서 전달합니다. value = "%" + q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%" conditions.append("(concat_ws(' ',a.tag,a.name,a.model,a.serial,a.manufacturer,a.location,a.department,a.assignee_email) ILIKE %s)") params.append(value) for col, value in (("category", category), ("status", status), ("location", location), ("assignee_email", assignee)): if value: conditions.append(f"a.{col} = %s") params.append(value) if warranty: conditions.append("a.warranty_until BETWEEN (now() AT TIME ZONE 'Asia/Seoul')::date AND (now() AT TIME ZONE 'Asia/Seoul')::date + 30 AND a.status <> 'retired'") if group == "furniture": conditions.append("a.category IN ('desk','chair','furniture')") elif group == "computer": conditions.append("a.category NOT IN ('desk','chair','furniture')") return " AND ".join(conditions), params class AssetStore: def __init__(self, dsn): self._pool = ConnectionPool(dsn, min_size=0, max_size=5, timeout=5, open=False, kwargs={"row_factory": dict_row, "autocommit": True}) self._pool.open(wait=False) def close(self): self._pool.close() def health(self): with self._pool.connection(timeout=5) as conn: conn.execute("SELECT id,deleted_at FROM assets LIMIT 1") conn.execute("SELECT id FROM asset_photos LIMIT 0") conn.execute("SELECT monitor_key FROM asset_monitor_links LIMIT 0") def list_assets(self, *, page=1, page_size=25, sort="updated", **kwargs): # 전체 개수와 목록을 같은 시점의 데이터로 읽어 페이지 숫자가 어긋나지 않게 합니다. where, params = filters(**kwargs) with self._pool.connection() as conn, conn.transaction(): conn.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY") total = conn.execute(f"SELECT count(*) AS n FROM assets a WHERE {where}", params).fetchone()["n"] rows = conn.execute( f"SELECT a.*,r.parsed->'summary' AS specs,r.uploaded_at AS report_at FROM assets a " "LEFT JOIN asset_reports r ON r.id=a.latest_report_id " f"WHERE {where} ORDER BY {SORTS.get(sort, SORTS['updated'])},a.id LIMIT %s OFFSET %s", [*params, page_size, (page - 1) * page_size]).fetchall() return {"items": [serialize(r) for r in rows], "total": total, "page": page, "page_size": page_size} def dashboard(self): with self._pool.connection() as conn, conn.transaction(): conn.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY") totals = conn.execute("""SELECT count(*) AS total, count(*) FILTER(WHERE status='available') AS available, count(*) FILTER(WHERE status='in_use') AS in_use, count(*) FILTER(WHERE status='maintenance') AS maintenance, count(*) FILTER(WHERE status='lost') AS lost, count(*) FILTER(WHERE status='retired') AS retired, coalesce(sum(purchase_cost) FILTER(WHERE status<>'retired'),0) AS purchase_total, count(*) FILTER(WHERE status<>'retired' AND warranty_until BETWEEN (now() AT TIME ZONE 'Asia/Seoul')::date AND (now() AT TIME ZONE 'Asia/Seoul')::date+30) AS warranty_soon FROM assets WHERE deleted_at IS NULL""").fetchone() categories = conn.execute("SELECT category,count(*) AS count FROM assets WHERE deleted_at IS NULL GROUP BY category ORDER BY count(*) DESC,category").fetchall() locations = conn.execute("SELECT DISTINCT location FROM assets WHERE location<>'' AND deleted_at IS NULL ORDER BY location").fetchall() activity = conn.execute("SELECT e.*,a.tag,a.name FROM asset_events e JOIN assets a ON a.id=e.asset_id WHERE a.deleted_at IS NULL ORDER BY e.id DESC LIMIT 12").fetchall() return {"totals": serialize(totals), "categories": categories, "locations": [r["location"] for r in locations], "activity": [serialize(r) for r in activity]} def detail(self, asset_id): with self._pool.connection() as conn, conn.transaction(): conn.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY") asset = conn.execute("SELECT * FROM assets WHERE id=%s AND deleted_at IS NULL", (asset_id,)).fetchone() if not asset: raise KeyError(asset_id) reports = conn.execute("SELECT id,filename,sha256,uploaded_at,actor,parsed->'summary' AS summary,parsed->>'scan_time' AS scan_time FROM asset_reports WHERE asset_id=%s ORDER BY uploaded_at DESC,id DESC", (asset_id,)).fetchall() report = conn.execute("SELECT id,filename,uploaded_at,parsed FROM asset_reports WHERE id=%s AND asset_id=%s", (asset["latest_report_id"], asset_id)).fetchone() if asset["latest_report_id"] else None events = conn.execute("SELECT * FROM asset_events WHERE asset_id=%s ORDER BY id DESC LIMIT 200", (asset_id,)).fetchall() photos = conn.execute("SELECT id,filename,width,height,uploaded_at,actor FROM asset_photos WHERE asset_id=%s ORDER BY uploaded_at DESC,id", (asset_id,)).fetchall() monitors = self._monitor_matches(conn, asset_id, report["parsed"]) if report else [] return {"asset": serialize(asset), "report": serialize(report), "reports": [serialize(r) for r in reports], "events": [serialize(r) for r in events], "photos": [serialize(r) for r in photos], "monitors": monitors} @staticmethod def _lock(conn, asset_id, version): # 같은 자산을 동시에 변경할 때 먼저 저장한 사용자의 값을 보호합니다. asset = conn.execute("SELECT * FROM assets WHERE id=%s AND deleted_at IS NULL FOR UPDATE", (asset_id,)).fetchone() if not asset or asset.get("deleted_at"): raise KeyError(asset_id) if asset["version"] != version: raise AssetConflict("다른 사용자가 수정했습니다. 상세 화면을 새로 열고 다시 시도하세요.") return asset @staticmethod def _event(conn, asset_id, actor, kind, note, changes): conn.execute("INSERT INTO asset_events(asset_id,actor,kind,note,changes) VALUES(%s,%s,%s,%s,%s)", (asset_id, actor, kind, note, Jsonb(changes))) def create(self, payload, actor, report=None): with self._pool.connection() as conn, conn.transaction(): return self._create(conn, payload, actor, report) def _create(self, conn, payload, actor, report=None): # 모니터 등록도 같은 트랜잭션 안에서 자산 생성과 연결을 함께 처리합니다. data = payload.model_dump() asset_id = uuid.uuid4().hex if not data["tag"]: data["tag"] = "AST-" + str(conn.execute("SELECT nextval('asset_tag_seq') AS n").fetchone()["n"]).zfill(6) conn.execute(f"INSERT INTO assets(id,{','.join(FIELDS)}) VALUES({','.join(['%s'] * (len(FIELDS) + 1))})", [asset_id, *[data[k] for k in FIELDS]]) self._event(conn, asset_id, actor, "create", "자산 등록", {"after": serialize(data)}) if report: if data["category"] != "computer": raise ValueError("HWiNFO 보고서는 컴퓨터 자산에만 연결할 수 있습니다.") self._save_report(conn, asset_id, actor, *report) return asset_id def update(self, asset_id, payload, actor): data = payload.model_dump(exclude={"version"}) with self._pool.connection() as conn, conn.transaction(): old = self._lock(conn, asset_id, payload.version) if old["latest_report_id"] and data["category"] != "computer": raise ValueError("사양 보고서가 연결된 자산은 컴퓨터 분류를 유지해야 합니다.") if not data["tag"]: data["tag"] = old["tag"] changes = {k: {"before": serialize(old)[k], "after": serialize(data)[k]} for k in FIELDS if old[k] != data[k]} if changes: conn.execute(f"UPDATE assets SET {','.join(k+'=%s' for k in FIELDS)},version=version+1,updated_at=now() WHERE id=%s", [*[data[k] for k in FIELDS], asset_id]) self._event(conn, asset_id, actor, "update", "자산 정보 수정", changes) def action(self, asset_id, payload, actor): with self._pool.connection() as conn, conn.transaction(): old = self._lock(conn, asset_id, payload.version) status, assignee = transition(old, payload) location = payload.location or old["location"] conn.execute("UPDATE assets SET status=%s,assignee_email=%s,location=%s,version=version+1,updated_at=now() WHERE id=%s", (status, assignee, location, asset_id)) changes = {k: {"before": old[k], "after": value} for k, value in (("status", status), ("assignee_email", assignee), ("location", location)) if old[k] != value} self._event(conn, asset_id, actor, payload.action, payload.note, changes) def _save_report(self, conn, asset_id, actor, filename, raw, parsed): # 원본과 분석 결과를 함께 저장하고 최신 보고서만 교체합니다. 이전 보고서는 남습니다. existing = conn.execute("SELECT id FROM asset_reports WHERE asset_id=%s AND sha256=%s", (asset_id, parsed["sha256"])).fetchone() if existing: raise AssetConflict("이 자산에 동일한 보고서가 이미 등록되어 있습니다.") report_id = uuid.uuid4().hex conn.execute("INSERT INTO asset_reports(id,asset_id,filename,sha256,raw_xml,parsed,actor) VALUES(%s,%s,%s,%s,%s,%s,%s)", (report_id, asset_id, filename, parsed["sha256"], raw, Jsonb(parsed), actor)) conn.execute("UPDATE assets SET latest_report_id=%s,version=version+1,updated_at=now() WHERE id=%s", (report_id, asset_id)) self._event(conn, asset_id, actor, "report", filename, {"report_id": report_id, "summary": parsed["summary"]}) return report_id def attach_report(self, asset_id, version, actor, filename, raw, parsed): with self._pool.connection() as conn, conn.transaction(): asset = self._lock(conn, asset_id, version) if asset["category"] != "computer": raise ValueError("HWiNFO 보고서는 컴퓨터 자산에만 연결할 수 있습니다.") return self._save_report(conn, asset_id, actor, filename, raw, parsed) def report(self, asset_id, report_id, *, raw=False): columns = "r.filename,r.raw_xml" if raw else "r.id,r.filename,r.parsed,r.uploaded_at" with self._pool.connection() as conn: row = conn.execute(f"SELECT {columns} FROM asset_reports r JOIN assets a ON a.id=r.asset_id WHERE r.asset_id=%s AND r.id=%s AND a.deleted_at IS NULL", (asset_id, report_id)).fetchone() if not row: raise KeyError(report_id) return serialize(row) def delete(self, asset_id, version, actor, note): # 수퍼 관리자 삭제도 이력과 원본은 보존하고 대장·다운로드에서 제외합니다. with self._pool.connection() as conn, conn.transaction(): self._lock(conn, asset_id, version) self._event(conn, asset_id, actor, "delete", note, {}) conn.execute("UPDATE assets SET deleted_at=now(),deleted_by=%s,version=version+1,updated_at=now() WHERE id=%s", (actor, asset_id)) def add_photo(self, asset_id, version, actor, filename, image, mime, width, height): with self._pool.connection() as conn, conn.transaction(): self._lock(conn, asset_id, version) count = conn.execute("SELECT count(*) AS n FROM asset_photos WHERE asset_id=%s", (asset_id,)).fetchone()["n"] if count >= MAX_PHOTOS: raise ValueError(f"사진은 자산당 {MAX_PHOTOS}개까지 등록할 수 있습니다.") photo_id = uuid.uuid4().hex conn.execute("INSERT INTO asset_photos(id,asset_id,filename,image,mime,width,height,actor) VALUES(%s,%s,%s,%s,%s,%s,%s,%s)", (photo_id, asset_id, filename, image, mime, width, height, actor)) conn.execute("UPDATE assets SET version=version+1,updated_at=now() WHERE id=%s", (asset_id,)) self._event(conn, asset_id, actor, "photo", filename, {"photo_id": photo_id}) return photo_id def photo(self, asset_id, photo_id): with self._pool.connection() as conn: row = conn.execute("SELECT p.image,p.mime FROM asset_photos p JOIN assets a ON a.id=p.asset_id WHERE p.asset_id=%s AND p.id=%s AND a.deleted_at IS NULL", (asset_id, photo_id)).fetchone() if not row: raise KeyError(photo_id) return row @staticmethod def _monitor_matches(conn, computer_id, parsed): result = [] for device in monitor_devices(parsed): linked = conn.execute("SELECT a.* FROM asset_monitor_links l JOIN assets a ON a.id=l.monitor_asset_id WHERE l.computer_id=%s AND l.monitor_key=%s AND a.category='monitor' AND a.deleted_at IS NULL", (computer_id, device["key"])).fetchone() matches = conn.execute("SELECT * FROM assets WHERE category='monitor' AND deleted_at IS NULL AND lower(btrim(serial))=%s ORDER BY id LIMIT 21", (device["serial"].casefold(),)).fetchall() if device["serial"] else [] compatible = [a for a in matches if compatible_monitor(a, device)] asset = linked or (compatible[0] if len(compatible) == 1 else None) candidates = matches if not asset else [] # candidate_by — 후보가 같은 시리얼(같은 실물일 가능성)인지, 참고용 같은 모델·이름인지. # 같은 모델은 여러 대일 수 있으므로(듀얼 모니터 등) 새 등록을 막지 않는다(2026-10-07). candidate_by = "serial" if candidates else "" if not asset and not candidates: candidates = conn.execute("SELECT * FROM assets WHERE category='monitor' AND deleted_at IS NULL AND (lower(btrim(model))=%s OR lower(btrim(name))=%s) ORDER BY id LIMIT 20", (device["model"].casefold(), device["name"].casefold())).fetchall() candidate_by = "model" if candidates else "" result.append({**device, "asset": serialize(asset), "candidates": [serialize(r) for r in candidates], "candidate_by": candidate_by, "match": "linked" if linked else "serial" if asset else "unconfirmed"}) return result def report_monitors(self, asset_id, report_id): with self._pool.connection() as conn, conn.transaction(): conn.execute("SET TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY") row = conn.execute("SELECT r.parsed FROM asset_reports r JOIN assets a ON a.id=r.asset_id WHERE r.asset_id=%s AND r.id=%s AND a.deleted_at IS NULL", (asset_id, report_id)).fetchone() if not row: raise KeyError(report_id) return self._monitor_matches(conn, asset_id, row["parsed"]) def register_monitor(self, computer_id, index, payload, actor): with self._pool.connection() as conn, conn.transaction(): computer = self._lock(conn, computer_id, payload.version) if computer["category"] != "computer" or computer["latest_report_id"] != payload.report_id: raise AssetConflict("최신 컴퓨터 보고서를 다시 열고 모니터를 등록하세요.") row = conn.execute("SELECT parsed FROM asset_reports WHERE asset_id=%s AND id=%s", (computer_id, payload.report_id)).fetchone() devices = monitor_devices(row["parsed"]) if row else [] if index < 0 or index >= len(devices): raise KeyError(index) device = devices[index] # 서로 다른 컴퓨터에서 동일 시리얼을 동시에 등록하는 경우도 중복을 막습니다. if device["serial"]: conn.execute("SELECT pg_advisory_xact_lock(hashtextextended(%s,0))", ("asset-monitor:" + device["serial"].casefold(),)) if payload.asset_id: target = conn.execute("SELECT * FROM assets WHERE id=%s AND deleted_at IS NULL FOR UPDATE", (payload.asset_id,)).fetchone() if not target or target["category"] != "monitor": raise ValueError("등록된 모니터 자산을 선택하세요.") monitor_id = target["id"] else: match = self._monitor_matches(conn, computer_id, row["parsed"])[index] # 같은 시리얼(같은 실물)만 막는다 — 같은 모델이지만 시리얼이 다른 모니터는 새 자산으로 등록된다. if match["asset"] or match["candidate_by"] == "serial": raise AssetConflict(f"같은 시리얼({device['serial']})의 모니터가 이미 등록되어 있습니다. 기존 자산에 연결하세요." if device["serial"] else "이 모니터는 이미 자산에 연결되어 있습니다.") # 보고서의 실제 시리얼을 유지해야 이후 보고서에서도 같은 장비를 찾습니다. data = payload.asset.model_copy(update={"serial": device["serial"] or payload.asset.serial}) monitor_id = self._create(conn, data, actor) conn.execute("INSERT INTO asset_monitor_links(computer_id,monitor_key,monitor_asset_id,actor) VALUES(%s,%s,%s,%s) ON CONFLICT(computer_id,monitor_key) DO UPDATE SET monitor_asset_id=EXCLUDED.monitor_asset_id,actor=EXCLUDED.actor,linked_at=now()", (computer_id, device["key"], monitor_id, actor)) conn.execute("UPDATE assets SET version=version+1,updated_at=now() WHERE id=%s", (computer_id,)) self._event(conn, computer_id, actor, "monitor", "모니터 자산 연결", {"monitor_asset_id": monitor_id, "model": device["model"]}) return monitor_id