Initial commit

.gitignore

+requirements.txt
+__pycache__/
+*.pyo
+*.pyd
+*.so
+*.py[cod]
+.env
+*.sqlite3
+.vscode/
+.DS_Store
+venv/
\ No newline at end of file

app/auth/auth_handler.py

+from passlib.context import CryptContext
+from datetime import datetime, timedelta
+from jose import JWTError, jwt
+
+
+SECRET_KEY = "secretkey"
+ALGORITHM = "HS256"
+ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+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 create_access_token(data: dict, expires_delta: timedelta = None):
+    to_encode = data.copy()
+    expire = datetime.now() + (expires_delta or timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES))
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
+
+def decode_access_token(token: str):
+    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
\ No newline at end of file

app/auth/auth_router.py

+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app.schemas.user import UserCreate, UserResponse
+from app.models.users import User
+from app.db import get_db
+from app.auth.auth_handler import get_password_hash, verify_password, create_access_token
+
+router = APIRouter()
+
+@router.post("/register", response_model=UserResponse)
+def register_user(user: UserCreate, db: Session = Depends(get_db)):
+    existing_user = db.query(User).filter(User.email == user.email).first()
+    if existing_user:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    hashed_pw = get_password_hash(user.password)
+    new_user = User(
+        username=user.username,
+        email=user.email,
+        password=hashed_pw
+    )
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    return new_user
+
+@router.post("/login")
+def login(user: UserCreate, db: Session = Depends(get_db)):
+    db_user = db.query(User).filter(User.email == user.email).first()
+    if not db_user or not verify_password(user.password, db_user.password):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    token = create_access_token(data={"sub": str(db_user.id)})
+    return {"access_token": token, "token_type": "bearer"}
\ No newline at end of file

app/auth/dependencies.py

+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from jose import JWTError
+from sqlalchemy.orm import Session
+from app.auth.auth_handler import decode_access_token
+from app.db import get_db
+from app.models.users import User
+
+
+security = HTTPBearer()
+
+def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(security),
+    db: Session = Depends(get_db)
+) -> User:
+    token = credentials.credentials 
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = decode_access_token(token)
+        user_id: str = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except JWTError:
+        raise credentials_exception
+
+    user = db.query(User).filter(User.id == user_id).first()
+    if user is None:
+        raise credentials_exception
+
+    return user

app/db.py

+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+
+DATABASE_URL = "sqlite:///./task_manager.db"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread":False})
+
+sessionLocal = sessionmaker(bind=engine,autocommit=False,autoflush=False)
+
+Base = declarative_base()
+
+
+
+def get_db():
+    db = sessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
\ No newline at end of file

app/main.py

+from fastapi import FastAPI
+from .db import engine, sessionLocal,get_db,Base
+from .routers import tasks, users, auth
+from .auth import  auth_router
+from . import models
+
+app = FastAPI(title="Task manager API")
+
+Base.metadata.create_all(bind=engine)
+
+app.include_router(auth_router.router,prefix='/auth', tags=['Authentication'])
+app.include_router(users.router,prefix='/users',tags=["Users"])
+app.include_router(tasks.router,prefix='/tasks', tags=['Tasks'])
\ No newline at end of file

app/models/tasks.py

+from sqlalchemy import Column, Integer, String, Boolean, ForeignKey
+from sqlalchemy.orm import relationship
+from ..db import Base
+
+class Task(Base):
+    __tablename__= "tasks"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, nullable=False)
+    description = Column(String, nullable=True)
+    completed = Column(Boolean, default=False)
+    owner_id = Column(Integer, ForeignKey("users.id"))
+
+    owner = relationship("User", back_populates="tasks")
\ No newline at end of file

app/models/users.py

+from sqlalchemy import Column, Integer, String
+from sqlalchemy.orm import relationship
+from ..db import Base
+from .tasks import Task
+
+class User(Base):
+    __tablename__ ="users"
+
+    id = Column(Integer, primary_key=True,index=True)
+    username = Column(String, nullable=False)
+    email = Column(String,unique= True, nullable=False)
+    password=Column(String,nullable=False)
+
+    tasks = relationship("Task", back_populates="owner")
\ No newline at end of file

