Merge branch '77-refactor-to-use-a-more-traditional-crud-module-structure' into 89-use-inheritance-to-define-data-models

Author: chriscarrollsmith

main.py

@@ -5,21 +5,16 @@
 from fastapi.responses import RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from fastapi.exceptions import RequestValidationError, HTTPException, StarletteHTTPException
-from sqlmodel import Session
-from routers import authentication, organization, role, user
+from fastapi.exceptions import RequestValidationError, StarletteHTTPException
+from routers import authentication, organization, role, user, dashboard, terms_of_service, privacy_policy, about
 from utils.auth import (
-    HTML_PASSWORD_PATTERN,
-    get_user_with_relations,
-    get_optional_user,
     NeedsNewTokens,
-    get_user_from_reset_token,
     PasswordValidationError,
-    AuthenticationError
+    AuthenticationError,
+    get_optional_user
 )
+from utils.db import set_up_db
 from utils.models import User
-from utils.db import get_session, set_up_db
-from utils.images import MAX_FILE_SIZE, MIN_DIMENSION, MAX_DIMENSION, ALLOWED_CONTENT_TYPES
 
 logger = logging.getLogger("uvicorn.error")
 logger.setLevel(logging.DEBUG)
@@ -33,23 +28,35 @@ async def lifespan(app: FastAPI):
     # Optional shutdown logic
 
 
+# Initialize the FastAPI app
 app: FastAPI = FastAPI(lifespan=lifespan)
 
-# Mount static files (e.g., CSS, JS)
+# Mount static files (e.g., CSS, JS) and initialize Jinja2 templates
 app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Initialize Jinja2 templates
 templates = Jinja2Templates(directory="templates")
 
 
+# --- Include Routers ---
+
+
+app.include_router(authentication.router)
+app.include_router(organization.router)
+app.include_router(role.router)
+app.include_router(user.router)
+app.include_router(dashboard.router)
+app.include_router(terms_of_service.router)
+app.include_router(privacy_policy.router)
+app.include_router(about.router)
+
+
 # --- Exception Handling Middlewares ---
 
 
 # Handle AuthenticationError by redirecting to login page
 @app.exception_handler(AuthenticationError)
 async def authentication_error_handler(request: Request, exc: AuthenticationError):
     return RedirectResponse(
-        url="/login",
+        url=app.url_path_for("read_login"),
         status_code=status.HTTP_303_SEE_OTHER
     )
 
@@ -146,160 +153,21 @@ async def general_exception_handler(request: Request, exc: Exception):
     )
 
 
