Files
dbx-main/app/store.py
T
king f54f19fa45 feat(라이브커머스): 라이브 커머스 모듈 추가
말레이시아 라이브 방송의 호스트 정보와 방송 스케줄을 관리하는 새 모듈.
호스트 설정(이름·연락처·주소·계좌·틱톡)은 ERP 관리자만 다루고,
스케줄표에서 등록된 호스트를 골라 날짜·시간·장소·판매금액(RM)·결과
이미지를 저장한다. 권한키 live, DB live_db(LIVE_DB_URL), 미설정이면
설정 필요 안내만 표시한다.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 16:41:37 +09:00

281 lines
11 KiB
Python

"""JSON 기반 사용자/권한 저장소.
- app/data/users.json 에 사용자 레코드 저장
- 동시성: 파일락 대신 process-내 threading.Lock + 원자적 쓰기(temp → rename)
- 운영시 컨테이너 한 대 가정. 다중 인스턴스 필요해지면 DB 로 교체.
"""
from __future__ import annotations
import json
import os
import tempfile
import threading
from pathlib import Path
from typing import Any, Iterable
from urllib.parse import quote
from fastapi.responses import RedirectResponse
from .timezone import now_kst_iso
# 슈퍼 관리자 — 강등/삭제 불가
SUPER_ADMIN_EMAIL = "king@dbxcorp.co.kr"
# 시스템에서 지원하는 권한 키.
# - 접근권한: 모듈 페이지 진입 허용
# - 승인자: 결재 워크플로에서 승인/반려 가능
# 신규 추가 시 여기 + admin.html MODULE_LABELS + 라우터 검사 동시 갱신.
MODULE_KEYS: tuple[str, ...] = (
"corm",
"order",
"expense",
"vacation",
"cupang",
"malaysia",
"dispatch",
"project",
"cafe24",
"performance",
"asset",
"inout",
"outreach",
"live",
"expense_approver",
"vacation_approver",
)
# 승인자 권한 키 — 결재 워크플로에서 별도 검사할 때 사용
APPROVER_KEYS: tuple[str, ...] = ("expense_approver", "vacation_approver")
# 관리자 등급(2026-10-12) — 수퍼관리자(SUPER_ADMIN_EMAIL 한 명, 고정·추가 불가) > admin > pro > user.
# 저장하는 role 값은 admin / pro / user 셋뿐 — 수퍼관리자는 role 이 아니라 이메일로 정해진다.
# pro 는 프로젝트 모듈(프로젝트·목표·주간 회의록)에서만 admin 에 가까운 권한을 받고
# (app/modules/project/access.py), 다른 모듈과 관리자 페이지에서는 user 와 같다(is_admin False).
ROLES: tuple[str, ...] = ("admin", "pro", "user")
ROLE_LABELS: dict[str, str] = {"admin": "Admin", "pro": "Pro user", "user": "User"}
def _now_iso() -> str:
return now_kst_iso()
class UserStore:
def __init__(self, path: Path):
self._path = path
self._lock = threading.Lock()
self._path.parent.mkdir(parents=True, exist_ok=True)
if not self._path.exists():
self._write_atomic({"users": {}})
def _read(self) -> dict[str, Any]:
try:
with self._path.open("r", encoding="utf-8") as f:
data = json.load(f)
except FileNotFoundError: # 깨진 JSON 은 잡지 않는다 — 빈 목록으로 읽으면 다음 로그인이 전체 사용자를 덮어쓴다
data = {"users": {}}
if "users" not in data or not isinstance(data["users"], dict):
data["users"] = {}
return data
def _write_atomic(self, data: dict[str, Any]) -> None:
fd, tmp = tempfile.mkstemp(
prefix=".users.", suffix=".json.tmp", dir=str(self._path.parent)
)
try:
with os.fdopen(fd, "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False, indent=2)
os.replace(tmp, self._path)
except Exception:
try:
os.unlink(tmp)
except OSError:
pass
raise
@staticmethod
def _default_modules(is_admin: bool) -> dict[str, bool]:
return {key: is_admin for key in MODULE_KEYS}
@staticmethod
def _normalize_modules(modules: dict[str, Any] | None, *, is_admin: bool) -> dict[str, bool]:
# 신규(modules 미지정) 사용자는 역할 기본값(admin=전체ON / user=전체OFF)으로 시작.
# 기존 값이 있으면 그대로 존중한다 — admin 이라도 슈퍼관리자가 개별 모듈을
# 끌 수 있다(예전엔 admin 을 무조건 전체 ON 으로 덮어썼다).
base = UserStore._default_modules(is_admin)
if isinstance(modules, dict):
for key in MODULE_KEYS:
if key in modules:
base[key] = bool(modules[key])
return base
def get(self, email: str) -> dict[str, Any] | None:
email = email.lower().strip()
with self._lock:
data = self._read()
user = data["users"].get(email)
if user is None:
return None
return self._enrich(email, user)
def list_all(self) -> list[dict[str, Any]]:
with self._lock:
data = self._read()
return [self._enrich(email, rec) for email, rec in data["users"].items()]
def create_user(
self,
*,
email: str,
name: str = "",
role: str = "user",
modules: dict[str, Any] | None = None,
) -> dict[str, Any]:
"""관리자가 이메일만으로 신규 사용자 등록. 로그인 전이라도 권한 부여 가능."""
email = email.lower().strip()
if not email or "@" not in email:
raise ValueError("올바른 이메일 형식이 아닙니다.")
if role not in ROLES:
raise ValueError(f"role 값이 잘못되었습니다: {role}")
is_super = email == SUPER_ADMIN_EMAIL
with self._lock:
data = self._read()
if email in data["users"]:
raise ValueError(f"이미 등록된 사용자입니다: {email}")
now = _now_iso()
final_role = "admin" if is_super else role
rec = {
"email": email,
"name": name or email.split("@")[0],
"picture": "",
"role": final_role,
"modules": self._normalize_modules(
modules, is_admin=(final_role == "admin")
),
"created_at": now,
"last_login": "",
}
data["users"][email] = rec
self._write_atomic(data)
return self._enrich(email, rec)
def upsert_login(self, *, email: str, name: str, picture: str) -> dict[str, Any]:
"""로그인 시 호출. 신규면 생성, 기존이면 last_login/name/picture 갱신."""
email = email.lower().strip()
is_super = email == SUPER_ADMIN_EMAIL
with self._lock:
data = self._read()
now = _now_iso()
existing = data["users"].get(email)
if existing is None:
rec = {
"email": email,
"name": name,
"picture": picture,
"role": "admin" if is_super else "user",
"modules": self._default_modules(is_admin=is_super),
"created_at": now,
"last_login": now,
}
else:
rec = dict(existing)
rec["name"] = name or rec.get("name", email)
rec["picture"] = picture or rec.get("picture", "")
rec["last_login"] = now
# 슈퍼 관리자는 항상 admin + 모든 모듈
if is_super:
rec["role"] = "admin"
rec["modules"] = self._default_modules(is_admin=True)
else:
rec["modules"] = self._normalize_modules(
rec.get("modules"), is_admin=(rec.get("role") == "admin")
)
data["users"][email] = rec
self._write_atomic(data)
return self._enrich(email, rec)
def update_permissions(
self, *, email: str, role: str | None, modules: dict[str, Any] | None
) -> dict[str, Any]:
"""관리자가 다른 사용자의 권한을 수정."""
email = email.lower().strip()
if email == SUPER_ADMIN_EMAIL:
raise PermissionError("슈퍼 관리자 계정은 수정할 수 없습니다.")
if role is not None and role not in ROLES:
raise ValueError(f"role 값이 잘못되었습니다: {role}")
with self._lock:
data = self._read()
rec = data["users"].get(email)
if rec is None:
raise KeyError(f"사용자를 찾을 수 없습니다: {email}")
if role is not None:
rec["role"] = role
new_is_admin = rec.get("role") == "admin"
rec["modules"] = self._normalize_modules(
modules if modules is not None else rec.get("modules"),
is_admin=new_is_admin,
)
data["users"][email] = rec
self._write_atomic(data)
return self._enrich(email, rec)
def delete(self, email: str) -> None:
email = email.lower().strip()
if email == SUPER_ADMIN_EMAIL:
raise PermissionError("슈퍼 관리자 계정은 삭제할 수 없습니다.")
with self._lock:
data = self._read()
if email in data["users"]:
del data["users"][email]
self._write_atomic(data)
@staticmethod
def _enrich(email: str, rec: dict[str, Any]) -> dict[str, Any]:
out = dict(rec)
out["email"] = email
out["is_super_admin"] = email == SUPER_ADMIN_EMAIL
out["modules"] = UserStore._normalize_modules(
out.get("modules"), is_admin=(out.get("role") == "admin")
)
return out
def is_admin(user_rec: dict[str, Any] | None) -> bool:
return bool(user_rec and user_rec.get("role") == "admin")
def has_module(user_rec: dict[str, Any] | None, module: str) -> bool:
if not user_rec:
return False
# 슈퍼관리자는 항상 전체 접근. 일반 admin 은 칩(modules) 상태를 따른다 —
# 슈퍼관리자가 admin 의 개별 프로그램 접근을 제어할 수 있도록.
if user_rec.get("is_super_admin"):
return True
mods = user_rec.get("modules") or {}
if mods.get(module):
return True
# 승인자(<module>_approver) 권한이 있으면 해당 모듈 접근도 허용 —
# 본인 경비 등록/제출도 가능해야 하므로.
if module in APPROVER_KEYS:
return False
if mods.get(f"{module}_approver"):
return True
return False
def is_approver(user_rec: dict[str, Any] | None, kind: str) -> bool:
"""결재 승인자 권한 검사. kind 예: 'expense', 'vacation'."""
return has_module(user_rec, f"{kind}_approver")
def allowed_modules(user_rec: dict[str, Any] | None) -> set[str]:
return {m for m in MODULE_KEYS if has_module(user_rec, m)}
def login_redirect(request: Any) -> RedirectResponse:
"""로그인 화면으로 — 로그인 뒤 지금 보던 화면(경로+쿼리)으로 돌아온다(모든 모듈 화면 공통).
GET 만 next 를 붙인다(폼 POST 주소로 돌아가면 GET 이라 405 가 난다)."""
if request.method != "GET":
return RedirectResponse(url="/login", status_code=303)
here = request.url.path + ("?" + request.url.query if request.url.query else "")
return RedirectResponse(url="/login?next=" + quote(here, safe=""), status_code=303)