Feat/endpoints tariff

.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,11 +1,13 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException, 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
 
 router = APIRouter()
@@ -14,7 +16,7 @@
 @router.get(
     "/",
     response_model=list[AchievementRead],
-    dependencies=[Depends(current_user)]
+    dependencies=[Depends(current_superuser)]
 )
 async def get_all_achievements(
     session: AsyncSession = Depends(get_async_session),
@@ -23,10 +25,51 @@ async def get_all_achievements(
     return await achievement_crud.get_multi(session)
 
 
+@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 +80,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,11 +1,12 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, HTTPException
 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
 
 router = APIRouter()
@@ -14,7 +15,7 @@
 @router.get(
     "/",
     response_model=list[GroupRead],
-    dependencies=[Depends(current_user)]
+    dependencies=[Depends(current_superuser)]
 )
 async def get_all_groups(
     session: AsyncSession = Depends(get_async_session),
@@ -23,10 +24,62 @@ async def get_all_groups(
     return await group_crud.get_multi(session)
 
 
+@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=404,
+            detail='Такой группы не существует.'
+        )
+    if user not in group.users:
+        raise HTTPException(
+            status_code=403,
+            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=201
 )
 async def create_group(
     group: GroupCreate, session: AsyncSession = Depends(get_async_session)
@@ -36,9 +89,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=204
 )
 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/api/endpoints/tariff.py

@@ -1,13 +1,11 @@
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.api.validators import check_name_duplicate, check_obj_exists
 from app.core.db import get_async_session
-from app.core.user import current_superuser, current_user
-from app.crud import tariff_crud, user_crud
-from app.models import User
-from app.schemas.tariff import TariffCreate, TariffRead
-from app.schemas.user import UserRead
+from app.core.user import current_superuser
+from app.crud import tariff_crud
+from app.schemas.tariff import TariffCreate, TariffRead, TariffUpdate
 from app.services.endpoints_services import delete_obj
 
 router = APIRouter()
@@ -16,7 +14,6 @@
 @router.get(
     "/",
     response_model=list[TariffRead],
-    dependencies=[Depends(current_user)]
 )
 async def get_all_tariffs(
     session: AsyncSession = Depends(get_async_session),
@@ -25,28 +22,59 @@ async def get_all_tariffs(
     return await tariff_crud.get_multi(session)
 
 
-@router.put(
-    "/",
-    response_model=UserRead,
-    dependencies=[Depends(current_user)]
+@router.get(
+        '/{tariff_id}',
+        response_model=TariffRead
 )
-async def update_users_tariff(
+async def get_tariff(
     tariff_id: int,
-    user: User = Depends(current_user),
-    session: AsyncSession = Depends(get_async_session),
-) -> UserRead:
-    """Привязывает тариф к юзеру"""
-    await check_obj_exists(tariff_id, tariff_crud, session)
-    user = await user_crud.update_id(
-        session=session, db_obj=user, field="tariff_id", field_value=tariff_id
+    session: AsyncSession = Depends(get_async_session)
+):
+    return await tariff_crud.get(tariff_id, session)
+
+
+@router.patch(
+        '/{tariff_id}',
+        response_model=TariffRead,
+        dependencies=[Depends(current_superuser)]
+)
+async def update_tariff(
+    tariff_id: int,
+    data: TariffUpdate,
+    session: AsyncSession = Depends(get_async_session)
+):
+    """Апдейт тарифа."""
+    _tariff = await check_obj_exists(tariff_id, tariff_crud, session)
+    return await tariff_crud.update(
+        _tariff, data, session
     )
-    return user
+
+
+# Перенести в эндпоинты юзера?
+# @router.patch(
+#     "/{tariff_id}",
+#     response_model=UserRead,
+#     dependencies=[Depends(current_user)]
+# )
+# async def update_users_tariff(
+#     tariff_id: int,
+#     user: User = Depends(current_user),
+#     session: AsyncSession = Depends(get_async_session),
+# ) -> UserRead:
+#     """Привязывает тариф к юзеру"""
+#     await check_obj_exists(tariff_id, tariff_crud, session)
+#     user = await user_crud.update_id(
+#         session=session, db_obj=user, field="tariff_id",
+#         field_value=tariff_id
+#     )
+#     return user
 
 
 @router.post(
     "/",
     response_model=TariffRead,
-    dependencies=[Depends(current_superuser)]
+    dependencies=[Depends(current_superuser)],
+    status_code=status.HTTP_201_CREATED
 )
 async def create_tariff(
     tariff: TariffCreate, session: AsyncSession = Depends(get_async_session)
@@ -58,7 +86,8 @@ async def create_tariff(
 
 @router.delete(
     "/{obj_id}",
-    dependencies=[Depends(current_superuser)]
+    dependencies=[Depends(current_superuser)],
+    status_code=status.HTTP_204_NO_CONTENT
 )
 async def delete_tariff(
     obj_id: int,

app/api/validators.py

@@ -16,6 +16,7 @@ async def check_obj_exists(
             detail=f"Объект {crud.model.__tablename__} "
                    f"f с id {obj_id} не найден.",
         )
+    return obj
 
 
 async def check_name_duplicate(