feat: добавить теги и связи many-to-many с задачами

RomanVetrov · RomanVetrov · commit 355f5fbeff53 · 2026-03-09T02:51:40.000+03:00
Что сделано:
- добавлена модель тега и слой данных для CRUD
- реализованы схемы и сервис для управления тегами
- добавлены роуты /tags и привязка тега к задаче
- вынесены общие dependency-хелперы get_or_404 для задач и тегов
diff --git a/app/get_or_404.py b/app/get_or_404.py
@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Annotated
+from uuid import UUID
+
+from fastapi import Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models.tag import Tag
+from app.models.task import Task
+from app.models.user import User
+from app.repositories import tag_repo, task_repo
+from app.security.dependences import get_current_user
+
+
+async def get_task_or_404(
+    task_id: UUID,
+    session: AsyncSession = Depends(get_db),
+    current_user: User = Depends(get_current_user),
+) -> Task:
+    """Возвращает задачу по id. 404 если не найдена, 403 если чужая."""
+    task = await task_repo.get_task_by_id(session, task_id)
+    if not task:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Задача не найдена"
+        )
+    if task.user_id != current_user.id:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Нет доступа")
+    return task
+
+
+async def get_tag_or_404(
+    tag_id: UUID,
+    session: AsyncSession = Depends(get_db),
+) -> Tag:
+    """Возвращает тег по id или 404 если не найден."""
+    tag = await tag_repo.get_tag_by_id(session, tag_id)
+    if not tag:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND, detail="Тег не найден"
+        )
+    return tag
+
+
+TagDep = Annotated[Tag, Depends(get_tag_or_404)]
+CurrentUser = Annotated[User, Depends(get_current_user)]
+TaskDep = Annotated[Task, Depends(get_task_or_404)]
diff --git a/app/models/tag.py b/app/models/tag.py
@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING
+
+from sqlalchemy import Column, ForeignKey, String, Table
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database import Base
+from app.models.mixins import CreatedAtMixin
+
+if TYPE_CHECKING:
+    from app.models.task import Task
+
+# Связь Task <-> Tag (многие ко многим).
+# task_tags определён здесь; Task импортирует его когда понадобится relationship.
+task_tags = Table(
+    "task_tags",
+    Base.metadata,
+    Column(
+        "task_id",
+        UUID(as_uuid=True),
+        ForeignKey("tasks.id", ondelete="CASCADE"),
+        primary_key=True,
+    ),
+    Column(
+        "tag_id",
+        UUID(as_uuid=True),
+        ForeignKey("tags.id", ondelete="CASCADE"),
+        primary_key=True,
+    ),
+)
+
+
+class Tag(CreatedAtMixin, Base):
+    __tablename__ = "tags"
+
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    # Теги глобальные, имя уникально в системе.
+    name: Mapped[str] = mapped_column(String(50), nullable=False, unique=True)
+    # Формат #RRGGBB, валидация на уровне схемы Pydantic.
+    color: Mapped[str] = mapped_column(String(7), nullable=False)
+    tasks: Mapped[list[Task]] = relationship(
+        secondary=task_tags,
+        back_populates="tags",
+    )
diff --git a/app/repositories/tag_repo.py b/app/repositories/tag_repo.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+from uuid import UUID
+
+from sqlalchemy import delete, insert, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.tag import Tag, task_tags
+from app.models.task import Task
+
+
+async def get_tag_by_id(session: AsyncSession, tag_id: UUID) -> Tag | None:
+    """Возвращает тег по id или None."""
+    return await session.get(Tag, tag_id)
+
+
+async def get_tag_by_name(session: AsyncSession, name: str) -> Tag | None:
+    """Возвращает тег по имени или None."""
+    result = await session.execute(select(Tag).where(Tag.name == name))
+    return result.scalar_one_or_none()
+
+
+async def list_tags(session: AsyncSession) -> Sequence[Tag]:
+    """Возвращает список тегов по имени."""
+    result = await session.execute(select(Tag).order_by(Tag.name.asc()))
+    return result.scalars().all()
+
+
+async def create_tag(session: AsyncSession, *, name: str, color: str) -> Tag:
+    """Создаёт и сохраняет тег."""
+    tag = Tag(name=name, color=color)
+    session.add(tag)
+    await session.commit()
+    await session.refresh(tag)
+    return tag
+
+
+async def update_tag(session: AsyncSession, tag: Tag, **data: Any) -> Tag:
+    """Обновляет переданные поля тега."""
+    for field, value in data.items():
+        setattr(tag, field, value)
+    await session.commit()
+    await session.refresh(tag)
+    return tag
+
+
+async def delete_tag(session: AsyncSession, tag: Tag) -> UUID:
+    """Удаляет тег и возвращает его id."""
+    tag_id = tag.id
+    await session.delete(tag)
+    await session.commit()
+    return tag_id
+
+
+async def attach_tag_to_task(session: AsyncSession, task: Task, tag: Tag) -> None:
+    """Привязывает тег к задаче (идемпотентно)."""
+    exists_result = await session.execute(
+        select(task_tags.c.task_id).where(
+            task_tags.c.task_id == task.id,
+            task_tags.c.tag_id == tag.id,
+        )
+    )
+    if exists_result.first():
+        return
+
+    await session.execute(insert(task_tags).values(task_id=task.id, tag_id=tag.id))
+    await session.commit()
+
+
+async def detach_tag_from_task(session: AsyncSession, task: Task, tag: Tag) -> None:
+    """Отвязывает тег от задачи (идемпотентно)."""
+    await session.execute(
+        delete(task_tags).where(
+            task_tags.c.task_id == task.id,
+            task_tags.c.tag_id == tag.id,
+        )
+    )
+    await session.commit()
diff --git a/app/routes/tags.py b/app/routes/tags.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.get_or_404 import CurrentUser, TagDep
+from app.schemas.tag import TagCreate, TagDeleted, TagRead, TagUpdate
+from app.services import tag as tag_service
+from app.services.tag import TagAlreadyExists
+
+router = APIRouter(prefix="/tags", tags=["tags"])
+
+_TAG_EXISTS_ERROR = HTTPException(
+    status_code=status.HTTP_409_CONFLICT,
+    detail="Тег с таким именем уже существует",
+)
+
+
+@router.post(
+    "",
+    response_model=TagRead,
+    status_code=status.HTTP_201_CREATED,
+    summary="Создать тег",
+)
+async def create_tag(
+    payload: TagCreate,
+    _: CurrentUser,
+    session: AsyncSession = Depends(get_db),
+) -> TagRead:
+    try:
+        created = await tag_service.create_tag(session, payload)
+    except TagAlreadyExists:
+        raise _TAG_EXISTS_ERROR
+    return TagRead.model_validate(created)
+
+
+@router.get(
+    "",
+    response_model=list[TagRead],
+    summary="Список тегов",
+)
+async def list_tags(
+    _: CurrentUser,
+    session: AsyncSession = Depends(get_db),
+) -> list[TagRead]:
+    tags = await tag_service.list_tags(session)
+    return [TagRead.model_validate(tag) for tag in tags]
+
+
+@router.get(
+    "/{tag_id}",
+    response_model=TagRead,
+    summary="Получить тег по id",
+)
+async def get_tag(
+    _: CurrentUser,
+    tag: TagDep,
+) -> TagRead:
+    return TagRead.model_validate(tag)
+
+
+@router.patch(
+    "/{tag_id}",
+    response_model=TagRead,
+    summary="Обновить тег",
+)
+async def update_tag(
+    payload: TagUpdate,
+    _: CurrentUser,
+    tag: TagDep,
+    session: AsyncSession = Depends(get_db),
+) -> TagRead:
+    try:
+        updated = await tag_service.update_tag(session, tag, payload)
+    except TagAlreadyExists:
+        raise _TAG_EXISTS_ERROR
+    return TagRead.model_validate(updated)
+
+
+@router.delete(
+    "/{tag_id}",
+    response_model=TagDeleted,
+    summary="Удалить тег",
+)
+async def delete_tag(
+    _: CurrentUser,
+    tag: TagDep,
+    session: AsyncSession = Depends(get_db),
+) -> TagDeleted:
+    tag_id = await tag_service.delete_tag(session, tag)
+    return TagDeleted(id=tag_id)
diff --git a/app/routes/tasks.py b/app/routes/tasks.py
@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.get_or_404 import CurrentUser, TagDep, TaskDep
+from app.schemas.tag import TaskTagLink
+from app.services import tag as tag_service
+from app.schemas.task import TaskCreate, TaskDeleted, TaskRead, TaskUpdate
+from app.services import task as task_service
+from app.services.task import InvalidDueDate
+
+router = APIRouter(prefix="/tasks", tags=["tasks"])
+
+_DUE_DATE_ERROR = HTTPException(
+    status_code=status.HTTP_400_BAD_REQUEST,
+    detail="Дедлайн не может быть в прошлом",
+)
+
+
+@router.post(
+    "",
+    response_model=TaskRead,
+    status_code=status.HTTP_201_CREATED,
+    summary="Создать задачу",
+)
+async def create_task(
+    payload: TaskCreate,
+    current_user: CurrentUser,
+    session: AsyncSession = Depends(get_db),
+) -> TaskRead:
+    try:
+        task = await task_service.create_task(session, current_user, payload)
+    except InvalidDueDate:
+        raise _DUE_DATE_ERROR
+    return TaskRead.model_validate(task)
+
+
+@router.get(
+    "",
+    response_model=list[TaskRead],
+    summary="Список задач текущего пользователя",
+)
+async def list_tasks(
+    current_user: CurrentUser,
+    session: AsyncSession = Depends(get_db),
+) -> list[TaskRead]:
+    tasks = await task_service.get_user_tasks(session, current_user)
+    return [TaskRead.model_validate(t) for t in tasks]
+
+
+@router.get(
+    "/{task_id}",
+    response_model=TaskRead,
+    summary="Получить задачу по id",
+)
+async def get_task(task: TaskDep) -> TaskRead:
+    return TaskRead.model_validate(task)
+
+
+@router.patch(
+    "/{task_id}",
+    response_model=TaskRead,
+    summary="Обновить задачу",
+)
+async def update_task(
+    payload: TaskUpdate,
+    task: TaskDep,
+    session: AsyncSession = Depends(get_db),
+) -> TaskRead:
+    try:
+        updated = await task_service.update_task(session, task, payload)
+    except InvalidDueDate:
+        raise _DUE_DATE_ERROR
+    return TaskRead.model_validate(updated)
+
+
+@router.delete(
+    "/{task_id}",
+    response_model=TaskDeleted,
+    summary="Удалить задачу",
+)
+async def delete_task(
+    task: TaskDep,
+    session: AsyncSession = Depends(get_db),
+) -> TaskDeleted:
+    task_id = await task_service.delete_task(session, task)
+    return TaskDeleted(id=task_id)
+
+
+@router.post(
+    "/{task_id}/tags/{tag_id}",
+    response_model=TaskTagLink,
+    status_code=status.HTTP_201_CREATED,
+    summary="Привязать тег к задаче",
+)
+async def attach_tag_to_task(
+    task: TaskDep,
+    tag: TagDep,
+    session: AsyncSession = Depends(get_db),
+) -> TaskTagLink:
+    await tag_service.attach_tag_to_task(session, task, tag)
+    return TaskTagLink(task_id=task.id, tag_id=tag.id)
+
+
+@router.delete(
+    "/{task_id}/tags/{tag_id}",
+    response_model=TaskTagLink,
+    summary="Отвязать тег от задачи",
+)
+async def detach_tag_from_task(
+    task: TaskDep,
+    tag: TagDep,
+    session: AsyncSession = Depends(get_db),
+) -> TaskTagLink:
+    await tag_service.detach_tag_from_task(session, task, tag)
+    return TaskTagLink(task_id=task.id, tag_id=tag.id)
diff --git a/app/schemas/tag.py b/app/schemas/tag.py
diff --git a/app/services/tag.py b/app/services/tag.py
