API для menu

fastfood/crud.py

@@ -1,8 +1,9 @@
-from sqlalchemy import select
+from uuid import UUID
+from sqlalchemy import delete, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from fastfood import models, schemas
-from fastfood.dbase import async_engine, async_session_maker
+from fastfood.dbase import async_engine
 
 
 async def create_db_and_tables():
@@ -17,15 +18,40 @@ class Crud:
         async with session:
             query = select(models.Menu)
             result = await session.execute(query)
-            return result.mappings().all()
+            return result.scalars().all()
 
     @staticmethod
-    async def add_menu(menu: schemas.Menu):
+    async def create_menu_item(menu: schemas.MenuBase, session: AsyncSession):
-        async with async_session_maker() as session:
+        async with session:
-            new_menu_item = models.Menu(
+            new_menu = models.Menu(**menu.model_dump())
-                title=menu.title,
+            session.add(new_menu)
-                description=menu.description,
+            await session.commit()
-            )
+            await session.refresh(new_menu)
-            session.add(new_menu_item)
+            return new_menu
+
+    @staticmethod
+    async def get_menu_item(menu_id: UUID, session: AsyncSession):
+        async with session:
+            query = select(models.Menu).where(models.Menu.id == menu_id)
+            menu = await session.execute(query)
+            return menu.scalars().one_or_none()
+
+    @staticmethod
+    async def update_menu_item(menu_id: UUID,
+                               menu: schemas.MenuBase,
+                               session: AsyncSession,
+                               ):
+        async with session:
+            query = update(models.Menu).where(models.Menu.id == menu_id).values(**menu.model_dump())
+            await session.execute(query)
+            await session.commit()
+            qr = select(models.Menu).where(models.Menu.id == menu_id)
+            updated_menu = await session.execute(qr)
+            return updated_menu.scalars().one()
+
+    @staticmethod
+    async def delete_menu_item(menu_id: UUID, session: AsyncSession):
+        async with session:
+            query = delete(models.Menu).where(models.Menu.id == menu_id)
+            await session.execute(query)
             await session.commit()
-            return new_menu_item

fastfood/routes.py

@@ -1,5 +1,7 @@
-from fastapi import APIRouter, Depends
+from typing import List, Optional
+from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy import insert, select
+from uuid import UUID
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from fastfood import models, schemas
@@ -9,18 +11,45 @@ from fastfood.dbase import get_async_session
 router = APIRouter()
 
 
-@router.get("/api/v1/menus")
+@router.get("/api/v1/menus", response_model=Optional[List[schemas.Menu]])
 async def get_menus(session: AsyncSession = Depends(get_async_session)):
     result = await crud.get_menus(session=session)
     return result
 
 
-@router.post("/api/v1/menus", status_code=201)
+@router.post("/api/v1/menus", status_code=201, response_model=schemas.Menu)
 async def add_menu(
     menu: schemas.MenuBase,
     session: AsyncSession = Depends(get_async_session),
 ):
-    stmt = insert(models.Menu).values(**menu.dict())
+    result = await crud.create_menu_item(
-    await session.execute(stmt)
+        menu=menu,
-    await session.commit()
+        session=session,
-    return {"status": "success"}
+    )
+    return result
+
+
+@router.get("/api/v1/menus/{menu_id}", response_model=schemas.Menu)
+async def get_menu(
+        menu_id: UUID,
+        session: AsyncSession = Depends(get_async_session),
+):
+    result = await crud.get_menu_item(menu_id=menu_id, session=session)
+    if not result:
+            raise HTTPException(status_code=404, detail="menu not found")
+    return result
+
+
+@router.patch("/api/v1/menus/{menu_id}", response_model=schemas.MenuBase)
+async def update_menu(
+    menu_id: UUID,
+    menu: schemas.MenuBase,
+    session: AsyncSession = Depends(get_async_session),
+):
+    result = await crud.update_menu_item(menu_id=menu_id, menu=menu, session=session)
+    return result
+
+
+@router.delete("/api/v1/menus/{menu_id}")
+async def delete_menu(menu_id: UUID, session: AsyncSession = Depends(get_async_session)):
+    await crud.delete_menu_item(menu_id=menu_id, session=session)

fastfood/schemas.py

@@ -1,39 +1,23 @@
 from decimal import Decimal
+from typing import List, Optional
+from uuid import UUID
 
 from pydantic import BaseModel
 
 
 class MenuBase(BaseModel):
     title: str
-    description: str | None = None
+    description: Optional[str]
-
-
-class SubMenuBase(MenuBase):
-    pass
-
-
-class DishBase(MenuBase):
-    price: Decimal
-
-
-class Dish():
-    id: int
     
     class Config:
-        orm_mode = True
+        from_attributes = True
-
-
-class SubMenu(SubMenuBase):
-    id: int
-    # dishes: list[Dish]
-
-    class Config:
-        orm_mode = True
 
 
 class Menu(MenuBase):
-    id: int
+    id: UUID
-    # submenus: list[SubMenu]
+    title: str
+    description: Optional[str]
+    # submenus: Optional[List[SubMenu]]
 
     class Config:
-        orm_mode = True
+        from_attributes = True