[rewrite] Major changes to code - switched to postgres, added initial backend docker files

backend/app/api/__init__.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from app.api.routes import cart_routes, shop_routes, user_routes, utils_routes
+
+api_router = APIRouter()
+
+api_router.include_router(cart_routes.router)
+api_router.include_router(shop_routes.router)
+api_router.include_router(user_routes.router)
+api_router.include_router(utils_routes.router)

backend/app/api/dependencies.py

@@ -0,0 +1,48 @@
+from typing import Annotated
+from sqlmodel import Session
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+
+import jwt
+from jwt.exceptions import InvalidTokenError
+
+from pydantic import ValidationError
+
+from app.core.config import settings
+from app.core import security
+
+from app.database.manager import get_session
+from app.database.models.user_model import User
+
+from app.schemas.user_schemas import TokenPayload
+
+
+reusable_oauth2 = OAuth2PasswordBearer(
+    tokenUrl="/login/access-token"
+)
+
+SessionDep = Annotated[Session, Depends(get_session)]
+TokenDep = Annotated[str, Depends(reusable_oauth2)]
+
+
+def get_current_user(session: SessionDep, token: TokenDep) -> User:
+    try:
+        payload = jwt.decode(
+            token, settings.SECRET_KEY, algorithms=[security.ALGORITHM]
+        )
+        token_data = TokenPayload(**payload)
+    except (InvalidTokenError, ValidationError):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Could not validate credentials",
+        )
+    user = session.get(User, {"uuid": token_data.sub})
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    if not user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return user
+
+
+CurrentUser = Annotated[User, Depends(get_current_user)]

backend/app/api/routes/cart_routes.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, Query
+
+router = APIRouter(
+    prefix="/cart",
+    tags=["Cart"]
+)
+
+
+@router.get("/")
+async def show_cart():
+    raise NotImplementedError
+
+
+@router.put("/add/{product_id}")
+async def add_to_cart(
+    product_id: int,
+    count: int = Query(
+        1, ge=1, description="Count must be greater than or equal to 1")
+):
+    raise NotImplementedError
+
+
+@router.delete("/remove/{product_id}")
+async def remove_from_cart(product_id: int):
+    raise NotImplementedError
+
+
+@router.put("/update/{product_id}")
+async def update_count_in_cart(
+    product_id: int,
+    count: int = Query(..., description="Count must be provided")
+):
+    raise NotImplementedError
+
+
+@router.get("/purchase")
+async def purchase():
+    raise NotImplementedError

backend/app/api/routes/login_routes.py

@@ -0,0 +1,37 @@
+from typing import Annotated
+from datetime import timedelta
+
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.security import OAuth2PasswordRequestForm
+
+from app.api.dependencies import SessionDep
+
+from app.schemas.user_schemas import Token
+
+from app.core import security
+from app.core.config import settings
+
+router = APIRouter(tags=["login"])
+
+
+@router.post("/login/access-token")
+def login_access_token(
+    session: SessionDep, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
+) -> Token:
+    """
+    OAuth2 compatible token login, get an access token for future requests
+    """
+    user = None
+    # user = crud.authenticate(
+    #     session=session, email=form_data.username, password=form_data.password
+    # )
+    if not user:
+        raise HTTPException(status_code=400, detail="Incorrect email or password")
+    elif not user:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    return Token(
+        access_token=security.create_access_token(
+            user.id, expires_delta=access_token_expires
+        )
+    )

backend/app/api/routes/shop_routes.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+router = APIRouter(
+    prefix="/shop",
+    tags=["Shop"]
+)
+
+
+@router.get("/")
+async def get_shop_info():
+    raise NotImplementedError

backend/app/api/routes/user_routes.py

@@ -0,0 +1,51 @@
+from fastapi import APIRouter, Body
+
+from app.schemas.user_schemas import UserRegisterSchema, UserLoginSchema
+
+from app.services.user_service import create_user
+
+router = APIRouter(
+    prefix="/user",
+    tags=["User"]
+)
+
+
+@router.delete("/delete", summary="Delete user")
+async def delete_user():
+    raise NotImplementedError("delete_user() needs to be implemented.")
+
+
+@router.post("/login", summary="User login")
+async def login(login_data: UserLoginSchema):
+    raise NotImplementedError("login() needs to be implemented.")
+    # user = authenticate_user(form_data.username, form_data.password)
+    # if not user:
+    #     raise HTTPException(
+    #         status_code=status.HTTP_401_UNAUTHORIZED,
+    #         detail="Incorrect username or password",
+    #         headers={"WWW-Authenticate": "Bearer"},
+    #     )
+    # access_token_expires = timedelta(minutes=30)
+    # access_token = create_access_token(
+    #     data={"sub": user.username}, expires_delta=access_token_expires
+    # )
+    # return Token(access_token=access_token, token_type="bearer")
+
+
+@router.delete("/logout", summary="User logout")
+async def logout():
+    raise NotImplementedError("logout() needs to be implemented.")
+
+
+@router.post("/register", summary="Register new user")
+async def register(user_data: UserRegisterSchema):
+    try:
+        create_user(user_data)
+        return {"message": "User registered successfully"}
+    except BaseException:
+        return {"message": "An error occured"}
+
+
+@router.put("/update", summary="Update user details")
+async def update_user(data: dict = Body(...)):
+    raise NotImplementedError("update_user() needs to be implemented.")

backend/app/api/routes/utils_routes.py

@@ -0,0 +1,20 @@
+from sqlmodel import select
+
+from fastapi import APIRouter
+from app.api.dependencies import SessionDep
+
+router = APIRouter(prefix="/utils", tags=["utils"])
+
+
+@router.get("/health-check/")
+async def health_check() -> bool:
+    return True
+
+@router.get("/test-db/")
+async def test_db(session: SessionDep) -> bool:
+    try:
+        with session:
+            session.exec(select(1))
+            return True
+    except Exception:
+        return False