-# --- Unauthenticated Routes ---
-
-
-# Define a dependency for common parameters
-async def common_unauthenticated_parameters(
-    request: Request,
-    user: Optional[User] = Depends(get_optional_user),
-    error_message: Optional[str] = None,
-) -> dict:
-    return {"request": request, "user": user, "error_message": error_message}
+# --- Home Page ---
 
 
 @app.get("/")
 async def read_home(
-    params: dict = Depends(common_unauthenticated_parameters)
-):
-    if params["user"]:
-        return RedirectResponse(url="/dashboard", status_code=302)
-    return templates.TemplateResponse(params["request"], "index.html", params)
-
-
-@app.get("/login")
-async def read_login(
-    params: dict = Depends(common_unauthenticated_parameters),
-    email_updated: Optional[str] = "false"
-):
-    if params["user"]:
-        return RedirectResponse(url="/dashboard", status_code=302)
-    params["email_updated"] = email_updated
-    return templates.TemplateResponse(params["request"], "authentication/login.html", params)
-
-
-@app.get("/register")
-async def read_register(
-    params: dict = Depends(common_unauthenticated_parameters)
-):
-    if params["user"]:
-        return RedirectResponse(url="/dashboard", status_code=302)
-
-    params["password_pattern"] = HTML_PASSWORD_PATTERN
-    return templates.TemplateResponse(params["request"], "authentication/register.html", params)
-
-
-@app.get("/forgot_password")
-async def read_forgot_password(
-    params: dict = Depends(common_unauthenticated_parameters),
-    show_form: Optional[str] = "true",
-):
-    params["show_form"] = show_form == "true"
-
-    return templates.TemplateResponse(params["request"], "authentication/forgot_password.html", params)
-
-
-@app.get("/about")
-async def read_about(params: dict = Depends(common_unauthenticated_parameters)):
-    return templates.TemplateResponse(params["request"], "about.html", params)
-
-
-@app.get("/privacy_policy")
-async def read_privacy_policy(params: dict = Depends(common_unauthenticated_parameters)):
-    return templates.TemplateResponse(params["request"], "privacy_policy.html", params)
-
-
-@app.get("/terms_of_service")
-async def read_terms_of_service(params: dict = Depends(common_unauthenticated_parameters)):
-    return templates.TemplateResponse(params["request"], "terms_of_service.html", params)
-
-
-@app.get("/auth/reset_password")
-async def read_reset_password(
-    email: str,
-    token: str,
-    params: dict = Depends(common_unauthenticated_parameters),
-    session: Session = Depends(get_session)
-):
-    authorized_user, _ = get_user_from_reset_token(email, token, session)
-
-    # Raise informative error to let user know the token is invalid and may have expired
-    if not authorized_user:
-        raise HTTPException(status_code=400, detail="Invalid or expired token")
-
-    params["email"] = email
-    params["token"] = token
-    params["password_pattern"] = HTML_PASSWORD_PATTERN
-
-    return templates.TemplateResponse(params["request"], "authentication/reset_password.html", params)
-
-
-# --- Authenticated Routes ---
-
-
-# Define a dependency for common parameters
-async def common_authenticated_parameters(
     request: Request,
-    user: User = Depends(get_user_with_relations),
-    error_message: Optional[str] = None
-) -> dict:
-    return {"request": request, "user": user, "error_message": error_message}
-
-
-# Redirect to home if user is not authenticated
-@app.get("/dashboard")
-async def read_dashboard(
-    params: dict = Depends(common_authenticated_parameters)
+    user: Optional[User] = Depends(get_optional_user)
 ):
