initial commit

worked on async alembic migrations, User model.

Current issue:

web_1      | INFO:     172.20.0.1:62958 - "POST /users/ HTTP/1.1" 500 Internal Server Error
web_1      | ERROR:    Exception in ASGI application
web_1      | Traceback (most recent call last):
...
web_1      | response
web_1      |   value is not a valid dict (type=type_error.dict)

when trying to create new user

users/models.py

@@ -0,0 +1,83 @@
+# from sqlmodel import SQLModel, Field
+from sqlalchemy import Column, String, DateTime, delete
+from sqlalchemy import update as sqlalchemy_update, delete as sqlalchemy_delete
+from sqlalchemy.future import select
+from app.db import Base, db
+from datetime import datetime
+
+from uuid import uuid4
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(String, primary_key=True)
+    username = Column(String)
+    created_at = Column(DateTime, index=True, default=datetime.utcnow)
+
+    def __repr__(self):
+        return (
+            f"<{self.__class__.__name__}("
+            f"id={self.id}, "
+            f"username={self.username}, "
+            f")>"
+        )
+
+    @classmethod
+    async def create(cls, **kwargs):
+        user = cls(id=str(uuid4()), **kwargs)
+        db.add(user)
+        try:
+            await db.commit()
+        except Exception:
+            await db.rollback()
+            raise
+        return user
+
+    @classmethod
+    async def update(cls, id, **kwargs):
+        query = (
+            sqlalchemy_update(cls)
+            .where(cls.id == id)
+            .values(**kwargs)
+            .execution_options(synchronize_session="fetch")
+        )
+        await db.execute(query)
+        try:
+            await db.commit()
+        except Exception:
+            await db.rollback()
+            raise
+
+    @classmethod
+    async def get(cls, id):
+        query = select(cls).where(cls.id == id)
+        users = await db.execute(query)
+        (user,) = users.first()
+        return user
+
+    @classmethod
+    async def get_all(cls):
+        query = select(cls)
+        users = await db.execute(query)
+        users = users.scalars().all()
+        return users
+
+    @classmethod
+    async def delete(cls, id):
+        query = sqlalchemy_delete(cls).where(cls.id == id)
+        await db.execute(query)
+        try:
+            await db.commit()
+        except Exception:
+            await db.rollback()
+            raise
+        return True
+
+# class UserBase(SQLModel):
+#     username: str
+#     full_name: str
+#     email: str
+#     hashed_password: str
+#     disabled: bool
+
+# class User(UserBase, table=True):
+#     id: int = Field(default=None, primary_key=True)

users/views.py

@@ -0,0 +1,150 @@
+from datetime import datetime, timedelta
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from starlette.status import HTTP_401_UNAUTHORIZED
+
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+
+from passlib.context import CryptContext
+from jose import JWTError, jwt
+
+# from app.db import get_session
+from app.settings import settings
+from pydantic import BaseModel
+from typing import List
+
+from users.models import User
+
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+# router = APIRouter()
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+# def verify_password(plain_password, hashed_password):
+#     return pwd_context.verify(plain_password, hashed_password)
+
+# def get_password_hash(password):
+#     return pwd_context.hash(password)
+
+# def authenticate_user(username: str, password: str, db: Session):
+#     statement = select(User).where(User.username == username)
+#     result = db.execute(statement).fetchone()
+
+#     if result:
+#         print(result.User.__dict__)
+#         if not verify_password(password, result.User.hashed_password):
+#             return False
+
+#     return result.User
+
+# def create_access_token(data: dict, expires_delta: timedelta | None = None):
+#     to_encode = data.copy()
+#     if expires_delta:
+#         expire = datetime.utcnow() + expires_delta
+#     else:
+#         expire = datetime.utcnow() + timedelta(minutes=15)
+#     to_encode.update({"exp": expire})
+#     encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
+
+#     return encoded_jwt
+
+# async def get_current_user(token: str = Depends(oauth2_scheme)):
+#     credentials_exception = HTTPException(
+#             status_code=status.HTTP_401_UNAUTHORIZED,
+#             detail="Could not validate credentials",
+#             headers={"WWW-Authenticate": "Bearer"},
+#             )
+#     try:
+#         payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[ALGORITHM])
+#         username: str = payload.get("sub", None)
+#         if username is None:
+#             raise credentials_exception
+#         token_data = TokenData(username=username)
+#     except JWTError:
+#         raise credentials_exception
+#     user = get_user(username=token_data.username)
+#     if user is None:
+#         raise credentials_exception
+#     return user
+
+# async def get_current_active_user(current_user: User = Depends(get_current_user)):
+#     if current_user.disabled:
+#         raise HTTPException(status_code=400, detail="Inactive user")
+#     return current_user
+
+# @router.post("/register/", tags=["users"])
+# async def register(db: Session = Depends(get_session)):
+#     pass
+
+# @router.get("/login/", tags=["users"])
+# async def login(session: Session = Depends(get_session)):
+#     username = "johndoe"
+#     statement = select(User).where(User.username == username)
+#     result = session.execute(statement).first()
+
+#     print(result)
+
+#     return {"hi": "there"}
+
+# @router.post("/token", tags=["users"])
+# async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_session)):
+#     user = authenticate_user(form_data.username, form_data.password, db)
+#     if not user:
+#         raise HTTPException(
+#                 status_code=HTTP_401_UNAUTHORIZED,
+#                 detail="Incorrect username or password",
+#                 headers={"WWW-Authenticate": "Bearer"},
+#                 )
+#     access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
+#     access_token = create_access_token(
+#             data = {"sub": user.username}, expires_delta=access_token_expires
+#             )
+#     return {"access_token": access_token, "token_type": "bearer"}
+
+
+class UserSchema(BaseModel):
+    username: str
+
+
+class UserSerializer(BaseModel):
+    id: str
+    username: str
+
+
+class Config:
+        orm_mode = True
+
+router = APIRouter(
+    prefix="/users",
+)
+
+@router.post("/", response_model=UserSerializer)
+async def create_user(user: UserSchema):
+    print(user)
+    print(type(user))
+    user = await User.create(**user.dict())
+    return user
+
+@router.get("/{id}", response_model=UserSerializer)
+async def get_user(id: str):
+    user = await User.get(id)
+    return user
+
+@router.get("/", response_model=List[UserSerializer])
+async def get_all_users():
+    users = await User.get_all()
+    return users
+
+@router.put("/{id}", response_model=UserSerializer)
+async def update(id: str, user: UserSchema):
+    user = await User.update(id, **user.dict())
+    return user
+
+@router.delete("/{id}", response_model=bool)
+async def delete_user(id: str):
+    return await User.delete(id)