Update routes/auth.py

routes/auth.py

@@ -1,37 +1,128 @@
 # app/routes/auth.py
-from fastapi import FastAPI, Depends, HTTPException, Form, Response, status
+from fastapi import APIRouter, Depends, HTTPException, Form, Response, status, FastAPI
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from pydantic import BaseModel
 from sqlalchemy.orm import Session
-
-# Your database model
 from app.models import User
+from app.database import get_db
+from jose import jwt
+from passlib.context import CryptContext
+from datetime import datetime, timedelta
 
+router = APIRouter()
 app = FastAPI()
 
-# Authentication methods (OAuth2, JWT, etc.) can be added here
+class AuthViews:
+    def __init__(self):
+        self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+        self.SECRET_KEY = "your-secret-key"  # Replace with your actual secret key
+        self.ALGORITHM = "HS256"
+        self.ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+    def register(self, user: UserCreate, db: Session = Depends(get_db)):
+    # Validate email format and check for existing users
+    db_user = database.get_user_by_email(db, user.email)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Hash the password
+    hashed_password = self.pwd_context.hash(user.password)
+
+    # Generate a verification token
+    verification_token = email.generate_verification_token(user.email)
+
+    # Send a verification email (implement email.send_verification_email)
+
+    # Create the user in the database
+    user_in_db = models.User(email=user.email, hashed_password=hashed_password)
+    db.add(user_in_db)
+    db.commit()
+    db.refresh(user_in_db)
+
+    return user_in_db
+
+    def verify_email(self, verification_token: str, db: Session = Depends(get_db)):
+    # Verify the email using the token (implement email.verify_token)
+    email = email.verify_token(verification_token)
+    if not email:
+        raise HTTPException(status_code=400, detail="Invalid verification token")
+
+    # Get the user by email
+    user = database.get_user_by_email(db, email)
+    if not user:
+        raise HTTPException(status_code=400, detail="User not found")
+
+    if user.is_verified:
+        raise HTTPException(status_code=400, detail="Email already verified")
+
+    # Mark the email as verified
+    user.is_verified = True
+    db.commit()
+    return {"message": "Email verification successful"}
+
+
+    def login(self, form_data: OAuth2PasswordRequestForm = Depends()):
+    # Check email verification
+    db_user = database.get_user_by_email(db, form_data.username)
+    if not db_user or not self.pwd_context.verify(form_data.password, db_user.hashed_password):
+        raise HTTPException(status_code=400, detail="Incorrect email or password")
+
+    if not db_user.is_verified:
+        raise HTTPException(status_code=400, detail="Email not verified")
+
+    # Generate an access token
+    access_token_expires = timedelta(minutes=self.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = jwt.encode(
+        {"sub": db_user.email, "exp": datetime.utcnow() + access_token_expires},
+        self.SECRET_KEY,
+        algorithm=self.ALGORITHM,
+    )
+
+    return {"access_token": access_token, "token_type": "bearer"}
+
+
+    # Import User model and database functions
+from app.models import User
+from app.database import get_user_by_email
+
+# ...
+
+# User authentication (protected route)
+@router.get("/protected", response_model=str)
+def protected_route(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    # Verify the access token
+    user = verify_token(token, SECRET_KEY, ALGORITHM)
+    if user is None:
+        raise HTTPException(status_code=401, detail="Invalid or expired token")
+
+    # Check if the user exists in the database
+    db_user = get_user_by_email(db, user)  # Modify this to match your database query
+
+    if db_user is None:
+        raise HTTPException(status_code=401, detail="User not found in the database")
+
+    # The user exists in the database, and you can perform the protected route logic
+    return f"Protected route for user: {user}"
+
+
+auth_views = AuthViews()
 
 # User registration route
-@app.post("/register", response_model=User)
+@router.post("/register", response_model=User)
 def register(user: UserCreate, db: Session = Depends(get_db)):
-    # Validate email format, check for existing users
-    # Hash the password, generate a verification token, send a verification email
-    # Update the database, and return the user object
+    return auth_views.register(user, db)
 
 # Email verification route
-@app.get("/verify/{verification_token}")
+@router.get("/verify/{verification_token}")
 def verify_email(verification_token: str, db: Session = Depends(get_db)):
-    # Handle email verification
-    # Update the database and return a confirmation response
+    return auth_views.verify_email(verification_token, db)
 
 # User login route
-@app.post("/login", response_model=dict)
+@router.post("/login", response_model=dict)
 def login(form_data: OAuth2PasswordRequestForm = Depends()):
-    # Check email verification
-    # Implement login and return an access token if successful
+    return auth_views.login(form_data)
 
 # User authentication (protected route)
-@app.get("/protected", response_model=str)
+@router.get("/protected", response_model=str)
 def protected_route(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
-    # Protect this route with an authentication method
-    return f"Protected route for user"
+    return auth_views.protected_route(token)