new api service and logic implemented
This commit is contained in:
14
ApiLayers/AllApiNeeds/middleware/__init__.py
Normal file
14
ApiLayers/AllApiNeeds/middleware/__init__.py
Normal file
@@ -0,0 +1,14 @@
|
||||
from .token_event_middleware import TokenEventMiddleware
|
||||
from .auth_middleware import (
|
||||
LoggerTimingMiddleware,
|
||||
RequestTimingMiddleware,
|
||||
MiddlewareModule,
|
||||
)
|
||||
|
||||
|
||||
__all__ = [
|
||||
"TokenEventMiddleware",
|
||||
"RequestTimingMiddleware",
|
||||
"MiddlewareModule",
|
||||
"LoggerTimingMiddleware",
|
||||
]
|
||||
162
ApiLayers/AllApiNeeds/middleware/auth_middleware.py
Normal file
162
ApiLayers/AllApiNeeds/middleware/auth_middleware.py
Normal file
@@ -0,0 +1,162 @@
|
||||
"""
|
||||
Authentication and Authorization middleware for FastAPI applications.
|
||||
|
||||
This module provides authentication decorator for protecting endpoints
|
||||
and a middleware for request timing measurements.
|
||||
"""
|
||||
|
||||
from time import perf_counter
|
||||
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 ApiLibrary.common.line_number import get_line_number_for_error
|
||||
from ErrorHandlers.ErrorHandlers.api_exc_handler import HTTPExceptionApi
|
||||
from AllConfigs.Token.config import Auth
|
||||
import inspect
|
||||
|
||||
|
||||
class MiddlewareModule:
|
||||
"""
|
||||
Middleware module for handling authentication and request timing.
|
||||
"""
|
||||
|
||||
@staticmethod
|
||||
def get_user_from_request(
|
||||
request: Request,
|
||||
) -> dict:
|
||||
"""
|
||||
Get authenticated token context from request.
|
||||
|
||||
Args:
|
||||
request: FastAPI request object
|
||||
|
||||
Returns:
|
||||
AuthContext: Context containing the authenticated token data
|
||||
|
||||
Raises:
|
||||
HTTPExceptionApi: If token is missing, invalid, or user not found
|
||||
"""
|
||||
from ApiServices.Token.token_handler import TokenService
|
||||
|
||||
# Get token and validate - will raise HTTPExceptionApi if invalid
|
||||
redis_token = TokenService.get_access_token_from_request(request=request)
|
||||
# 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(),
|
||||
sys_msg="TokenService: Token Context couldnt retrieved from redis",
|
||||
)
|
||||
|
||||
return token_context
|
||||
|
||||
@classmethod
|
||||
def auth_required(cls, func: Callable) -> Callable:
|
||||
"""
|
||||
Decorator for protecting FastAPI endpoints with authentication.
|
||||
|
||||
Usage:
|
||||
@router.get("/protected")
|
||||
@MiddlewareModule.auth_required
|
||||
async def protected_endpoint(request: Request):
|
||||
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)
|
||||
async def wrapper(request: Request, *args, **kwargs):
|
||||
# Get and validate token context from request
|
||||
# Create auth context and Attach auth context to both wrapper and original function
|
||||
func.auth = cls.get_user_from_request(request)
|
||||
wrapper.auth = func.auth
|
||||
# Call the original endpoint function
|
||||
if inspect.iscoroutinefunction(func):
|
||||
return await func(request, *args, **kwargs)
|
||||
return func(request, *args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
|
||||
|
||||
class RequestTimingMiddleware(BaseHTTPMiddleware):
|
||||
"""
|
||||
Middleware for measuring and logging request timing.
|
||||
Only handles timing, no authentication.
|
||||
"""
|
||||
|
||||
async def dispatch(self, request: Request, call_next: Callable) -> Response:
|
||||
"""
|
||||
Process each request through the middleware.
|
||||
|
||||
Args:
|
||||
request: FastAPI request object
|
||||
call_next: Next middleware in the chain
|
||||
|
||||
Returns:
|
||||
Response: Processed response with timing headers
|
||||
"""
|
||||
start_time = perf_counter()
|
||||
# Process the request
|
||||
response = await call_next(request)
|
||||
|
||||
# Add timing information to response headers
|
||||
end_time = perf_counter()
|
||||
elapsed = (end_time - start_time) * 1000 # Convert to milliseconds
|
||||
|
||||
response.headers.update(
|
||||
{
|
||||
"request-start": f"{start_time:.6f}",
|
||||
"request-end": f"{end_time:.6f}",
|
||||
"request-duration": f"{elapsed:.2f}ms",
|
||||
}
|
||||
)
|
||||
|
||||
return response
|
||||
|
||||
|
||||
class LoggerTimingMiddleware(BaseHTTPMiddleware):
|
||||
"""
|
||||
Middleware for measuring and logging request timing.
|
||||
Only handles timing, no authentication.
|
||||
"""
|
||||
|
||||
async def dispatch(self, request: Request, call_next: Callable) -> Response:
|
||||
# Log the request
|
||||
import arrow
|
||||
|
||||
headers = dict(request.headers)
|
||||
response = await call_next(request)
|
||||
# Log the response
|
||||
print(
|
||||
"Loggers :",
|
||||
{
|
||||
"url": request.url,
|
||||
"method": request.method,
|
||||
"access_token": headers.get(Auth.ACCESS_TOKEN_TAG, ""),
|
||||
"referer": headers.get("referer", ""),
|
||||
"origin": headers.get("origin", ""),
|
||||
"user-agent": headers.get("user-agent", ""),
|
||||
"datetime": arrow.now().format("YYYY-MM-DD HH:mm:ss ZZ"),
|
||||
"status_code": response.status_code,
|
||||
},
|
||||
)
|
||||
return response
|
||||
297
ApiLayers/AllApiNeeds/middleware/token_event_middleware.py
Normal file
297
ApiLayers/AllApiNeeds/middleware/token_event_middleware.py
Normal file
@@ -0,0 +1,297 @@
|
||||
"""
|
||||
Token event middleware for handling authentication and event tracking.
|
||||
"""
|
||||
|
||||
import inspect
|
||||
|
||||
from functools import wraps
|
||||
from typing import Callable, Dict, Any, Optional, Union
|
||||
from fastapi import Request
|
||||
from pydantic import BaseModel
|
||||
|
||||
from ApiLibrary.common.line_number import get_line_number_for_error
|
||||
from ApiServices.Token.token_handler import TokenService
|
||||
from ErrorHandlers.Exceptions.api_exc import HTTPExceptionApi
|
||||
from Schemas.rules.rules import EndpointRestriction
|
||||
|
||||
from .auth_middleware import MiddlewareModule
|
||||
from Schemas import Events
|
||||
|
||||
|
||||
class EventFunctions:
|
||||
|
||||
def __init__(self, endpoint: str, request: Request):
|
||||
self.endpoint = endpoint
|
||||
self.request = request
|
||||
|
||||
def match_endpoint_with_accesiable_event(self) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Match an endpoint with accessible events.
|
||||
|
||||
Args:
|
||||
endpoint: The endpoint to match
|
||||
|
||||
Returns:
|
||||
Dict containing the endpoint registration data
|
||||
None if endpoint is not found in database
|
||||
"""
|
||||
access_token = TokenService.get_access_token_from_request(self.request)
|
||||
token_context = TokenService.get_object_via_access_key(
|
||||
access_token=access_token
|
||||
)
|
||||
if token_context.is_employee:
|
||||
reachable_event_codes: list[str] = (
|
||||
token_context.selected_company.reachable_event_codes
|
||||
)
|
||||
elif token_context.is_occupant:
|
||||
reachable_event_codes: list[str] = (
|
||||
token_context.selected_occupant.reachable_event_codes
|
||||
)
|
||||
else:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Token not found",
|
||||
)
|
||||
|
||||
if not access_token:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Token not found",
|
||||
)
|
||||
|
||||
db = EndpointRestriction.new_session()
|
||||
restriction = EndpointRestriction.filter_one(
|
||||
EndpointRestriction.endpoint_name == self.endpoint,
|
||||
db=db,
|
||||
).data
|
||||
if not restriction:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Function code not found",
|
||||
)
|
||||
|
||||
event_related = Events.filter_all(
|
||||
Events.endpoint_id == restriction.id,
|
||||
db=db,
|
||||
).data
|
||||
if not event_related:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="No event is registered for this user.",
|
||||
)
|
||||
an_event = event_related[0]
|
||||
event_related_codes: list[str] = [
|
||||
event.function_code for event in event_related
|
||||
]
|
||||
intersected_code: set = set(reachable_event_codes).intersection(
|
||||
set(event_related_codes)
|
||||
)
|
||||
if not len(list(intersected_code)) == 1:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="No event is registered for this user.",
|
||||
)
|
||||
return {
|
||||
"endpoint_url": self.endpoint,
|
||||
"reachable_event_code": list(intersected_code)[0],
|
||||
"class": an_event.function_class,
|
||||
}
|
||||
|
||||
def retrieve_function_dict(self) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Retrieve function dictionary for a given endpoint.
|
||||
|
||||
Args:
|
||||
endpoint: The endpoint to retrieve the function dictionary for
|
||||
|
||||
Returns:
|
||||
Dictionary containing the function dictionary
|
||||
None if endpoint is not found
|
||||
"""
|
||||
access_token = TokenService.get_access_token_from_request(self.request)
|
||||
token_context = TokenService.get_object_via_access_key(
|
||||
access_token=access_token
|
||||
)
|
||||
if token_context.is_employee:
|
||||
reachable_event_codes: list[str] = (
|
||||
token_context.selected_company.reachable_event_codes
|
||||
)
|
||||
elif token_context.is_occupant:
|
||||
reachable_event_codes: list[str] = (
|
||||
token_context.selected_occupant.reachable_event_codes
|
||||
)
|
||||
else:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Token not found",
|
||||
)
|
||||
|
||||
if not access_token:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Token not found",
|
||||
)
|
||||
|
||||
db = EndpointRestriction.new_session()
|
||||
restriction = EndpointRestriction.filter_one(
|
||||
EndpointRestriction.endpoint_name == self.endpoint,
|
||||
db=db,
|
||||
).data
|
||||
if not restriction:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Function code not found",
|
||||
)
|
||||
|
||||
event_related = Events.filter_all(
|
||||
Events.endpoint_id == restriction.id,
|
||||
db=db,
|
||||
).data
|
||||
if not event_related:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="No event is registered for this user.",
|
||||
)
|
||||
an_event = event_related[0]
|
||||
event_related_codes: list[str] = [
|
||||
event.function_code for event in event_related
|
||||
]
|
||||
intersected_code: set = set(reachable_event_codes).intersection(
|
||||
set(event_related_codes)
|
||||
)
|
||||
if not len(list(intersected_code)) == 1:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="No event is registered for this user.",
|
||||
)
|
||||
return {
|
||||
"endpoint_url": self.endpoint,
|
||||
"reachable_event_code": list(intersected_code)[0],
|
||||
"class": an_event.function_class,
|
||||
}
|
||||
|
||||
|
||||
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)
|
||||
authenticated_func = func
|
||||
|
||||
@wraps(authenticated_func)
|
||||
async def wrapper(request: Request, *args, **kwargs) -> Dict[str, Any]:
|
||||
|
||||
# Get function code from the function's metadata
|
||||
endpoint_url = getattr(authenticated_func, "url_of_endpoint", {})
|
||||
if not endpoint_url:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Function code not found",
|
||||
)
|
||||
|
||||
# Make handler available to all functions in the chain
|
||||
func.func_code = EventFunctions(
|
||||
endpoint_url, request
|
||||
).match_endpoint_with_accesiable_event()
|
||||
# Call the authenticated function
|
||||
if inspect.iscoroutinefunction(authenticated_func):
|
||||
return await authenticated_func(request, *args, **kwargs)
|
||||
return authenticated_func(request, *args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
|
||||
@staticmethod
|
||||
def validation_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)
|
||||
async def wrapper(
|
||||
request: Request, *args: Any, **kwargs: Any
|
||||
) -> Union[Dict[str, Any], BaseModel]:
|
||||
# Handle both async and sync functions
|
||||
endpoint_asked = getattr(kwargs.get("data", None), "data", None).get(
|
||||
"endpoint", None
|
||||
)
|
||||
if not endpoint_asked:
|
||||
raise HTTPExceptionApi(
|
||||
error_code="",
|
||||
lang="en",
|
||||
loc=get_line_number_for_error(),
|
||||
sys_msg="Endpoint not found",
|
||||
)
|
||||
wrapper.validation_code = EventFunctions(
|
||||
endpoint_asked, request
|
||||
).retrieve_function_dict()
|
||||
if inspect.iscoroutinefunction(authenticated_func):
|
||||
result = await authenticated_func(request, *args, **kwargs)
|
||||
else:
|
||||
result = authenticated_func(request, *args, **kwargs)
|
||||
function_auth = getattr(authenticated_func, "auth", None)
|
||||
wrapper.auth = function_auth
|
||||
func.auth = function_auth
|
||||
authenticated_func.auth = function_auth
|
||||
# If result is a coroutine, await it
|
||||
if inspect.iscoroutine(result):
|
||||
result = await result
|
||||
return result
|
||||
|
||||
return wrapper
|
||||
Reference in New Issue
Block a user