initial commit

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.9-slim
+WORKDIR /app
+COPY requirements.txt ./requirements.txt
+# Install uvicorn
+RUN pip install uvicorn
+# Install dependencies
+RUN pip install -r requirements.txt
+COPY . /app
+ENTRYPOINT ["uvicorn", "main:app"]
+CMD ["--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,111 @@
+from fastapi import FastAPI, HTTPException, security, Depends
+import sqlalchemy.orm as orm
+import services as services
+import schemas as schemas
+import models as models
+from fastapi.middleware.cors import CORSMiddleware
+
+
+app = FastAPI(title="TODO API",
+              description='Todo App API using FastAPI, PostgreSQL and authentication support',
+              version='0.0.1')
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+async def root():
+    return {"Title": "Todo API",
+            "Description": "Todo App API using FastAPI, PostgreSQL and authentication support",
+            "Version": "0.0.1"}
+
+
+# create user
+@app.post("/api/users/")
+async def create_user(user: schemas.userCreate,
+                      db: orm.Session = Depends(services.get_db)):
+
+    db_user = await services.get_user_by_email(email=user.email.lower(), db=db)
+    if db_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+    # Await the create_user function
+    user = await services.create_user(user=user, db=db)
+    token = await services.create_token(user=user)
+    return token
+
+
+@app.post("/api/token/")
+async def generate_token(form_data: security.OAuth2PasswordRequestForm = Depends(),
+                         db: orm.Session = Depends(services.get_db)):
+
+    user = await services.authenticate_user(form_data.username.lower(), form_data.password, db=db)
+    if not user:
+        raise HTTPException(
+            status_code=401, detail="Incorrect email or password")
+    token = await services.create_token(user=user)
+    return {
+        "access_token": token['access_token'],
+        "first_name": user.first_name,
+        "last_name": user.last_name,
+    }
+
+
+@app.get('/api/users/me', response_model=schemas.User)
+async def get_user(user: schemas.User = Depends(services.get_current_user)):
+    return user
+
+
+@app.post("/api/users/todo")
+async def create_todo(todo: schemas.TodoCreate, user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.create_todo(user=user, todo=todo, db=db)
+
+
+@app.get("/api/users/todo")
+async def get_todos(user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.get_todos(user=user, db=db)
+
+
+@app.put("/api/users/todo/{todo_id}")
+async def update_todo(todo_id: int,
+                      todo: schemas.TodoCreate,
+                      user: schemas.User = Depends(services.get_current_user),
+                      db: orm.Session = Depends(services.get_db)):
+    return {
+        "todo": await services.update_todo(user=user, db=db, todo=todo, todo_id=todo_id),
+        "message": "Todo updated successfully"
+    }
+
+
+@app.delete("/api/users/todo/{todo_id}")
+async def delete_todo(todo_id: int,
+                      user: schemas.User = Depends(services.get_current_user),
+                      db: orm.Session = Depends(services.get_db)):
+    return {
+        "todo": await services.delete_todo(user=user, db=db, todo_id=todo_id),
+        "message": "Todo deleted successfully"
+    }
+
+
+@app.get("/api/users/todo/today")
+async def get_today_todos(user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.get_today_todos(user=user, db=db)
+
+
+@app.get("/api/users/todo/overdue")
+async def get_overdue_todos(user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.get_overdue_todos(user=user, db=db)
+
+
+@app.get("/api/users/todo/upcoming")
+async def get_upcoming_todos(user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.get_upcoming_todos(user=user, db=db)
+
+@app.get("/api/users/todo/completed")
+async def get_completed_todos(user: schemas.User = Depends(services.get_current_user), db: orm.Session = Depends(services.get_db)):
+    return await services.get_completed_todos(user=user, db=db)

models.py

@@ -0,0 +1,41 @@
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, Date, ForeignKey, CheckConstraint
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from psql_database import engine, Base
+from passlib.hash import bcrypt
+
+# Define the User model
+class User(Base):
+    __tablename__ = 'users'
+    user_id = Column(Integer, primary_key=True)
+    first_name = Column(String(50), nullable=False)
+    last_name = Column(String(50), nullable=False)
+    email = Column(String(100), nullable=False, unique=True)
+    password = Column(String(100), nullable=False) # HASHED PASSWORD
+    
+    todos = relationship('Todo', back_populates='user')
+    
+    
+    def verify_password(self, plain_password):
+        return bcrypt.verify(plain_password, self.password)
+    
+
+    
+# Define the Todo model
+class Todo(Base):
+    __tablename__ = 'todos'
+    todo_id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey('users.user_id'), nullable=False)
+    task_name = Column(String(100), nullable=False)
+    task_description = Column(String)
+    priority = Column(Integer, CheckConstraint('priority >= 1 AND priority <= 3', name="priority should be either 1 or 2 or 3"), nullable=False) # 1: high, 2: medium, 3: low
+    category = Column(String(50))
+    due_date = Column(Date, nullable=False)
+    status = Column(Boolean, default=False)
+    
+    user = relationship('User', back_populates='todos')
+
+# Create the tables
+def create_database_tables():
+    return Base.metadata.create_all(bind=engine)
+    

psql_database.py

@@ -0,0 +1,29 @@
+import os
+import urllib.parse as up
+import sqlalchemy as sa
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+
+# Parse the DATABASE_URL using urllib.parse
+up.uses_netloc.append("postgres")
+url = up.urlparse(
+    "postgres://xphzyodo:[email protected]/xphzyodo")
+
+
+# Create the connection string
+conn_string = f'postgresql+psycopg2://{url.username}:{url.password}@{url.hostname}/{url.path[1:]}'
+
+# Create the engine using the connection string
+engine = sa.create_engine(conn_string)
+
+# Reassign the engine to your existing engine variable
+engine = engine
+
+# Create the session factory
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Reassign the session factory to your existing SessionLocal variable
+SessionLocal = SessionLocal
+
+# Reassign the Base to your existing Base variable
+Base = declarative_base()

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.97.0
+passlib==1.7.4
+pydantic==1.10.2
+PyJWT==2.7.0
+SQLAlchemy==1.4.48

schemas.py

@@ -0,0 +1,54 @@
+# why schemas? it is a way to define the structure of the data sent to the server and the data received from the server
+from pydantic import BaseModel, Field
+import datetime as dt
+
+# template for user data. this is used to validate the data sent to the server
+
+
+class userBase(BaseModel):
+    first_name: str = Field(...)
+    last_name: str = Field(...)
+    email: str = Field(...,)
+
+
+class userCreate(userBase):
+    password: str = Field(...)  # hashed password
+
+    class Config:
+        orm_mode = True  # to tell pydantic to read the data even if it is not a dict but an ORM model
+        schema_extra = {
+            "example": {
+                "first_name": "John",
+                "last_name": "Doe",
+                "email": "[email protected]",
+                "password": "password",
+            }
+        }
+
+
+class User(userBase):
+    user_id: int
+
+    class Config:
+        orm_mode = True
+
+
+class TodoBase(BaseModel):
+    task_name: str
+    task_description: str
+    priority: int
+    category: str
+    due_date: dt.date
+    status: bool = False
+
+
+class TodoCreate(TodoBase):
+    pass
+
+
+class Todo(TodoBase):
+    todo_id: int
+    user_id: int
+
+    class Config:
+        orm_mode = True

services.py

@@ -0,0 +1,151 @@
+from copy import deepcopy
+import models
+from psql_database import engine, Base, SessionLocal
+import sqlalchemy as sa
+import schemas as schemas
+import passlib.hash as pwd_hash
+import re
+from fastapi import HTTPException, Depends, security
+import jwt
+
+
+OAUTH2_SCHEME = security.OAuth2PasswordBearer(tokenUrl="/api/token")
+
+JWT_SECRET = 'myjwtsecret'
+
+
+def validate_email(email):
+    pattern = r'^[\w\.-]+@[\w\.-]+\.\w+$'
+    return bool(re.match(pattern, email))
+
+
+def create_database_tables():
+    return Base.metadata.create_all(bind=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+async def get_user_by_email(email: str, db: sa.orm.Session):
+    return db.query(models.User).filter(models.User.email == email).first()
+
+
+async def create_user(user: schemas.userCreate, db: sa.orm.Session):
+
+    if not validate_email(user.email):
+        raise HTTPException(status_code=400, detail="Invalid email")
+
+    user_obj = models.User(
+        first_name=user.first_name,
+        last_name=user.last_name,
+        email=user.email,
+        password=pwd_hash.bcrypt.hash(user.password)
+    )
+
+    db.add(user_obj)
+    db.commit()  # commit operation
+    db.refresh(user_obj)  # Await the refresh operation
+    return user_obj
+
+
+async def authenticate_user(email, password, db: sa.orm.Session):
+    user = await get_user_by_email(email=email, db=db)
+
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user if user.verify_password(password) else False
+
+
+async def create_token(user: models.User):
+    user_dict = {
+        "first_name": user.first_name,
+        "last_name": user.last_name,
+        "email": user.email,
+    }
+    token = jwt.encode(user_dict, JWT_SECRET)
+
+    return dict(access_token=token, token_type='bearer', status='success')
+
+
+async def get_current_user(db: sa.orm.Session = Depends(get_db), token: str = Depends(OAUTH2_SCHEME)):
+    try:
+        payload = jwt.decode(token, JWT_SECRET, algorithms=['HS256'])
+        print(payload)
+        user = db.query(models.User).filter(
+            models.User.email == payload['email']).first()
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        return schemas.User(**user.__dict__)
+    except Exception as e:
+        raise HTTPException(status_code=401, detail="Invalid token") from e
+
+
+async def create_todo(user: schemas.User, todo: schemas.TodoCreate, db: sa.orm.Session = Depends(get_db)):
+    print(todo.dict())
+
+    todo_obj = models.Todo(
+        task_name=todo.task_name,
+        task_description=todo.task_description,
+        priority=todo.priority,
+        category=todo.category,
+        due_date=todo.due_date,
+        status=todo.status,
+        user_id=user.user_id,
+    )
+
+    db.add(todo_obj)
+    db.commit()
+    db.refresh(todo_obj)
+    return todo_obj
+
+
+async def get_todos(user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    return db.query(models.Todo).filter(models.Todo.user_id == user.user_id).all()
+
+
+async def delete_todo(todo_id: int, user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    todo = db.query(models.Todo).filter(models.Todo.user_id ==
+                                        user.user_id, models.Todo.todo_id == todo_id).first()
+    if not todo:
+        raise HTTPException(status_code=404, detail="Todo not found")
+    db.delete(todo)
+    db.commit()
+    return todo
+
+
+async def update_todo(todo_id: int, user: schemas.User, todo: schemas.TodoCreate, db: sa.orm.Session = Depends(get_db)):
+    todo_db = db.query(models.Todo).filter(
+        models.Todo.user_id == user.user_id, models.Todo.todo_id == todo_id).first()
+    if not todo_db:
+        raise HTTPException(status_code=404, detail="Todo not found")
+    todo_db.task_name = todo.task_name
+    todo_db.task_description = todo.task_description or todo.task_description
+    todo_db.priority = todo.priority
+    todo_db.category = todo.category
+    todo_db.due_date = todo.due_date
+    todo_db.status = todo.status
+
+    db.commit()
+    db.refresh(todo_db)
+    return todo_db
+
+
+async def get_today_todos(user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    return db.query(models.Todo).filter(models.Todo.user_id == user.user_id, sa.func.date(models.Todo.due_date) == sa.func.date(sa.func.now())).all()
+
+
+async def get_overdue_todos(user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    return db.query(models.Todo).filter(models.Todo.user_id == user.user_id, models.Todo.due_date < sa.func.now()).all()
+
+
+async def get_upcoming_todos(user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    return db.query(models.Todo).filter(models.Todo.user_id == user.user_id, models.Todo.due_date > sa.func.now()).all()
+
+
+async def get_completed_todos(user: schemas.User, db: sa.orm.Session = Depends(get_db)):
+    return db.query(models.Todo).filter(models.Todo.user_id == user.user_id, models.Todo.status == True).all()