edit authentication and config

Author: gitkoDev

.env

@@ -1,3 +1,9 @@
 POSTGRES_USER=postgres
 POSTGRES_PASSWORD=1234
-POSTGRES_DB=postgres
+POSTGRES_DB=postgres
+
+DB_USER = postgres
+DB_PASSWORD = 1234
+DB_HOST = notesdb
+DB_NAME = postgres
+DB_URL = postgresql+asyncpg://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:5432/${DB_NAME}

Makefile

@@ -1,14 +1,11 @@
 run:
-	uvicorn main:app --reload
+	docker compose up --build
 
-review:
-	alembic revision --autogenerate -m "Create User model"
-
 upgrade:
 	alembic upgrade head
 
 downgrade:
 	alembic downgrade base
 
-generate_migrations: upgrade
+generate_migrations:
 	alembic revision --autogenerate -m "Create User and Note models"

alembic.ini

@@ -1,86 +1,11 @@
-# A generic, single database configuration.
-
 [alembic]
-# path to migration scripts
-# Use forward slashes (/) also on windows to provide an os agnostic path
 script_location = migrations
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
 prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to alembic/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "version_path_separator" below.
-# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
+version_path_separator = os  
 sqlalchemy.url = postgresql://postgres:1234@notesdb/postgres
 
