update events via wrapper routers
This commit is contained in:
@@ -1 +1,5 @@
|
||||
from .token_event_middleware import TokenEventMiddleware
|
||||
from .auth_middleware import RequestTimingMiddleware, MiddlewareModule
|
||||
|
||||
|
||||
__all__ = ["TokenEventMiddleware", "RequestTimingMiddleware", "MiddlewareModule"]
|
||||
|
||||
@@ -6,70 +6,83 @@ and a middleware for request timing measurements.
|
||||
"""
|
||||
|
||||
from time import perf_counter
|
||||
from typing import Callable, Optional, Dict, Any, Tuple
|
||||
from typing import Callable, Optional, Dict, Any, Tuple, Union
|
||||
from functools import wraps
|
||||
from fastapi import Request, Response
|
||||
from starlette.middleware.base import BaseHTTPMiddleware
|
||||
from fastapi import Request, Response
|
||||
from AllConfigs.Token.config import Auth
|
||||
from ApiLibrary.common.line_number import get_line_number_for_error
|
||||
from ErrorHandlers.ErrorHandlers.api_exc_handler import HTTPExceptionApi
|
||||
from .base_context import BaseContext
|
||||
from ApiServices.Token.token_handler import OccupantTokenObject, EmployeeTokenObject
|
||||
|
||||
|
||||
class AuthContext(BaseContext):
|
||||
"""
|
||||
Context class for authentication middleware.
|
||||
Extends BaseContext to provide authentication-specific functionality.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self, token_context: Union[OccupantTokenObject, EmployeeTokenObject]
|
||||
) -> None:
|
||||
super().__init__()
|
||||
self.token_context = token_context
|
||||
|
||||
@property
|
||||
def is_employee(self) -> bool:
|
||||
"""Check if authenticated token is for an employee."""
|
||||
return isinstance(self.token_context, EmployeeTokenObject)
|
||||
|
||||
@property
|
||||
def is_occupant(self) -> bool:
|
||||
"""Check if authenticated token is for an occupant."""
|
||||
return isinstance(self.token_context, OccupantTokenObject)
|
||||
|
||||
@property
|
||||
def user_id(self) -> str:
|
||||
"""Get the user's UUID from token context."""
|
||||
return self.token_context.user_uu_id if self.token_context else ""
|
||||
|
||||
def __repr__(self) -> str:
|
||||
user_type = "Employee" if self.is_employee else "Occupant"
|
||||
return f"AuthContext({user_type}Token: {self.user_id})"
|
||||
|
||||
|
||||
class MiddlewareModule:
|
||||
"""
|
||||
Module containing authentication and middleware functionality.
|
||||
|
||||
This class provides:
|
||||
- Token extraction and validation
|
||||
- Authentication decorator for endpoints
|
||||
Middleware module for handling authentication and request timing.
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def get_access_token(request: Request) -> Tuple[str, str]:
|
||||
def get_user_from_request(
|
||||
request: Request,
|
||||
) -> AuthContext:
|
||||
"""
|
||||
Extract access token from request headers.
|
||||
Get authenticated token context from request.
|
||||
|
||||
Args:
|
||||
request: FastAPI request object
|
||||
|
||||
Returns:
|
||||
Tuple[str, str]: A tuple containing (scheme, token)
|
||||
AuthContext: Context containing the authenticated token data
|
||||
|
||||
Raises:
|
||||
HTTPExceptionApi: If token is missing or malformed
|
||||
HTTPExceptionApi: If token is missing, invalid, or user not found
|
||||
"""
|
||||
auth_header = request.headers.get(Auth.ACCESS_TOKEN_TAG)
|
||||
if not auth_header:
|
||||
raise HTTPExceptionApi(error_code="HTTP_401_UNAUTHORIZED", lang="tr")
|
||||
from ApiServices.Token.token_handler import TokenService
|
||||
|
||||
try:
|
||||
scheme, token = auth_header.split()
|
||||
if scheme.lower() != "bearer":
|
||||
raise HTTPExceptionApi(error_code="HTTP_401_UNAUTHORIZED", lang="tr")
|
||||
return scheme, token
|
||||
except ValueError:
|
||||
raise HTTPExceptionApi(error_code="HTTP_401_UNAUTHORIZED", lang="tr")
|
||||
# Get token and validate - will raise HTTPExceptionApi if invalid
|
||||
redis_token = TokenService.get_access_token_from_request(request=request)
|
||||
|
||||
@staticmethod
|
||||
async def validate_token(token: str) -> Dict[str, Any]:
|
||||
"""
|
||||
Validate the authentication token.
|
||||
# Get token context - will validate token and raise appropriate errors
|
||||
token_context = TokenService.get_object_via_access_key(access_token=redis_token)
|
||||
if not token_context:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="USER_NOT_FOUND", lang="tr", loc=get_line_number_for_error()
|
||||
)
|
||||
|
||||
Args:
|
||||
token: JWT token to validate
|
||||
|
||||
Returns:
|
||||
Dict[str, Any]: User data extracted from token
|
||||
|
||||
Raises:
|
||||
HTTPExceptionApi: If token is invalid
|
||||
"""
|
||||
try:
|
||||
# TODO: Implement your token validation logic
|
||||
# Example:
|
||||
# return jwt.decode(token, settings.SECRET_KEY, algorithms=["HS256"])
|
||||
return {"user_id": "test", "role": "user"} # Placeholder
|
||||
except Exception as e:
|
||||
raise HTTPExceptionApi(error_code="HTTP_401_UNAUTHORIZED", lang="tr")
|
||||
return AuthContext(token_context=token_context)
|
||||
|
||||
@classmethod
|
||||
def auth_required(cls, func: Callable) -> Callable:
|
||||
@@ -80,30 +93,36 @@ class MiddlewareModule:
|
||||
@router.get("/protected")
|
||||
@MiddlewareModule.auth_required
|
||||
async def protected_endpoint(request: Request):
|
||||
user = request.state.user # Access authenticated user data
|
||||
return {"message": "Protected content"}
|
||||
|
||||
@router.get("/public") # No decorator = public endpoint
|
||||
async def public_endpoint():
|
||||
return {"message": "Public content"}
|
||||
auth = protected_endpoint.auth # Access auth context
|
||||
if auth.is_employee:
|
||||
# Handle employee logic
|
||||
employee_id = auth.token_context.employee_id
|
||||
else:
|
||||
# Handle occupant logic
|
||||
occupant_id = auth.token_context.occupant_id
|
||||
return {"user_id": auth.user_id}
|
||||
|
||||
Args:
|
||||
func: The FastAPI route handler function to protect
|
||||
|
||||
Returns:
|
||||
Callable: Wrapped function that checks authentication before execution
|
||||
|
||||
Raises:
|
||||
HTTPExceptionApi: If authentication fails
|
||||
"""
|
||||
|
||||
@wraps(func)
|
||||
def wrapper(request: Request, *args, **kwargs):
|
||||
from ApiServices import TokenService
|
||||
# Get token from header
|
||||
# token = TokenService.get_access_token_from_request(request=request)
|
||||
# print(token)
|
||||
# if not token:
|
||||
# raise HTTPExceptionApi(error_code="NOT_AUTHORIZED", lang="tr")
|
||||
# Get and validate token context from request
|
||||
auth_context = cls.get_user_from_request(request)
|
||||
|
||||
# Attach auth context to function
|
||||
func.auth = auth_context
|
||||
|
||||
# Call the original endpoint function
|
||||
return func(request, *args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
|
||||
47
DockerApiServices/AllApiNeeds/middleware/base_context.py
Normal file
47
DockerApiServices/AllApiNeeds/middleware/base_context.py
Normal file
@@ -0,0 +1,47 @@
|
||||
"""Base context for middleware."""
|
||||
|
||||
from typing import Optional, Dict, Any, Union, TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from ApiServices.Token.token_handler import OccupantTokenObject, EmployeeTokenObject
|
||||
|
||||
|
||||
class BaseContext:
|
||||
"""Base context class for middleware."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._token_context: Optional[
|
||||
Union["OccupantTokenObject", "EmployeeTokenObject"]
|
||||
] = None
|
||||
self._function_code: Optional[str] = None
|
||||
|
||||
@property
|
||||
def token_context(
|
||||
self,
|
||||
) -> Optional[Union["OccupantTokenObject", "EmployeeTokenObject"]]:
|
||||
"""Get token context if available."""
|
||||
return self._token_context
|
||||
|
||||
@token_context.setter
|
||||
def token_context(
|
||||
self, value: Union["OccupantTokenObject", "EmployeeTokenObject"]
|
||||
) -> None:
|
||||
"""Set token context."""
|
||||
self._token_context = value
|
||||
|
||||
@property
|
||||
def function_code(self) -> Optional[str]:
|
||||
"""Get function code if available."""
|
||||
return self._function_code
|
||||
|
||||
@function_code.setter
|
||||
def function_code(self, value: str) -> None:
|
||||
"""Set function code."""
|
||||
self._function_code = value
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Convert context to dictionary."""
|
||||
return {
|
||||
"token_context": self._token_context,
|
||||
"function_code": self._function_code,
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
"""
|
||||
Token event middleware for handling authentication and event tracking.
|
||||
"""
|
||||
|
||||
from functools import wraps
|
||||
from typing import Callable, Dict, Any
|
||||
from .auth_middleware import MiddlewareModule
|
||||
from .base_context import BaseContext
|
||||
|
||||
|
||||
class TokenEventHandler(BaseContext):
|
||||
"""Handler for token events with authentication context."""
|
||||
|
||||
def __init__(self, func: Callable, url_of_endpoint: str):
|
||||
"""Initialize the handler with function and URL."""
|
||||
super().__init__()
|
||||
self.func = func
|
||||
self.url_of_endpoint = url_of_endpoint
|
||||
|
||||
def update_context(self, function_code: str):
|
||||
"""Update the event context with function code."""
|
||||
self.function_code = function_code
|
||||
|
||||
|
||||
class TokenEventMiddleware:
|
||||
"""
|
||||
Module containing token and event handling functionality.
|
||||
|
||||
This class provides:
|
||||
- Token and event context management
|
||||
- Event validation decorator for endpoints
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def event_required(
|
||||
func: Callable[..., Dict[str, Any]]
|
||||
) -> Callable[..., Dict[str, Any]]:
|
||||
"""
|
||||
Decorator for endpoints with token and event requirements.
|
||||
This decorator:
|
||||
1. First validates authentication using MiddlewareModule.auth_required
|
||||
2. Then adds event tracking context
|
||||
|
||||
Args:
|
||||
func: The function to be decorated
|
||||
|
||||
Returns:
|
||||
Callable: The wrapped function with both auth and event handling
|
||||
"""
|
||||
# First apply authentication
|
||||
authenticated_func = MiddlewareModule.auth_required(func)
|
||||
|
||||
@wraps(authenticated_func)
|
||||
def wrapper(*args, **kwargs) -> Dict[str, Any]:
|
||||
# Create handler with context
|
||||
handler = TokenEventHandler(
|
||||
func=authenticated_func,
|
||||
url_of_endpoint=authenticated_func.url_of_endpoint,
|
||||
)
|
||||
|
||||
# Update event-specific context
|
||||
handler.update_context(
|
||||
function_code="7192c2aa-5352-4e36-98b3-dafb7d036a3d" # Keep function_code as URL
|
||||
)
|
||||
|
||||
# Copy auth context from authenticated function
|
||||
if hasattr(authenticated_func, "auth"):
|
||||
handler.token_context = authenticated_func.auth.token_context
|
||||
|
||||
# Make handler available to the function
|
||||
authenticated_func.handler = handler
|
||||
|
||||
# Call the authenticated function
|
||||
return authenticated_func(*args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
Reference in New Issue
Block a user