included frontend code

Author: sierrawelsch

backend/.pre-commit-config.yaml

@@ -0,0 +1,12 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.8.0
+    hooks:
+      - id: black
+        args: [--line-length=100, backend]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.9
+    hooks:
+      - id: ruff
+        args: [--fix, backend]

backend/README.md

@@ -10,14 +10,14 @@
 8. Set the values for the variables ```MONGODB_URL``` (should be the connection string with <db_password> replaced by the password that Sierra will give you) and ```ACCESS_TOKEN_EXPIRE_MINUTES``` (300 is fine for now)
 9. Run ```python run.py```
 10. Install Postman
-11. Make a new tab, and send a GET request to ```http://localhost:8080/health``` and ensure that the returned result is ```{
-    "status": "ok",
-    "message": "API is running"
-}```
+11. Make a new tab, and send a GET request to ```http://localhost:8080/health``` and ensure that the returned result is ```{ "status": "ok", "message": "API is running" }```
 12. Make a MongoDB account and get Sierra to add you to the list of users by providing you an email
+13. Run ```pre-commit install```
 
 # Software Bootcamp Onboarding
 
 1. Checkout the API endpoints in the ```persons``` controller using Postman
 2. Hit the ```/new``` endpoint to add yourself to the DB!
-3. Sign into your MongoDB account or connect to MongoDB via VSCode in the browser and verify that your name appears in the collection!
+3. Sign into your MongoDB account in the browser and verify that your name appears in the collection!
+4. Get MongoDB VSCode extension
+5. Make a new branch using git and make a new endpoint to fetch yourself

backend/app/api/endpoints/health.py

@@ -2,6 +2,7 @@
 
 router = APIRouter()
 
+
 @router.get("/health", status_code=200)
 async def health_check():
     """Health check endpoint to verify API status"""

backend/app/api/endpoints/persons.py

@@ -1,18 +1,22 @@
-from fastapi import APIRouter, Body
-from typing import List
-from app.schemas.person import Person, CreatePersonRequest
+from typing import Annotated
+
 from app.models.person import person_model
+from app.schemas.person import CreatePersonRequest, Person
+from fastapi import APIRouter, Body
 
 router = APIRouter()
 
+
 @router.post("/new", response_model=Person)
-async def create_person(person: CreatePersonRequest = Body(...)):
+async def create_person(person: Annotated[CreatePersonRequest, Body(...)]) -> Person:
     return await person_model.create_person(person)
 
-@router.get("/all", response_model=List[Person])
-async def get_persons():
+
+@router.get("/all", response_model=list[Person])
+async def get_persons() -> list[Person]:
     return await person_model.get_all_persons()
 
+
 @router.delete("/clear", response_model=None)
-async def clear_persons():
-    return await person_model.delete_all_persons()
+async def clear_persons() -> None:
+    return await person_model.delete_all_persons()

backend/app/api/endpoints/users.py

@@ -1,17 +1,17 @@
-from fastapi import APIRouter, HTTPException, Depends, status, UploadFile, File, Form, Body
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
-from typing import List, Optional, Tuple
-from datetime import timedelta, datetime
-from bson import ObjectId
-from pydantic import EmailStr, ValidationError
-from app.schemas.user import User, UserCreate, UserResponse, UserInDB
-from app.models.user import user_model
-from app.utils import hash_password, verify_password, create_access_token, settings
 import logging
 import re
-import json
-from fastapi.responses import JSONResponse
+from datetime import timedelta
+from typing import Annotated
+
+from app.models.user import user_model
+from app.schemas.user import User, UserInDB, UserResponse
+from app.utils import create_access_token, hash_password, settings, verify_password
+from bson import ObjectId
+from fastapi import APIRouter, Depends, Form, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from pydantic import EmailStr
+
 router = APIRouter()
 
 
@@ -22,7 +22,8 @@
 # OAuth2 scheme
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
 
