add updates to show bedir

auth/router.py

@@ -1,15 +1,14 @@
-from fastapi import APIRouter, Depends, HTTPException, status
-from .models import Token, UserPublic
-from .models import authenticate_user, create_access_token
-from datetime import timedelta
-from ..auth.models import get_password_hash, verify_password
-from typing import Annotated
-from sqlmodel import Session
-from ..config import get_session_db
-from fastapi import Depends
-from fastapi.security import OAuth2PasswordRequestForm
-from .models import UserCreate, DBUser
+import os
 
+from fastapi import APIRouter, HTTPException
+import bcrypt
+import jwt
+
+from fastapi import Depends
+from sqlalchemy.orm import Session
+from .models import User
+from .schemas import UserCreate, UserOut, UserLogin
+from ..config import get_db
 
 router = APIRouter(
     prefix="/auth",
@@ -18,41 +17,40 @@ router = APIRouter(
     dependencies=[],
 )
 
-@router.post('/login')
-async def login_for_access_token(
-    form_data : Annotated[OAuth2PasswordRequestForm, Depends()],
-    session : Annotated[Session, Depends(get_session_db)],
-) -> Token:
+def create_token(user: User):
+    return jwt.encode({"sub": user.username}, os.getenv("SECRET_KEY"), algorithm=os.getenv("ALGORITHM"))
 
-    user = authenticate_user(session, 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, "role": user.role, 'status': user.status}, expires_delta=access_token_expires
-    )
-    return Token(access_token=access_token, token_type="bearer")
+def verify_token(token: str):
+    try:
+        data = jwt.decode(token, os.getenv("SECRET_KEY"), algorithms=[os.getenv("ALGORITHM")])
+        return data.get("sub")
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(401, "Token expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(401, "Invalid token")
 
 
-@router.post('/register', response_model=UserPublic)
-async def create_user(
-        session : Annotated[Session, Depends(get_session_db)],
-        user : Annotated[UserCreate, Depends()]
-):
-    user_dict = user.dict()
-    print(user.password)
-    user_dict['hashed_password'] = get_password_hash(user.password)
-    print (user_dict['hashed_password'])
+@router.post("/register")
+def register(user: UserCreate, db: Session = Depends(get_db)):
+    if db.query(User).filter_by(username=user.username).first():
+        raise HTTPException(400, "Username taken")
+    hashed = bcrypt.hashpw(user.password.encode(), bcrypt.gensalt()).decode()
+    db_user = User(**user.model_dump(exclude={"password"}), hashedPassword=hashed)
+    db.add(db_user)
+    db.commit()
+    return {"msg": "User created"}
 
-    if not verify_password(user.password, user_dict['hashed_password']):
-        raise HTTPException(status_code=400, detail="Password hashing failed")
+@router.post("/login")
+def login(user: UserLogin, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter_by(username=user.username).first()
+    if not db_user or not bcrypt.checkpw(user.password.encode(), db_user.hashedPassword.encode()):
+        raise HTTPException(401, "Invalid creds")
+    return {"token": create_token(db_user)}
 
-    db_user = DBUser.model_validate(user_dict)
-    session.add(db_user)
-    session.commit()
-    session.refresh(db_user)
-    return db_user
+@router.get("/me", response_model=UserOut)
+def get_me(token: str, db: Session = Depends(get_db)):
+    username = verify_token(token)
+    if not username:
+        raise HTTPException(401, "Invalid token")
+    user = db.query(User).filter_by(username=username).first()
+    return user