add task post

src/api/v1/tasks.py

@@ -1,17 +1,21 @@
-from fastapi import APIRouter
+from typing import Annotated
+
+from fastapi import APIRouter, Depends
 from sqlalchemy import select
 
 from src.api.dependacies.db_dep import sessionDep
 from src.api.dependacies.user_dep import ActiveUser
 from src.models.tasks import TasksORM
+from src.schemas.tasks import TaskADDRequest
+from src.services.tasks import TaskService
 
 router = APIRouter(prefix="/tasks", tags=["Tasks"])
 
 
 @router.get("/")
-async def get_tasks(db: sessionDep, user: ActiveUser):
+async def get_tasks(session: sessionDep, user: ActiveUser):
     query = select(TasksORM.id, TasksORM.description).where(TasksORM.user_id == user.id)
-    tasks = await db.session.execute(query)
+    tasks = await session.session.execute(query)
     result = tasks.scalars().all()
     return result
 
@@ -21,7 +25,15 @@ async def get_task_id(task_id: int): ...
 
 
 @router.post("/")
-async def post_task(): ...
+async def post_task(
+    task_data: Annotated[TaskADDRequest, Depends()],
+    session: sessionDep,
+    user: ActiveUser,
+):
+    result = await TaskService(session).create_task(
+        user_id=user.id, task_data=task_data
+    )
+    return result
 
 
 @router.put("/{task_id}")

src/api/v1/users.py

@@ -30,7 +30,9 @@ async def get_user_by_id(session: sessionDep, id: int, _: CurrentOrAdmin):
 async def patch_user(
     session: sessionDep, id: int, _: CurrentOrAdmin, user_update: UserUpdate = Body()
 ):
-    updated_user = await UserService(session).update_user(id=id, update_data=user_update)
+    updated_user = await UserService(session).update_user(
+        id=id, update_data=user_update
+    )
     return updated_user
 
 

src/repository/base.py

@@ -1,37 +1,41 @@
-from typing import Any
+from typing import Any, Generic, Mapping, Sequence, Type, TypeVar
 
-from pydantic import BaseModel
 from sqlalchemy import delete, insert, select
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from src.core.database import Base
 
+ModelType = TypeVar("ModelType", bound=Base)
 
-class BaseRepo:
-    model: type[Base]
 
-    def __init__(self, session):
-        self.session = session
+class BaseRepo(Generic[ModelType]):
+    model: Type[ModelType]
 
-    async def get_filtered(self, *filter, **filter_by) -> list[Base]:
-        query = select(self.model).filter(*filter).filter_by(**filter_by)
+    def __init__(self, session: AsyncSession) -> None:
+        self.session: AsyncSession = session
+
+    async def get_filtered(
+        self, *filters: Any, **filter_by: Any
+    ) -> Sequence[ModelType]:
+        query = select(self.model).filter(*filters).filter_by(**filter_by)
         result = await self.session.execute(query)
         models = result.scalars().all()
         return models
 
-    async def create_one(self, data: BaseModel) -> Base:
-        statement = insert(self.model).values(data.model_dump()).returning(self.model)
+    async def create_one(self, data: Mapping[str, Any]) -> ModelType:
+        statement = insert(self.model).values(data).returning(self.model)
         result = await self.session.execute(statement)
-        obj = result.scalar_one()
+        obj: ModelType = result.scalar_one()
         return obj
 
-    async def get_one_or_none(self, **filter_by: Any) -> Base | None:
+    async def get_one_or_none(self, **filter_by: Any) -> ModelType | None:
         query = select(self.model).filter_by(**filter_by)
         result = await self.session.execute(query)
-        model = result.scalars().one_or_none()
-        return model
+        model_obj: ModelType | None = result.scalars().one_or_none()
+        return model_obj
 
-    async def get_all(self, *args, **kwargs) -> list[Base]:
-        result = await self.get_filtered(*args, **kwargs)
+    async def get_all(self, *args: Any, **kwargs: Any) -> Sequence[ModelType]:
+        result: Sequence[ModelType] = await self.get_filtered(*args, **kwargs)
         return result
 
     async def delete_one(self, **filter_by) -> None:

src/schemas/tasks.py

@@ -0,0 +1,20 @@
+from datetime import date
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+class TaskADDRequest(BaseModel):
+    title: str
+    description: str | None = None
+    due_date: date | None = None
+    priority: Literal["low", "medium", "high", "critical"] = "medium"
+
+
+class Task(TaskADDRequest):
+    id: int
+    user_id: int
+    status: Literal["open", "closed", "in_progress", "todo"]
+    time_spent: int
+    
+    model_config = ConfigDict(from_attributes=True)

src/services/auth.py

@@ -15,7 +15,7 @@ class AuthService(BaseService):
             email=cred.email,
             hashed_password=hashed_pass,
         )
-        result = await self.session.user.create_one(user_to_insert)
+        result = await self.session.user.create_one(user_to_insert.model_dump())
         await self.session.commit()
         return User.model_validate(result)
 

src/services/tasks.py

@@ -1,4 +1,19 @@
+from fastapi import HTTPException
+
+from src.models.tasks import TasksORM
+from src.schemas.tasks import Task, TaskADDRequest
 from src.services.base import BaseService
 
 
-class TasksService(BaseService): ...
+class TaskService(BaseService):
+    model = TasksORM
+
+    async def create_task(self, user_id: int, task_data: TaskADDRequest) -> Task:
+        user = await self.session.user.get_one_or_none(id=user_id)
+        if user is None:
+            raise HTTPException(status_code=404, detail="User not found.")
+        data_to_insert = task_data.model_dump(exclude_none=True)
+        data_to_insert["user_id"] = user.id
+        created_task_orm = await self.session.task.create_one(data_to_insert)
+        await self.session.commit()
+        return Task.model_validate(created_task_orm)

src/services/users.py

@@ -33,6 +33,8 @@ class UserService(BaseService):
 
     async def update_user(self, id: int, update_data: UserUpdate) -> User:
         await self.get_user_by_filter_or_raise(id=id)
-        user = await self.session.user.update_one(id=id, data=update_data.model_dump(exclude_unset=True))
+        user = await self.session.user.update_one(
+            id=id, data=update_data.model_dump(exclude_unset=True)
+        )
         await self.session.commit()
         return User.model_validate(user)