From f1e0b91601a496dc98eae4984d0b124a7786f8f8 Mon Sep 17 00:00:00 2001 From: Ryan Reed Date: Tue, 2 Jul 2019 18:50:40 -0400 Subject: [PATCH] Initial work --- README.md | 12 ++++++++++ app/__init__.py | 0 app/crud.py | 35 +++++++++++++++++++++++++++++ app/database.py | 13 +++++++++++ app/main.py | 59 +++++++++++++++++++++++++++++++++++++++++++++++++ app/models.py | 24 ++++++++++++++++++++ app/schemas.py | 32 +++++++++++++++++++++++++++ 7 files changed, 175 insertions(+) create mode 100644 app/__init__.py create mode 100644 app/crud.py create mode 100644 app/database.py create mode 100644 app/main.py create mode 100644 app/models.py create mode 100644 app/schemas.py diff --git a/README.md b/README.md index e69de29..95bf4ce 100644 --- a/README.md +++ b/README.md @@ -0,0 +1,12 @@ + +# Table of Contents + + +* [Requirements](#requirements) + + + +# Requirements +* FastAPI +* SQLAlchemy +* uvicorn diff --git a/app/__init__.py b/app/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/crud.py b/app/crud.py new file mode 100644 index 0000000..5355ae9 --- /dev/null +++ b/app/crud.py @@ -0,0 +1,35 @@ +from sqlalchemy.orm import Session + +from . import models, schemas + + +# Create +def create_user(db: Session, user: schemas.UserCreate): + fake_hashed_password = user.password + "notreallyhashed" # Change to something later + db_user = models.User(email=user.email, hashed_password=fake_hashed_password) + + db.add(db_user) + db.commit() + db.refresh(db_user) + return db_user + +def create_user_item(db: Session, item: schemas.ItemCreate, user_id: int): + db_item = models.item(**item.dict(), owner_id=user_id) + + db.add(db_item) + db.commit() + db.refresh(db_item) + return db_item + + + +# Read +def get_user(db: Session, user_id: int): + return db.query(models.User).filter(models.User.id == user_id).first() + +def get_user_by_email(db: Session, email: str): + return db.query(models.User).filter(models.User.email == email).first() + +def get_users(db: Session, skip: int = 0, limit: int = 100): + return db.query(models.User).offset(skip).limit(limit).all() + diff --git a/app/database.py b/app/database.py new file mode 100644 index 0000000..6a23fd5 --- /dev/null +++ b/app/database.py @@ -0,0 +1,13 @@ +from sqlalchemy import create_engine +from sqlalchemy.ext.declarative import declarative_base +from sqlalchemy.orm import sessionmaker + +SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db" + +engine = create_engine( + SQLALCHEMY_DATABASE_URL, + connect_args={"check_same_thread": False} #sqlite +) +SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) + +Base = declarative_base() diff --git a/app/main.py b/app/main.py new file mode 100644 index 0000000..b9bd40f --- /dev/null +++ b/app/main.py @@ -0,0 +1,59 @@ +from typing import List + +from fastapi import Depends, FastAPI, HTTPException +from sqlalchemy.orm import Session +from starlette.requests import Request +from starlette.responses import Response + +from . import crud, models, schemas +from .database import SessionLocal, engine + +models.Base.metadata.create_all(bind=engine) + +app = FastAPI() + +# The following is called for every request +# Creates the db session on initial request +# Closes the db session at end of request +@app.middleware("http") +async def db_session_middleware(request: Request, call_next): + response = Response("Internal server error", status_code=500) + try: + request.state.db = SessionLocal + response = await call_next(request) + finally: + request.state.db.close() + return response + +def get_db(request: Request): + return request.state.db + + +@app.post("/users", response_model=schemas.User) +def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)): + db_user = crud.get_user_by_email(db, email=user.email) + if db_user: + raise HTTPException(status_code=400, detail="Email already registered") + return crud.create_user(db=db, user=user) + +@app.get("/users", response_model=List[schemas.User]) +def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): + users = crud.get_users(db, skip=skip, limit=limit) + return users + +@app.get("/users/{user_id}", response_model=schemas.User) +def read_user(user_id: int, db: Session = Depends(get_db)): + db_user = crud.get_user(db, user_id=user_id) + if db_user is None: + raise HTTPException(status_code=404, detail="User not found") + return db_user + + +@app.post("/users/{user_id}/items/", response_model=schemas.Item) +def create_item_for_user(user_id: int, item: schemas.ItemCreate, db: Session = Depends(get_db)): + return crud.create_user_item(db=db, item=item, user_id=user_id) + +@app.post("/items/", response_model=List[schemas.Item]) +def read_items(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): + items = crud.get_items(db, skip=skip, limit=limit) + return items diff --git a/app/models.py b/app/models.py new file mode 100644 index 0000000..535524f --- /dev/null +++ b/app/models.py @@ -0,0 +1,24 @@ +from sqlalchemy import Boolean, Column, ForeignKey, Integer, String +from sqlalchemy.orm import relationship + +from .database import Base + +class User(Base): + __tablename__ = "users" + + id = Column(Integer, primary_key=True, index=True) + email = Column(String, unique=True, index=True) + hashed_password = Column(String) + is_active = Column(Boolean, default=True) + + items = relationship("Item", back_populates="owner") + +class Item(Base): + __tablename__ = "items" + + id = Column(Integer, primary_key=True, index=True) + title = Column(String, index=True) + description = Column(String, index=True) + owner_id = Column(Integer, ForeignKey("users.id")) + + owner = relationship("User", back_populates="items") diff --git a/app/schemas.py b/app/schemas.py new file mode 100644 index 0000000..cfc20d8 --- /dev/null +++ b/app/schemas.py @@ -0,0 +1,32 @@ +from typing import List + +from pydantic import BaseModel + +class ItemBase(BaseModel): + title: str + description: str = None + +class ItemCreate(ItemBase): + pass + +class Item(ItemBase): + id: int + owner_id: int + + class Config: + orm_mode = True # pydantic - read dicts or objects (e.g. data["id"] or data.id) + + +class UserBase(BaseModel): + email: str + +class UserCreate(UserBase): + password: str + +class User(UserBase): + id: int + is_active: bool + items: List[Item] = [] + + class Config: + orm_mode = True # pydantic - read dicts or objects (e.g. data["id"] or data.id)