Feat/test achievements

.gitignore

@@ -1,7 +1,11 @@
+test.db
+test.db-journal
+
 .vscode/
 *.jpg
 *.PNG
 infra/.env
+test.db
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

app/api/endpoints/achievement.py

@@ -1,32 +1,83 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, Response, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.validators import check_name_duplicate
 from app.core.db import get_async_session
 from app.core.user import current_superuser, current_user
 from app.crud import achievement_crud
-from app.schemas.achievement import AchievementCreate, AchievementRead
+from app.models import Achievement, User
+from app.schemas.achievement import (AchievementCreate, AchievementRead,
+                                     AchievementUpdate)
 from app.services.endpoints_services import delete_obj
+from app.services.utils import (Pagination, add_response_headers,
+                                get_pagination_params, paginated)
 
 router = APIRouter()
 
 
 @router.get(
     "/",
     response_model=list[AchievementRead],
-    dependencies=[Depends(current_user)]
+    dependencies=[Depends(current_superuser)]
 )
 async def get_all_achievements(
+    response: Response,
+    pagination: Pagination = Depends(get_pagination_params),
     session: AsyncSession = Depends(get_async_session),
 ) -> list[AchievementRead]:
     """Возвращает все achievement."""
-    return await achievement_crud.get_multi(session)
+    achievements = await achievement_crud.get_multi(session)
+    response = add_response_headers(
+        response, achievements, pagination
+    )
+    return paginated(achievements, pagination)
+
+
+@router.get(
+        '/me',
+        response_model=list[AchievementRead],
+        dependencies=[Depends(current_user)]
+)
+async def get_self_achievements(
+    user: User = Depends(current_user),
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Возвращает ачивментс юзера."""
+    return await achievement_crud.get_users_obj(user.id, session)
+
+
+@router.get(
+        '/me/{achievement_id}',
+        response_model=AchievementRead,
+        dependencies=[Depends(current_user)]
+)
+async def get_self_achievement_by_id(
+    achievement_id: int,
+    user: User = Depends(current_user),
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Возвращает ачивмент юзера по id."""
+    achievement: Achievement = await achievement_crud.get(
+        achievement_id, session
+    )
+    if achievement is None:
+        raise HTTPException(
+            status_code=404,
+            detail='Achievement не существует.'
+        )
+    if user.id not in [_.id for _ in achievement.profiles]:
+        raise HTTPException(
+            status_code=403,
+            detail='У выс нет этого achievement.'
+        )
+    return achievement
 
 
 @router.post(
     "/",
     response_model=AchievementRead,
-    dependencies=[Depends(current_superuser)]
+    dependencies=[Depends(current_superuser)],
+    status_code=status.HTTP_201_CREATED
 )
 async def create_achievement(
     achievement: AchievementCreate,
@@ -37,7 +88,25 @@ async def create_achievement(
     return await achievement_crud.create(obj_in=achievement, session=session)
 
 
-@router.delete("/{obj_id}", dependencies=[Depends(current_superuser)])
+@router.patch(
+        '/{achievement_id}',
+        response_model=AchievementRead,
+        dependencies=[Depends(current_superuser)]
+)
+async def update_achievement(
+    achievement_id: int,
+    data: AchievementUpdate,
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Апдейт ачивмент."""
+    _achievement = await achievement_crud.get(achievement_id, session)
+    return await achievement_crud.update(
+        _achievement, data, session
+    )
+
+
+@router.delete("/{obj_id}", dependencies=[Depends(current_superuser)],
+               status_code=status.HTTP_204_NO_CONTENT)
 async def delete_achievement(
     obj_id: int,
     session: AsyncSession = Depends(get_async_session),

app/api/endpoints/group.py

@@ -1,32 +1,93 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, Response, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.validators import check_name_duplicate
 from app.core.db import get_async_session
 from app.core.user import current_superuser, current_user
 from app.crud import group_crud
-from app.schemas.group import GroupCreate, GroupRead
+from app.models import Group, User
+from app.schemas.group import GroupCreate, GroupRead, GroupUpdate
 from app.services.endpoints_services import delete_obj
+from app.services.utils import (Pagination, add_response_headers,
+                                get_pagination_params, paginated)
 
 router = APIRouter()
 
 
 @router.get(
     "/",
     response_model=list[GroupRead],
-    dependencies=[Depends(current_user)]
+    dependencies=[Depends(current_superuser)]
 )
 async def get_all_groups(
+    response: Response,
     session: AsyncSession = Depends(get_async_session),
+    pagination: Pagination = Depends(get_pagination_params)
 ) -> list[GroupRead]:
     """Возвращает все группы."""
-    return await group_crud.get_multi(session)
+    groups = await group_crud.get_multi(session)
+    response = add_response_headers(
+        response, groups, pagination
+    )
+    return paginated(groups, pagination)
+
+
+@router.get(
+        '/me',
+        response_model=list[GroupRead],
+        dependencies=[Depends(current_user)]
+)
+async def get_self_groups(
+    user: User = Depends(current_user),
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Получение групп юзером."""
+    return await group_crud.get_users_obj(user.id, session)
+
+
+@router.get(
+        '/me/{group_id}',
+        response_model=GroupRead,
+        dependencies=[Depends(current_user)]
+)
+async def get_self_group_by_id(
+    group_id: int,
+    user: User = Depends(current_user),
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Получение группы по id юзером."""
+    group: Group | None = await group_crud.get(group_id, session)
+    if group is None:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail='Такой группы не существует.'
+        )
+    if user not in group.users:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail='Вы не состоите в этой группе.'
+        )
+    return group
+
+
+@router.get(
+        '/{group_id}',
+        response_model=GroupRead,
+        dependencies=[Depends(current_superuser)]
+)
+async def get_group(
+    group_id: int,
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Получение группы по id"""
+    return await group_crud.get(group_id, session)
 
 
 @router.post(
     "/",
     response_model=GroupRead,
-    dependencies=[Depends(current_superuser)]
+    dependencies=[Depends(current_superuser)],
+    status_code=status.HTTP_201_CREATED
 )
 async def create_group(
     group: GroupCreate, session: AsyncSession = Depends(get_async_session)
@@ -36,9 +97,25 @@ async def create_group(
     return await group_crud.create(obj_in=group, session=session)
 
 
+@router.patch(
+        '/{group_id}',
+        dependencies=[Depends(current_superuser)],
+        response_model=GroupRead
+)
+async def update_group(
+    group_id: int,
+    group: GroupUpdate,
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Апдейт группы."""
+    _group = await group_crud.get(group_id, session)
+    return await group_crud.update(_group, group, session)
+
+
 @router.delete(
     "/{obj_id}",
-    dependencies=[Depends(current_superuser)]
+    dependencies=[Depends(current_superuser)],
+    status_code=status.HTTP_204_NO_CONTENT
 )
 async def delete_group(
     obj_id: int,

app/api/endpoints/profile.py

@@ -49,10 +49,16 @@ async def get_current_user_profile(
     )
 
 
-@router.get(
-    '/me//photo',
-    dependencies=[Depends(current_user)]
-)
+@router.get('/{profile_id}', response_model=ProfileRead,
+            dependencies=[Depends(current_superuser)])
+async def get_profile(
+    profile_id: int,
+    session: AsyncSession = Depends(get_async_session)
+):
+    return await profile_crud.get(profile_id, session)
+
+
+@router.get('/me/photo', dependencies=[Depends(current_user)])
 async def get_user_photo(
     user: User = Depends(current_user),
     session: AsyncSession = Depends(get_async_session)
@@ -76,7 +82,7 @@ async def update_profile(
 
 
 @router.patch(
-    '/me//update_photo',
+    '/me/update_photo',
     response_model=ProfileRead,
     dependencies=[Depends(current_user)]
 )
@@ -109,7 +115,7 @@ def create_profile():
 
 
 @router.delete('/{obj_id}', deprecated=True)
-def delete_profile(obg_id: str):
+def delete_profile():
     """Удалить объект"""
     raise HTTPException(
         status_code=status.HTTP_405_METHOD_NOT_ALLOWED,

app/crud/achievement.py

@@ -1,9 +1,33 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
 from app.crud.base import CRUDBase
-from app.models import Achievement
+from app.models import Achievement, Profile
 
 
 class CRUDAchievement(CRUDBase):
-    pass
+    async def get(self, obj_id: int, session: AsyncSession):
+        stmt = (
+            select(Achievement)
+            .where(Achievement.id == obj_id)
+            .options(
+                selectinload(Achievement.profiles)
+            )
+        )
+        achievement = await session.execute(stmt)
+        achievement = achievement.scalars().first()
+        return achievement
+
+    async def get_users_obj(self, user_id: int, session: AsyncSession):
+        stmt = (
+            select(Achievement)
+            .options(
+                selectinload(Achievement.profiles)
+            ).where(Achievement.profiles.any(Profile.user_id == user_id))
+        )
+        db_obj = await session.execute(stmt)
+        return db_obj.scalars().all()
 
 
 achievement_crud = CRUDAchievement(Achievement)

app/crud/group.py

@@ -1,9 +1,34 @@
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
 from app.crud.base import CRUDBase
-from app.models import Group
+from app.models import Group, User
 
 
 class CRUDGroup(CRUDBase):
-    pass
+    async def get(self, group_id: int, session: AsyncSession):
+        stmt = (
+            select(Group)
+            .where(Group.id == group_id)
+            .options(
+                selectinload(Group.users)
+            )
+        )
+        group = await session.execute(stmt)
+        group = group.scalars().first()
+        return group
+
+    async def get_users_obj(self, user_id: int, session: AsyncSession):
+        stmt = (
+            select(Group)
+            # .where(Group.users == user_id)
+            .options(
+                selectinload(Group.users)
+            ).where(Group.users.any(User.id == user_id))
+        )
+        db_obj = await session.execute(stmt)
+        return db_obj.scalars().all()
 
 
 group_crud = CRUDGroup(Group)

app/crud/profile.py

@@ -35,6 +35,15 @@ async def get_multi(self, session: AsyncSession):
         )
         return db_objs.scalars().all()
 
+    async def get(self, obj_id: int, session: AsyncSession):
+        profile = await session.execute(
+            select(self.model)
+            .options(
+                selectinload(Profile.achievements)
+            )
+        )
+        return profile.scalars().first()
+
     async def get_user_photo(
             self,
             user_id: int,

app/models/profile.py

@@ -38,7 +38,7 @@ class Profile(Base):
         ForeignKey('user.id'), unique=True
     )
     user: Mapped[User] = relationship(back_populates='profile')
-    achievements: Mapped[Achievement] = relationship(
+    achievements: Mapped[list[Achievement]] = relationship(
         secondary=achievement_profile_association, back_populates="profiles"
     )
     image: Mapped[str] = Column(
@@ -48,4 +48,6 @@ class Profile(Base):
     )
 
     def __repr__(self):
-        return self.first_name
+        if self.first_name:
+            return self.first_name
+        return str(self.user_id)