-    return templates.TemplateResponse(params["request"], "dashboard/index.html", params)
-
-
-@app.get("/profile")
-async def read_profile(
-    params: dict = Depends(common_authenticated_parameters),
-    email_update_requested: Optional[str] = "false",
-    email_updated: Optional[str] = "false"
-):
-    # Add image constraints to the template context
-    params.update({
-        "max_file_size_mb": MAX_FILE_SIZE / (1024 * 1024),  # Convert bytes to MB
-        "min_dimension": MIN_DIMENSION,
-        "max_dimension": MAX_DIMENSION,
-        "allowed_formats": list(ALLOWED_CONTENT_TYPES.keys()),
-        "email_update_requested": email_update_requested,
-        "email_updated": email_updated
-    })
-    return templates.TemplateResponse(params["request"], "users/profile.html", params)
-
-
-@app.get("/organizations/{org_id}")
-async def read_organization(
-    org_id: int,
-    params: dict = Depends(common_authenticated_parameters)
-):
-    # Get the organization only if the user is a member of it
-    org = next(
-        (org for org in params["user"].organizations if org.id == org_id),
-        None
+    if user:
+        return RedirectResponse(url="/dashboard", status_code=302)
+    return templates.TemplateResponse(
+        "index.html",
+        {"request": request, "user": user}
     )
-    if not org:
-        raise organization.OrganizationNotFoundError()
-
-    # Eagerly load roles and users
-    org.roles
-    org.users
-    params["organization"] = org
-
-    return templates.TemplateResponse(params["request"], "users/organization.html", params)
-
 
-# --- Include Routers ---
-
-
-app.include_router(authentication.router)
-app.include_router(organization.router)
-app.include_router(role.router)
-app.include_router(user.router)
 
 if __name__ == "__main__":
     import uvicorn

routers/about.py

@@ -0,0 +1,18 @@
+from typing import Optional
+from fastapi import APIRouter, Depends, Request
+from fastapi.templating import Jinja2Templates
+from utils.auth import get_optional_user
+from utils.models import User
+
+router = APIRouter(prefix="/about", tags=["about"])
+templates = Jinja2Templates(directory="templates")
+
+@router.get("/")
+async def read_about(
+    request: Request,
+    user: Optional[User] = Depends(get_optional_user)
+):
+    return templates.TemplateResponse(
+        "about.html", 
+        {"request": request, "user": user}
+    )

routers/account.py

@@ -5,11 +5,13 @@
 from datetime import datetime
 from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks, Form, Request
 from fastapi.responses import RedirectResponse
+from fastapi.templating import Jinja2Templates
 from pydantic import BaseModel, EmailStr, ConfigDict
 from sqlmodel import Session, select
-from utils.models import AccountBase, Account, DataIntegrityError, User
+from utils.models import User, Account, DataIntegrityError, User
+from utils.db import get_session
 from utils.auth import (
-    get_session,
+    HTML_PASSWORD_PATTERN,
     get_user_from_reset_token,
     create_password_validator,
     create_passwords_match_validator,
@@ -23,12 +25,14 @@
     send_email_update_confirmation,
     get_user_from_email_update_token,
     get_authenticated_user,
-    PasswordValidationError
+    PasswordValidationError,
+    get_optional_user
 )
 
 logger = getLogger("uvicorn.error")
 
 router = APIRouter(prefix="/account", tags=["account"])
+templates = Jinja2Templates(directory="templates")
 
 # --- Custom Exceptions ---
 
@@ -52,7 +56,7 @@ def __init__(self, message: str = "Invalid credentials"):
 # --- Server Request and Response Models ---
 
 
-class DeleteAccount(AccountBase):
+class DeleteAccount(Account):
     @classmethod
     async def as_form(
         cls,
@@ -62,7 +66,7 @@ async def as_form(
         return cls(email=email, password=password)
 
 
-class CreateAccount(AccountBase):
+class CreateAccount(Account):
     name: str
     password: str
     confirm_password: str
@@ -187,6 +191,67 @@ async def delete_account(
 
     # Log out the user
     return RedirectResponse(url="/auth/logout", status_code=303)
+@router.get("/login")
+async def read_login(
+    request: Request,
+    user: Optional[User] = Depends(get_optional_user),
+    email_updated: Optional[str] = "false"
+):
+    if user:
+        return RedirectResponse(url="/dashboard", status_code=302)
+    return templates.TemplateResponse(
+        "authentication/login.html",
+        {"request": request, "user": user, "email_updated": email_updated}
+    )
+
+
+@router.get("/register")
+async def read_register(
+    request: Request,
+    user: Optional[User] = Depends(get_optional_user)
+):
+    if user:
+        return RedirectResponse(url="/dashboard", status_code=302)
+
+    return templates.TemplateResponse(
+        "authentication/register.html",
+        {"request": request, "user": user}
+    )
+
+
+@router.get("/forgot_password")
+async def read_forgot_password(
+    request: Request,
+    user: Optional[User] = Depends(get_optional_user),
+    show_form: Optional[str] = "true",
+):
+    if user:
+        return RedirectResponse(url="/dashboard", status_code=302)
+
+    return templates.TemplateResponse(
+        "authentication/forgot_password.html",
+        {"request": request, "user": user, "show_form": show_form == "true"}
+    )
+
+
+@router.get("/reset_password")
+async def read_reset_password(
+    request: Request,
+    email: str,
+    token: str,
+    user: Optional[User] = Depends(get_optional_user),
+    session: Session = Depends(get_session)
+):
+    authorized_user, _ = get_user_from_reset_token(email, token, session)
+
+    # Raise informative error to let user know the token is invalid and may have expired
+    if not authorized_user:
+        raise HTTPException(status_code=400, detail="Invalid or expired token")
+
+    return templates.TemplateResponse(
+        "authentication/reset_password.html",
+        {"request": request, "user": user, "email": email, "token": token, "password_pattern": HTML_PASSWORD_PATTERN}
+    )
 
 
 # TODO: Use custom error message in the case where the user is already registered

routers/dashboard.py

@@ -0,0 +1,22 @@
+from typing import Optional
+from fastapi import APIRouter, Depends, Request
+from fastapi.templating import Jinja2Templates
+from utils.auth import get_user_with_relations
+from utils.models import User
+
+router = APIRouter(prefix="/dashboard", tags=["dashboard"])
+templates = Jinja2Templates(directory="templates")
+
+
+# --- Authenticated Routes ---
+
+
+@router.get("/")
+async def read_dashboard(
+    request: Request,
+    user: Optional[User] = Depends(get_user_with_relations)
+):
+    return templates.TemplateResponse(
+        "dashboard/index.html",
+        {"request": request, "user": user}
+    )