-
 [post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = --fix REVISION_SCRIPT_FILENAME
 
-# Logging configuration
 [loggers]
 keys = root,sqlalchemy,alembic
 

models/notes_models.py renamed to api/models/notes_models.py

@@ -1,8 +1,8 @@
-from sqlalchemy import String, Integer, Text, DateTime, ForeignKey, func
-from sqlalchemy.orm import Mapped, mapped_column, DeclarativeBase, relationship
+from sqlalchemy import Integer, Text, DateTime, ForeignKey, func
+from sqlalchemy.orm import Mapped, mapped_column, DeclarativeBase
 
 from datetime import datetime
-from models.user_models import UserModel
+from api.models.user_models import UserModel
 
 
 class Base(DeclarativeBase):

models/user_models.py renamed to api/models/user_models.py

@@ -5,20 +5,23 @@
 from datetime import datetime, timedelta
 from typing import Annotated
 
-from models.user_models import UserModel
-from schemas.user_schemas import (
+from api.models.user_models import UserModel
+from api.schemas.user_schemas import (
     CreateUserInput,
     bcrypt_context,
     SECRET_KEY,
     ALGORITHM,
     oauth2_bearer,
 )
 from config.database import SessionLocal
+from helpers.helpers import NotFoundError
 
 
 class AuthRepository:
     @classmethod
     async def create_user(cls, data: CreateUserInput) -> int:
+        if await cls.is_existing_user(user=data):
+            raise NotFoundError
         async with SessionLocal() as session:
             user = UserModel(
                 name=data.name, password_hash=bcrypt_context.hash(data.password)
@@ -40,6 +43,16 @@ async def authenticate_user(cls, name: str, password: str):
                 return False
             return user
 
+    @classmethod
+    async def is_existing_user(cls, user: UserModel) -> bool:
+        async with SessionLocal() as session:
+            query = select(UserModel).where(UserModel.name == user.name)
+            result = await session.execute(query)
+            user = result.scalars().one_or_none()
+            if not user:
+                return False
+            return True
+
     @classmethod
     def create_access_token(cls, name: str, id: int, ttl: timedelta):
         data_to_encode = {"sub": name, "id": id}

repository/auth_repository.py renamed to api/repository/auth_repository.py

@@ -1,27 +1,27 @@
 from sqlalchemy.future import select
 
 from config.database import SessionLocal
-from schemas.notes_schemas import NoteOutput, NoteInput
-from models.notes_models import NoteModel
+from api.schemas.notes_schemas import NoteOutput, NoteInput
+from api.models.notes_models import NoteModel
 from helpers.helpers import NotFoundError
 
 
 class NotesRepository:
     @classmethod
-    async def add_note(cls, data: NoteInput) -> int:
+    async def add_note(cls, data: NoteInput, user_id: int) -> int:
         async with SessionLocal() as session:
             note_dict = data.model_dump()
             note = NoteModel(**note_dict)
-            print(note, "HEREEEEE")
+            note.user_id = user_id
             session.add(note)
             await session.commit()
             await session.refresh(note)
             return note.id
 
     @classmethod
-    async def get_notes(cls) -> list[NoteOutput]:
+    async def get_notes(cls, user_id: int) -> list[NoteOutput]:
         async with SessionLocal() as session:
-            query = select(NoteModel)
+            query = select(NoteModel).where(NoteModel.user_id == user_id)
             result = await session.execute(query)
             note_models = result.scalars().all()
             notes_schemas = [
@@ -30,9 +30,11 @@ async def get_notes(cls) -> list[NoteOutput]:
             return notes_schemas
 
     @classmethod
-    async def get_note(cls, note_id: int) -> NoteOutput:
+    async def get_note(cls, note_id: int, user_id: int) -> NoteOutput:
         async with SessionLocal() as session:
-            query = select(NoteModel).where(NoteModel.id == note_id)
+            query = select(NoteModel).where(
+                NoteModel.id == note_id, NoteModel.user_id == user_id
+            )
             result = await session.execute(query)
             note_model = result.scalars().one_or_none()
             if not note_model:
@@ -41,9 +43,13 @@ async def get_note(cls, note_id: int) -> NoteOutput:
             return note
 
     @classmethod
-    async def update_note(cls, note_id: int, data: NoteInput) -> NoteOutput:
+    async def update_note(
+        cls, note_id: int, data: NoteInput, user_id: int
+    ) -> NoteOutput:
         async with SessionLocal() as session:
-            query = select(NoteModel).where(NoteModel.id == note_id)
+            query = select(NoteModel).where(
+                NoteModel.id == note_id, NoteModel.user_id == user_id
+            )
             result = await session.execute(query)
             note_model = result.scalars().one_or_none()
             if not note_model:
@@ -58,9 +64,11 @@ async def update_note(cls, note_id: int, data: NoteInput) -> NoteOutput:
             return note
 
     @classmethod
-    async def delete_note(cls, note_id: int):
+    async def delete_note(cls, note_id: int, user_id: int):
         async with SessionLocal() as session:
-            query = select(NoteModel).where(NoteModel.id == note_id)
+            query = select(NoteModel).where(
+                NoteModel.id == note_id, NoteModel.user_id == user_id
+            )
             result = await session.execute(query)
             note_model = result.scalars().one_or_none()
             if not note_model:

repository/notes_repository.py renamed to api/repository/notes_repository.py

@@ -3,10 +3,11 @@
 from starlette import status
 
 from typing import Annotated
-from datetime import datetime, timedelta
+from datetime import timedelta
 
-from repository.auth_repository import AuthRepository
-from schemas.user_schemas import CreateUserInput, Token
+from api.repository.auth_repository import AuthRepository
+from api.schemas.user_schemas import CreateUserInput, Token
+from helpers.helpers import NotFoundError
 
 
 router = APIRouter(
@@ -16,13 +17,21 @@
 
 
 @router.post("", status_code=status.HTTP_201_CREATED)
-async def create_user(data: Annotated[CreateUserInput, Depends()]):
-    user_id = await AuthRepository.create_user(data)
+async def create_user(data: Annotated[CreateUserInput, Depends()]) -> dict:
+    try:
+        user_id = await AuthRepository.create_user(data)
+    except NotFoundError:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="User with this name already exists",
+        )
     return {"id": user_id}
 
 
 @router.post("/token", response_model=Token)
-async def get_access_token(data: Annotated[OAuth2PasswordRequestForm, Depends()]):
+async def get_access_token(
+    data: Annotated[OAuth2PasswordRequestForm, Depends()]
+) -> dict:
     user = await AuthRepository.authenticate_user(data.username, data.password)
     if not user:
         raise HTTPException(

router/auth_routes.py renamed to api/router/auth_routes.py

@@ -0,0 +1,93 @@
+from fastapi import APIRouter, Depends, HTTPException
+from starlette import status
+
+from typing import Annotated
+
+from api.schemas.notes_schemas import NoteInput, NoteOutput
+from api.repository.notes_repository import NotesRepository
+from api.repository.auth_repository import AuthRepository
+from helpers.helpers import NotFoundError
+
+
+router = APIRouter(
+    prefix="/api/v1",
+    tags=["Notes"],
+)
+
+
+@router.post("", status_code=status.HTTP_201_CREATED)
+async def add_note(
+    user: Annotated[dict, Depends(AuthRepository.parse_access_token)],
+    data: Annotated[NoteInput, Depends()],
+) -> dict:
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication failed"
+        )
+    note_id = await NotesRepository.add_note(data, user.get("user_id"))
+    return {"okay": note_id}
+
+
+@router.get("", response_model=list[NoteOutput])
+async def get_notes(
+    user: Annotated[dict, Depends(AuthRepository.parse_access_token)]
+) -> list[NoteOutput]:
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication failed"
+        )
+    notes = await NotesRepository.get_notes(user.get("user_id"))
+    return notes
+
+
+@router.get("/{note_id}", response_model=NoteOutput)
+async def get_note(
+    user: Annotated[dict, Depends(AuthRepository.parse_access_token)], note_id: int
+) -> NoteOutput:
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication failed"
+        )
+    try:
+        note = await NotesRepository.get_note(note_id, user.get("user_id"))
+    except NotFoundError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Note with id {note_id} not found",
+        )
+    return note
+
+
+@router.put("/{note_id}", response_model=NoteOutput)
+async def update_note(
+    user: Annotated[dict, Depends(AuthRepository.parse_access_token)],
+    note_id: int,
+    data: Annotated[NoteInput, Depends()],
+) -> NoteOutput:
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication failed"
+        )
+    try:
+        note = await NotesRepository.update_note(note_id, data, user.get("user_id"))
+    except NotFoundError:
+        raise HTTPException(status_code=404, detail=f"Note with id {note_id} not found")
+    return note
+
+
+@router.delete("/{note_id}")
+async def delete_note(
+    user: Annotated[dict, Depends(AuthRepository.parse_access_token)], note_id: int
+) -> dict:
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Authentication failed"
+        )
+    try:
+        await NotesRepository.delete_note(note_id, user.get("user_id"))
+    except NotFoundError:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Note with id {note_id} not found",
+        )
+    return {"okay": note_id}

api/router/note_routes.py

@@ -5,12 +5,11 @@
 
 class NoteInput(BaseModel):
     content: str
-    user_id: int
-    created_at: datetime = datetime.now()
-    updated_at: datetime = datetime.now()
 
 
 class NoteOutput(NoteInput):
     id: int
+    created_at: datetime = datetime.now()
+    updated_at: datetime = datetime.now()
 
     model_config = ConfigDict(from_attributes=True)