b576dd1a38
Apply asset_db_002_photos_monitors.sql before rebuilding web. Restrict soft deletion to the super admin; retain reports and audit.
305 lines
14 KiB
Python
305 lines
14 KiB
Python
from __future__ import annotations
|
|
|
|
# 화면, 권한 검사, 파일 업로드를 담당합니다. 실제 저장은 db.py에서 처리합니다.
|
|
|
|
import io
|
|
import secrets
|
|
from contextlib import contextmanager
|
|
from typing import Annotated
|
|
from urllib.parse import quote
|
|
|
|
from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile
|
|
from fastapi.responses import RedirectResponse, Response
|
|
from openpyxl import Workbook
|
|
from pydantic import ValidationError
|
|
from psycopg import Error as DBError
|
|
from psycopg.errors import UniqueViolation
|
|
from psycopg_pool import PoolTimeout
|
|
from starlette.concurrency import run_in_threadpool
|
|
|
|
from .hwinfo import MAX_REPORT_BYTES, parse_hwinfo
|
|
from .store import ActionInput, AssetConflict, AssetInput, AssetUpdate, CATEGORIES, STATUSES
|
|
from .store import DeleteInput, MonitorInput
|
|
from .media import MAX_PHOTO_BYTES, prepare_photo
|
|
|
|
router = APIRouter(prefix="/asset", tags=["asset"])
|
|
|
|
|
|
def _user(request: Request):
|
|
from app.main import get_current_user_record
|
|
from app.store import has_module
|
|
user = get_current_user_record(request)
|
|
if not user:
|
|
raise HTTPException(401, "로그인이 필요합니다.")
|
|
if not has_module(user, "asset"):
|
|
raise HTTPException(403, "자산관리 권한이 없습니다.")
|
|
return user
|
|
|
|
|
|
def _write(request: Request, user=Depends(_user)):
|
|
expected = request.session.get("asset_csrf", "")
|
|
token = request.headers.get("x-asset-csrf", "")
|
|
if not expected or not secrets.compare_digest(expected, token):
|
|
raise HTTPException(403, "화면을 새로 열고 다시 시도하세요.")
|
|
return user
|
|
|
|
|
|
def _super(user):
|
|
from app.store import SUPER_ADMIN_EMAIL
|
|
return user.get("email", "").lower() == SUPER_ADMIN_EMAIL
|
|
|
|
|
|
def _super_write(user=Depends(_write)):
|
|
if not _super(user):
|
|
raise HTTPException(403, "수퍼 관리자만 자산을 삭제할 수 있습니다.")
|
|
return user
|
|
|
|
|
|
def _store(request):
|
|
store = getattr(request.app.state, "asset_store", None)
|
|
if store is None:
|
|
raise HTTPException(503, "자산관리 DB 설정이 필요합니다. 관리자에게 문의하세요.")
|
|
return store
|
|
|
|
|
|
@contextmanager
|
|
def _errors():
|
|
try:
|
|
yield
|
|
except AssetConflict as exc:
|
|
raise HTTPException(409, str(exc)) from exc
|
|
except KeyError as exc:
|
|
raise HTTPException(404, "자산 또는 보고서를 찾을 수 없습니다.") from exc
|
|
except ValueError as exc:
|
|
raise HTTPException(422, str(exc)) from exc
|
|
except UniqueViolation as exc:
|
|
raise HTTPException(409, "이미 등록된 자산번호입니다. 다른 번호를 사용하세요.") from exc
|
|
except (DBError, PoolTimeout) as exc:
|
|
# DB 오류에 접속 비밀번호가 섞일 수 있어 원문 대신 일반 안내만 보여줍니다.
|
|
raise HTTPException(503, "자산관리 DB에 연결할 수 없습니다. 설정과 초기화를 확인하세요.") from exc
|
|
|
|
|
|
@router.get("/")
|
|
def index(request: Request):
|
|
from app.main import build_erp_nav, get_current_user_record, render_template
|
|
from app.store import has_module, is_admin
|
|
user = get_current_user_record(request)
|
|
if not user:
|
|
return RedirectResponse("/login", 303)
|
|
if not has_module(user, "asset"):
|
|
return render_template(request, "denied.html", {"reason": "자산관리 권한이 없습니다.", "user": user,
|
|
"is_admin": is_admin(user)}, status_code=403)
|
|
request.session.setdefault("asset_csrf", secrets.token_urlsafe(32))
|
|
return render_template(request, "asset/index.html", {
|
|
"user": user, "is_admin": is_admin(user), "nav_items": build_erp_nav(user, active="asset"),
|
|
"page_title": "자산관리", "page_subtitle": "사무집기부터 컴퓨터 사양까지, 회사 자산을 한곳에서",
|
|
"categories": CATEGORIES, "statuses": STATUSES, "csrf_token": request.session["asset_csrf"],
|
|
"configured": getattr(request.app.state, "asset_store", None) is not None,
|
|
"can_delete": _super(user),
|
|
})
|
|
|
|
|
|
@router.get("/health")
|
|
def health(request: Request, user=Depends(_user)):
|
|
with _errors():
|
|
_store(request).health()
|
|
return {"ok": True}
|
|
|
|
|
|
@router.get("/api/bootstrap")
|
|
def bootstrap(request: Request, user=Depends(_user)):
|
|
from app.main import user_store
|
|
with _errors():
|
|
data = _store(request).dashboard()
|
|
data["users"] = [{"email": u["email"], "name": u.get("name") or u["email"]} for u in user_store.list_all()]
|
|
return data
|
|
|
|
|
|
def _query(q="", category="", status="", location="", assignee="", warranty=False, group=""):
|
|
if category and category not in CATEGORIES or status and status not in STATUSES:
|
|
raise HTTPException(422, "분류 또는 상태 필터가 올바르지 않습니다.")
|
|
if group not in {"", "computer", "furniture"}:
|
|
raise HTTPException(422, "자산 구분 필터가 올바르지 않습니다.")
|
|
return dict(q=q, category=category, status=status, location=location, assignee=assignee, warranty=warranty, group=group)
|
|
|
|
|
|
@router.get("/api/assets")
|
|
def assets(request: Request, q: str = Query("", max_length=200), category: str = "", status: str = "",
|
|
location: str = Query("", max_length=150), assignee: str = Query("", max_length=254), warranty: bool = False,
|
|
page: int = Query(1, ge=1, le=100000), page_size: int = Query(25, ge=1, le=100),
|
|
sort: str = "updated", group: str = "", user=Depends(_user)):
|
|
with _errors():
|
|
return _store(request).list_assets(page=page, page_size=page_size, sort=sort,
|
|
**_query(q, category, status, location, assignee, warranty, group))
|
|
|
|
|
|
@router.get("/api/export")
|
|
def export(request: Request, q: str = Query("", max_length=200), category: str = "", status: str = "",
|
|
location: str = Query("", max_length=150), assignee: str = Query("", max_length=254), warranty: bool = False,
|
|
group: str = "", user=Depends(_user)):
|
|
from app.timezone import today_kst
|
|
with _errors():
|
|
data = _store(request).list_assets(page=1, page_size=10001, **_query(q, category, status, location, assignee, warranty, group))
|
|
if data["total"] > 10000:
|
|
raise HTTPException(422, "한 번에 10,000개까지 내보낼 수 있습니다. 필터를 좁혀주세요.")
|
|
book = Workbook()
|
|
sheet = book.active
|
|
sheet.title = "자산대장"
|
|
headers = ["자산번호", "자산명", "분류", "상태", "제조사", "모델", "시리얼", "위치", "부서", "사용자", "구매일", "구매금액(원)", "구매처", "보증종료", "메모", "CPU", "메모리", "GPU", "운영체제"]
|
|
sheet.append(headers)
|
|
for row in data["items"]:
|
|
specs = row.get("specs") or {}
|
|
values = [row["tag"], row["name"], CATEGORIES[row["category"]], STATUSES[row["status"]],
|
|
*[row[k] for k in ("manufacturer", "model", "serial", "location", "department", "assignee_email", "purchased_on")],
|
|
float(row["purchase_cost"]) if row["purchase_cost"] is not None else None,
|
|
row["vendor"], row["warranty_until"], row["notes"], *[specs.get(k, "") for k in ("cpu", "memory", "gpu", "os")]]
|
|
sheet.append(values)
|
|
# =로 시작하는 자산명도 엑셀 수식 대신 일반 글자로 저장합니다.
|
|
for cell in sheet[sheet.max_row]:
|
|
if isinstance(cell.value, str):
|
|
cell.data_type = "s"
|
|
sheet.freeze_panes = "C2"
|
|
sheet.auto_filter.ref = sheet.dimensions
|
|
from openpyxl.styles import Font, PatternFill
|
|
from openpyxl.utils import get_column_letter
|
|
for cell in sheet[1]:
|
|
cell.font = Font(bold=True, color="FFFFFF")
|
|
cell.fill = PatternFill("solid", fgColor="171717")
|
|
for i in range(1, len(headers) + 1):
|
|
sheet.column_dimensions[get_column_letter(i)].width = 22 if i > 2 else 28
|
|
buffer = io.BytesIO()
|
|
book.save(buffer)
|
|
return Response(buffer.getvalue(), media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
|
|
headers={"Content-Disposition": f'attachment; filename="assets-{today_kst().isoformat()}.xlsx"'})
|
|
|
|
|
|
@router.post("/api/assets")
|
|
def create(request: Request, payload: AssetInput, user=Depends(_write)):
|
|
with _errors():
|
|
asset_id = _store(request).create(payload, user["email"])
|
|
return {"id": asset_id}
|
|
|
|
|
|
@router.get("/api/assets/{asset_id}")
|
|
def detail(request: Request, asset_id: str, user=Depends(_user)):
|
|
with _errors():
|
|
return _store(request).detail(asset_id)
|
|
|
|
|
|
@router.put("/api/assets/{asset_id}")
|
|
def update(request: Request, asset_id: str, payload: AssetUpdate, user=Depends(_write)):
|
|
with _errors():
|
|
_store(request).update(asset_id, payload, user["email"])
|
|
return {"ok": True}
|
|
|
|
|
|
@router.delete("/api/assets/{asset_id}")
|
|
def delete(request: Request, asset_id: str, payload: DeleteInput, user=Depends(_super_write)):
|
|
with _errors():
|
|
_store(request).delete(asset_id, payload.version, user["email"], payload.note)
|
|
return {"ok": True}
|
|
|
|
|
|
@router.post("/api/assets/{asset_id}/photos")
|
|
async def add_photo(request: Request, asset_id: str, file: Annotated[UploadFile, File()],
|
|
version: Annotated[int, Form(ge=1)], user=Depends(_write)):
|
|
filename = (file.filename or "photo.jpg").replace("\\", "/").rsplit("/", 1)[-1]
|
|
try:
|
|
if len(filename) > 200 or any(ord(c) < 32 for c in filename):
|
|
raise HTTPException(422, "사진 파일 이름을 확인하세요.")
|
|
raw = await file.read(MAX_PHOTO_BYTES + 1)
|
|
finally:
|
|
await file.close()
|
|
with _errors():
|
|
image, mime, width, height = await run_in_threadpool(prepare_photo, raw)
|
|
photo_id = await run_in_threadpool(_store(request).add_photo, asset_id, version, user["email"], filename, image, mime, width, height)
|
|
return {"id": photo_id}
|
|
|
|
|
|
@router.get("/api/assets/{asset_id}/photos/{photo_id}")
|
|
def photo(request: Request, asset_id: str, photo_id: str, user=Depends(_user)):
|
|
with _errors():
|
|
row = _store(request).photo(asset_id, photo_id)
|
|
return Response(bytes(row["image"]), media_type=row["mime"],
|
|
headers={"X-Content-Type-Options": "nosniff", "Cache-Control": "no-store"})
|
|
|
|
|
|
@router.get("/api/assets/{asset_id}/reports/{report_id}/monitors")
|
|
def report_monitors(request: Request, asset_id: str, report_id: str, user=Depends(_user)):
|
|
with _errors():
|
|
return {"items": _store(request).report_monitors(asset_id, report_id)}
|
|
|
|
|
|
@router.post("/api/assets/{asset_id}/monitors/{index}")
|
|
def register_monitor(request: Request, asset_id: str, index: int, payload: MonitorInput, user=Depends(_write)):
|
|
with _errors():
|
|
monitor_id = _store(request).register_monitor(asset_id, index, payload, user["email"])
|
|
return {"id": monitor_id}
|
|
|
|
|
|
@router.post("/api/assets/{asset_id}/actions")
|
|
def action(request: Request, asset_id: str, payload: ActionInput, user=Depends(_write)):
|
|
from app.main import user_store
|
|
if payload.action == "checkout" and not user_store.get(payload.assignee_email.lower()):
|
|
raise HTTPException(422, "등록된 회사 사용자를 선택하세요.")
|
|
with _errors():
|
|
_store(request).action(asset_id, payload, user["email"])
|
|
return {"ok": True}
|
|
|
|
|
|
async def _report_file(file):
|
|
filename = (file.filename or "report.xml").replace("\\", "/").rsplit("/", 1)[-1]
|
|
if not filename.lower().endswith(".xml") or len(filename) > 200 or any(ord(c) < 32 for c in filename):
|
|
raise HTTPException(422, "이름이 200자 이하인 XML 보고서를 선택하세요.")
|
|
try:
|
|
raw = await file.read(MAX_REPORT_BYTES + 1)
|
|
finally:
|
|
await file.close()
|
|
with _errors():
|
|
parsed = await run_in_threadpool(parse_hwinfo, raw)
|
|
return filename, raw, parsed
|
|
|
|
|
|
@router.post("/api/reports/preview")
|
|
async def preview(file: Annotated[UploadFile, File()], user=Depends(_write)):
|
|
filename, raw, parsed = await _report_file(file)
|
|
return {"filename": filename, "summary": parsed["summary"], "scan_time": parsed["scan_time"],
|
|
"property_count": parsed["property_count"], "warnings": parsed["warnings"]}
|
|
|
|
|
|
@router.post("/api/reports/import")
|
|
async def import_report(request: Request, file: Annotated[UploadFile, File()], payload: Annotated[str, Form(max_length=20000)], user=Depends(_write)):
|
|
with _errors():
|
|
try:
|
|
data = AssetInput.model_validate_json(payload)
|
|
except ValidationError as exc:
|
|
raise HTTPException(422, "자산명·분류·구매일·금액을 확인하세요.") from exc
|
|
report = await _report_file(file)
|
|
with _errors():
|
|
asset_id = await run_in_threadpool(_store(request).create, data, user["email"], report)
|
|
return {"id": asset_id}
|
|
|
|
|
|
@router.post("/api/assets/{asset_id}/reports")
|
|
async def attach(request: Request, asset_id: str, file: Annotated[UploadFile, File()],
|
|
version: Annotated[int, Form(ge=1)], user=Depends(_write)):
|
|
filename, raw, parsed = await _report_file(file)
|
|
with _errors():
|
|
report_id = await run_in_threadpool(_store(request).attach_report, asset_id, version, user["email"], filename, raw, parsed)
|
|
return {"id": report_id}
|
|
|
|
|
|
@router.get("/api/assets/{asset_id}/reports/{report_id}")
|
|
def report_detail(request: Request, asset_id: str, report_id: str, user=Depends(_user)):
|
|
with _errors():
|
|
return _store(request).report(asset_id, report_id)
|
|
|
|
|
|
@router.get("/api/assets/{asset_id}/reports/{report_id}/download")
|
|
def download(request: Request, asset_id: str, report_id: str, user=Depends(_user)):
|
|
with _errors():
|
|
row = _store(request).report(asset_id, report_id, raw=True)
|
|
return Response(bytes(row["raw_xml"]), media_type="application/octet-stream",
|
|
headers={"Content-Disposition": f"attachment; filename=hwinfo.xml; filename*=UTF-8''{quote(row['filename'], safe='')}",
|
|
"X-Content-Type-Options": "nosniff", "Cache-Control": "no-store"})
|