app/routers/auth.py

+from fastapi import APIRouter
+
+router= APIRouter()
+
+@router.get('/')
+def auth():
+    return{"message":"This is authentication"}
\ No newline at end of file

app/routers/tasks.py

+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app.models.tasks import Task
+from app.models.users import User
+from app.schemas.task import TaskCreate, TaskResponse, TaskUpdate
+from app.db import get_db
+from app.auth.dependencies import get_current_user
+
+router = APIRouter()
+
+@router.post("/", response_model=TaskResponse, status_code=201)
+def create_task(task: TaskCreate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    new_task = Task(**task.dict(), owner_id=current_user.id)
+    db.add(new_task)
+    db.commit()
+    db.refresh(new_task)
+    return new_task
+
+@router.get("/", response_model=list[TaskResponse])
+def get_tasks(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    return db.query(Task).filter(Task.owner_id == current_user.id).all()
+
+@router.get("/{task_id}", response_model=TaskResponse)
+def get_task(task_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    task = db.query(Task).filter(Task.id == task_id, Task.owner_id == current_user.id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    return task
+
+@router.put("/{task_id}", response_model=TaskResponse)
+def update_task(task_id: int, task_update: TaskUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    task = db.query(Task).filter(Task.id == task_id, Task.owner_id == current_user.id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    for key, value in task_update.dict(exclude_unset=True).items():
+        setattr(task, key, value)
+    db.commit()
+    db.refresh(task)
+    return task
+
+@router.delete("/{task_id}", status_code=204)
+def delete_task(task_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    task = db.query(Task).filter(Task.id == task_id, Task.owner_id == current_user.id).first()
+    if not task:
+        raise HTTPException(status_code=404, detail="Task not found")
+    db.delete(task)
+    db.commit()

app/routers/users.py

+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from app.models.users import User
+from app.schemas.user import UserOut, UserUpdate
+from app.db import get_db
+from app.auth.dependencies import get_current_user
+
+router = APIRouter()
+
+@router.get("/", response_model=list[UserOut])
+def get_users(db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    return db.query(User).all()
+
+@router.get("/{user_id}", response_model=UserOut)
+def get_user(user_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+@router.put("/{user_id}", response_model=UserOut)
+def update_user(user_id: int, user_update: UserUpdate, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    for key, value in user_update.dict(exclude_unset=True).items():
+        setattr(user, key, value)
+    db.commit()
+    db.refresh(user)
+    return user
+
+@router.delete("/{user_id}", status_code=204)
+def delete_user(user_id: int, db: Session = Depends(get_db), current_user: User = Depends(get_current_user)):
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    db.delete(user)
+    db.commit()

app/schemas/task.py

+from pydantic import BaseModel
+from typing import Optional
+
+
+class TaskBase(BaseModel):
+    title: str
+    description: Optional[str] = None
+    completed: bool = False
+
+class TaskCreate(TaskBase):
+    pass
+
+class TaskUpdate(BaseModel):
+    title: Optional[str] = None
+    description: Optional[str] = None
+    completed: Optional[bool] = None
+
+class TaskResponse(TaskBase):
+    id: int
+    owner_id: int
+
+    class Config:
+        orm_mode = True
+
+    class Config:
+        orm_mode = True
\ No newline at end of file

app/schemas/user.py

+from pydantic import BaseModel, EmailStr
+class UserBase(BaseModel):
+    username: str
+    email: EmailStr
+
+class UserCreate(UserBase):
+    password: str
+
+class UserOut(BaseModel):
+    id: int
+    username: str
+    email: str
+
+    class Config:
+        orm_mode = True
+
+class UserUpdate(BaseModel):
+    username: str | None = None
+    email: str | None = None
+
+class UserResponse(UserBase):
+    id: int
+
+    class Config:
+        orm_mode = True
\ No newline at end of file