0f9a5ad2ea
Some checks failed
SonarQube Analysis / SonarQube Scan (push) Has been cancelled
✅ 주요 수정사항: - 재질 GRADE 전체 표기: ASTM A106 B 완전 표시 (A10 잘림 현상 해결) - material_grade_extractor.py 정규표현식 패턴 개선 - files.py 파일 업로드 시 재질 추출 로직 수정 - CSS 그리드 너비 확장으로 텍스트 잘림 현상 해결 - 사용자 요구사항 엑셀 다운로드 기능 완료 🎯 해결된 문제: 1. ASTM A106 B → ASTM A10 잘림 문제 2. 재질 컬럼 너비 부족으로 인한 표시 문제 3. 사용자 요구사항이 엑셀에 반영되지 않는 문제 📋 다음 단계 준비: - 파이프 끝단 정보 제외 취합 로직 개선 - 플랜지 타입 정보 확장 - 자재 분류 필터 기능 추가
327 lines
9.7 KiB
Python
327 lines
9.7 KiB
Python
"""
|
|
인증 및 권한 미들웨어
|
|
JWT 토큰 기반 인증과 역할 기반 접근 제어(RBAC) 구현
|
|
"""
|
|
from fastapi import Depends, HTTPException, status, Request
|
|
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
|
|
from sqlalchemy.orm import Session
|
|
from typing import List, Optional, Callable, Any
|
|
from functools import wraps
|
|
import inspect
|
|
|
|
from ..database import get_db
|
|
from .jwt_service import jwt_service
|
|
from .models import UserRepository
|
|
from ..utils.logger import get_logger
|
|
|
|
logger = get_logger(__name__)
|
|
security = HTTPBearer()
|
|
|
|
|
|
class AuthMiddleware:
|
|
"""인증 미들웨어 클래스"""
|
|
|
|
def __init__(self):
|
|
self.security = HTTPBearer()
|
|
|
|
async def get_current_user(
|
|
self,
|
|
credentials: HTTPAuthorizationCredentials = Depends(security),
|
|
db: Session = Depends(get_db)
|
|
) -> dict:
|
|
"""
|
|
현재 사용자 정보 조회
|
|
|
|
Args:
|
|
credentials: JWT 토큰
|
|
db: 데이터베이스 세션
|
|
|
|
Returns:
|
|
dict: 사용자 정보
|
|
|
|
Raises:
|
|
HTTPException: 인증 실패 시
|
|
"""
|
|
try:
|
|
# 토큰 검증
|
|
payload = jwt_service.verify_access_token(credentials.credentials)
|
|
user_id = payload['user_id']
|
|
|
|
# 사용자 정보 조회
|
|
user_repo = UserRepository(db)
|
|
user = user_repo.find_by_id(user_id)
|
|
|
|
if not user:
|
|
logger.warning(f"User not found for token: user_id {user_id}")
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="사용자를 찾을 수 없습니다"
|
|
)
|
|
|
|
if not user.is_active:
|
|
logger.warning(f"Inactive user attempted access: {user.username}")
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="비활성화된 계정입니다"
|
|
)
|
|
|
|
if user.is_locked():
|
|
logger.warning(f"Locked user attempted access: {user.username}")
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="잠긴 계정입니다"
|
|
)
|
|
|
|
# 사용자 정보와 토큰 페이로드 결합
|
|
user_info = user.to_dict()
|
|
user_info.update({
|
|
'token_user_id': payload['user_id'],
|
|
'token_username': payload['username'],
|
|
'token_role': payload['role']
|
|
})
|
|
|
|
return user_info
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Get current user error: {str(e)}")
|
|
raise HTTPException(
|
|
status_code=status.HTTP_401_UNAUTHORIZED,
|
|
detail="인증 처리 중 오류가 발생했습니다"
|
|
)
|
|
|
|
async def get_current_active_user(
|
|
self,
|
|
current_user: dict = Depends(get_current_user)
|
|
) -> dict:
|
|
"""
|
|
현재 활성 사용자 정보 조회 (별칭)
|
|
|
|
Args:
|
|
current_user: 현재 사용자 정보
|
|
|
|
Returns:
|
|
dict: 사용자 정보
|
|
"""
|
|
return current_user
|
|
|
|
def require_roles(self, allowed_roles: List[str]):
|
|
"""
|
|
특정 역할을 요구하는 의존성 함수 생성
|
|
|
|
Args:
|
|
allowed_roles: 허용된 역할 목록
|
|
|
|
Returns:
|
|
Callable: 의존성 함수
|
|
"""
|
|
async def role_checker(
|
|
current_user: dict = Depends(self.get_current_user)
|
|
) -> dict:
|
|
user_role = current_user.get('role')
|
|
|
|
if user_role not in allowed_roles:
|
|
logger.warning(
|
|
f"Access denied for user {current_user.get('username')} "
|
|
f"with role {user_role}. Required roles: {allowed_roles}"
|
|
)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail=f"이 기능을 사용하려면 다음 권한이 필요합니다: {', '.join(allowed_roles)}"
|
|
)
|
|
|
|
return current_user
|
|
|
|
return role_checker
|
|
|
|
def require_permissions(self, required_permissions: List[str]):
|
|
"""
|
|
특정 권한을 요구하는 의존성 함수 생성
|
|
|
|
Args:
|
|
required_permissions: 필요한 권한 목록
|
|
|
|
Returns:
|
|
Callable: 의존성 함수
|
|
"""
|
|
async def permission_checker(
|
|
current_user: dict = Depends(self.get_current_user),
|
|
db: Session = Depends(get_db)
|
|
) -> dict:
|
|
user_role = current_user.get('role')
|
|
|
|
# 사용자 권한 조회
|
|
user_repo = UserRepository(db)
|
|
user_permissions = user_repo.get_user_permissions(user_role)
|
|
|
|
# 필요한 권한 확인
|
|
missing_permissions = []
|
|
for permission in required_permissions:
|
|
if permission not in user_permissions:
|
|
missing_permissions.append(permission)
|
|
|
|
if missing_permissions:
|
|
logger.warning(
|
|
f"Permission denied for user {current_user.get('username')} "
|
|
f"with role {user_role}. Missing permissions: {missing_permissions}"
|
|
)
|
|
raise HTTPException(
|
|
status_code=status.HTTP_403_FORBIDDEN,
|
|
detail=f"이 기능을 사용하려면 다음 권한이 필요합니다: {', '.join(missing_permissions)}"
|
|
)
|
|
|
|
# 사용자 정보에 권한 정보 추가
|
|
current_user['permissions'] = user_permissions
|
|
|
|
return current_user
|
|
|
|
return permission_checker
|
|
|
|
def require_admin(self):
|
|
"""관리자 권한을 요구하는 의존성 함수"""
|
|
return self.require_roles(['admin', 'system'])
|
|
|
|
def require_leader_or_admin(self):
|
|
"""팀장 이상 권한을 요구하는 의존성 함수"""
|
|
return self.require_roles(['admin', 'system', 'leader'])
|
|
|
|
|
|
# 전역 인증 미들웨어 인스턴스
|
|
auth_middleware = AuthMiddleware()
|
|
|
|
# 편의를 위한 의존성 함수들
|
|
get_current_user = auth_middleware.get_current_user
|
|
get_current_active_user = auth_middleware.get_current_active_user
|
|
require_admin = auth_middleware.require_admin
|
|
require_leader_or_admin = auth_middleware.require_leader_or_admin
|
|
|
|
|
|
def require_roles(allowed_roles: List[str]):
|
|
"""역할 기반 접근 제어 데코레이터"""
|
|
return auth_middleware.require_roles(allowed_roles)
|
|
|
|
|
|
def require_permissions(required_permissions: List[str]):
|
|
"""권한 기반 접근 제어 데코레이터"""
|
|
return auth_middleware.require_permissions(required_permissions)
|
|
|
|
|
|
# 추가 유틸리티 함수들
|
|
async def get_user_from_token(token: str, db: Session) -> Optional[dict]:
|
|
"""
|
|
토큰에서 사용자 정보 추출 (미들웨어 없이 직접 사용)
|
|
|
|
Args:
|
|
token: JWT 토큰
|
|
db: 데이터베이스 세션
|
|
|
|
Returns:
|
|
Optional[dict]: 사용자 정보 또는 None
|
|
"""
|
|
try:
|
|
payload = jwt_service.verify_access_token(token)
|
|
user_id = payload['user_id']
|
|
|
|
user_repo = UserRepository(db)
|
|
user = user_repo.find_by_id(user_id)
|
|
|
|
if user and user.is_active and not user.is_locked():
|
|
return user.to_dict()
|
|
|
|
return None
|
|
|
|
except Exception as e:
|
|
logger.error(f"Get user from token error: {str(e)}")
|
|
return None
|
|
|
|
|
|
def check_user_permission(user_role: str, required_permission: str, db: Session) -> bool:
|
|
"""
|
|
사용자 권한 확인
|
|
|
|
Args:
|
|
user_role: 사용자 역할
|
|
required_permission: 필요한 권한
|
|
db: 데이터베이스 세션
|
|
|
|
Returns:
|
|
bool: 권한 보유 여부
|
|
"""
|
|
try:
|
|
user_repo = UserRepository(db)
|
|
user_permissions = user_repo.get_user_permissions(user_role)
|
|
return required_permission in user_permissions
|
|
except Exception as e:
|
|
logger.error(f"Check user permission error: {str(e)}")
|
|
return False
|
|
|
|
|
|
def get_user_permissions_by_role(role: str, db: Session) -> List[str]:
|
|
"""
|
|
역할별 권한 목록 조회
|
|
|
|
Args:
|
|
role: 사용자 역할
|
|
db: 데이터베이스 세션
|
|
|
|
Returns:
|
|
List[str]: 권한 목록
|
|
"""
|
|
try:
|
|
user_repo = UserRepository(db)
|
|
return user_repo.get_user_permissions(role)
|
|
except Exception as e:
|
|
logger.error(f"Get user permissions by role error: {str(e)}")
|
|
return []
|
|
|
|
|
|
# 선택적 인증 (토큰이 있으면 검증, 없으면 None 반환)
|
|
async def get_current_user_optional(
|
|
request: Request,
|
|
db: Session = Depends(get_db)
|
|
) -> Optional[dict]:
|
|
"""
|
|
선택적 사용자 인증 (토큰이 있으면 검증, 없으면 None)
|
|
|
|
Args:
|
|
request: FastAPI Request 객체
|
|
db: 데이터베이스 세션
|
|
|
|
Returns:
|
|
Optional[dict]: 사용자 정보 또는 None
|
|
"""
|
|
try:
|
|
# Authorization 헤더 확인
|
|
authorization = request.headers.get('authorization')
|
|
if not authorization or not authorization.startswith('Bearer '):
|
|
return None
|
|
|
|
token = authorization.split(' ')[1]
|
|
return await get_user_from_token(token, db)
|
|
|
|
except Exception as e:
|
|
logger.debug(f"Optional auth failed: {str(e)}")
|
|
return None
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|