-def validate_password(password: str) -> Tuple[bool, str]:
+
+def validate_password(password: str) -> tuple[bool, str]:
     """
     Validate password strength
     Returns: (is_valid: bool, message: str)
@@ -39,12 +40,13 @@ def validate_password(password: str) -> Tuple[bool, str]:
         return False, "Password must contain at least one special character"
     return True, "Password is valid"
 
-def validate_email(email: str) -> Tuple[bool, str]:
+
+def validate_email(email: str) -> tuple[bool, str]:
     """
     Validate email format and domain
     Returns: (is_valid: bool, message: str)
     """
-    email_regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    email_regex = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
     if not re.match(email_regex, email):
         return False, "Invalid email format"
     # Add additional domain validation if needed
@@ -53,26 +55,25 @@ def validate_email(email: str) -> Tuple[bool, str]:
 
 @router.post("/", response_model=UserResponse)
 async def create_user(
-    username: str = Form(...),
-    email: EmailStr = Form(...),
-    password: str = Form(...),
-    first_name: Optional[str] = Form(None),
-    last_name: Optional[str] = Form(None)
+    username: Annotated[str, Form(...)],
+    email: Annotated[EmailStr, Form(...)],
+    password: Annotated[str, Form(...)],
+    first_name: Annotated[str | None, Form()] = None,
+    last_name: Annotated[str | None, Form()] = None,
 ):
     """
     Create a new user with publications and avatar image.
     """
     logger.info(f"Creating new user with email: {email}")
 
     # Check if user exists
-    user_exists = await user_model.check_existing_username_and_email(username.lower(), email.lower())
+    user_exists = await user_model.check_existing_username_and_email(
+        username.lower(), email.lower()
+    )
 
     if user_exists:
         detail = "Email or username already registered"
-        raise HTTPException(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=detail
-        )
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=detail)
 
     # Create user document
     user_id = str(ObjectId())
@@ -94,15 +95,13 @@ async def create_user(
     except Exception as e:
         logger.error(f"Database error during user creation: {e}")
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Error creating user account"
-        )
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Error creating user account"
+        ) from None
 
     # Create access token
     access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
     access_token = create_access_token(
-        data={"sub": email.lower()},
-        expires_delta=access_token_expires
+        data={"sub": email.lower()}, expires_delta=access_token_expires
     )
 
     # Prepare user response
@@ -115,15 +114,16 @@ async def create_user(
             username=username.lower(),
             first_name=first_name,
             last_name=last_name,
-        )
+        ),
     )
 
     logger.info(f"Successfully created user with email: {email}")
     return user_response
 
+
 # Update the login endpoint
 @router.post("/token", response_model=UserResponse)
-async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+async def login_for_access_token(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
     logger.info(f"Login attempt for user: {form_data.username}")
 
     # Find user by username (case insensitive)
@@ -150,8 +150,7 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
     # Create access token
     access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
     access_token = create_access_token(
-        data={"sub": user["email"]},
-        expires_delta=access_token_expires
+        data={"sub": user["email"]}, expires_delta=access_token_expires
     )
 
     # Prepare user response
@@ -163,13 +162,14 @@ async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(
             email=user["email"],
             username=user["username"],
             first_name=user.get("first_name"),
-            last_name=user.get("last_name")
-        )
+            last_name=user.get("last_name"),
+        ),
     )
 
     logger.info(f"Login successful for user: {form_data.username}")
     return user_response
 
+
 # Get current user
 async def get_current_user(token: str = Depends(oauth2_scheme)):
     credentials_exception = HTTPException(
@@ -183,23 +183,26 @@ async def get_current_user(token: str = Depends(oauth2_scheme)):
         if email is None:
             raise credentials_exception
     except JWTError:
-        raise credentials_exception
+        raise credentials_exception from None
     user = await user_model.get_by_email(email)
     if user is None:
         raise credentials_exception
     return UserInDB(**user)
 
+
 # Protected route to get current user info
 @router.get("/me", response_model=User)
-async def read_users_me(current_user: User = Depends(get_current_user)):
+async def read_users_me(current_user: Annotated[User, Depends(get_current_user)]):
     return current_user
 
-@router.get("/all", response_model=List[User])
+
+@router.get("/all", response_model=list[User])
 async def get_all_users():
     """get all users"""
     users = await user_model.get_all()
     return users
 
+
 @router.get("/{user_id}", response_model=User)
 async def get_user(user_id: str):
     """get user by id"""

backend/app/core/config.py

@@ -1,5 +1,6 @@
 from pydantic_settings import BaseSettings
 
+
 class Settings(BaseSettings):
     PROJECT_NAME: str = "Person"
     API_V1_STR: str = "/api/v1"
@@ -12,4 +13,5 @@ class Settings(BaseSettings):
     class Config:
         env_file = ".env"
 
+
 settings = Settings()

backend/app/database/mongodb.py

@@ -1,4 +1,5 @@
 from motor.motor_asyncio import AsyncIOMotorClient
+
 from app.core.config import settings
 
 client = AsyncIOMotorClient(settings.MONGODB_URL)

backend/app/main.py

@@ -1,14 +1,14 @@
-# main.py
-from fastapi import FastAPI, Depends, HTTPException, status
-from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from app.api.endpoints import users, health
-from app.utils import verify_password, create_access_token
-from app.models.user import user_model
 from datetime import timedelta
-from jose import JWTError, jwt
+from typing import Annotated
+
+from fastapi import Depends, FastAPI, HTTPException, status
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security import OAuth2PasswordRequestForm
+
+from app.api.endpoints import health, persons, users
 from app.core.config import settings
-from app.api.endpoints import persons
+from app.models.user import user_model
+from app.utils import create_access_token, verify_password
 
 app = FastAPI()
 
@@ -35,9 +35,10 @@
 
 app.include_router(health.router, prefix="", tags=["Health"])
 
+
 # Login
 @app.post("/token", response_model=dict)
-async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
+async def login_for_access_token(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
     user = await user_model.get_by_email(form_data.username)
     if not user or not verify_password(form_data.password, user["hashed_password"]):
         raise HTTPException(

backend/app/models/person.py

@@ -1,7 +1,8 @@
-from typing import List
-from motor.motor_asyncio import AsyncIOMotorCollection
-from app.schemas.person import Person, CreatePersonRequest
+from motor.motor_asyncio import AsyncIOMotorCollection  # noqa: TCH002
+
 from app.database.mongodb import db
+from app.schemas.person import CreatePersonRequest, Person
+
 
 class PersonModel:
     def __init__(self):
@@ -14,12 +15,13 @@ async def create_person(self, person: CreatePersonRequest) -> Person:
 
         return Person(**person_data)
 
-    async def get_all_persons(self) -> List[Person]:
+    async def get_all_persons(self) -> list[Person]:
         persons_list = await self.collection.find().to_list(length=None)
 
         return [Person(**person) for person in persons_list]
 
     async def delete_all_persons(self) -> None:
         await self.collection.delete_many({})
 
-person_model = PersonModel()
+
+person_model = PersonModel()

backend/app/models/user.py

@@ -1,8 +1,8 @@
-# app/models/user.py
 from pydantic import EmailStr
-from app.schemas.user import UserInDB
+
 from app.database.mongodb import db
-from typing import List, Tuple
+from app.schemas.user import UserInDB
+
 
 class UserModel:
     def __init__(self):
@@ -16,22 +16,19 @@ async def get_by_username(self, username: str) -> UserInDB:
 
     async def get_by_id(self, id: str) -> UserInDB:
         return await self.collection.find_one({"id": id})
-    
+
     async def get_all(self):
         return await self.collection.find().to_list(1000)
-    
+
     async def check_existing_username_and_email(self, username: str, email: EmailStr) -> bool:
-        existing_user = await self.collection.find_one({
-            "$or": [
-                {"email": email.lower()},
-                {"username": username.lower()}
-            ]
-        })
+        existing_user = await self.collection.find_one(
+            {"$or": [{"email": email.lower()}, {"username": username.lower()}]}
+        )
 
         return existing_user is not None
 
     async def create_user(self, form_data):
         return await self.collection.insert_one(form_data)
 
 
-user_model = UserModel()
+user_model = UserModel()