Przeglądaj źródła

feat: implement product routing update endpoint and sort node configurations with enabled first

jerry 2 miesięcy temu
rodzic
commit
73d6d56a4e

+ 12 - 2
app/api/endpoints/product.py

@@ -5,7 +5,7 @@ from app.core.database import get_db
 from app.utils.response import success
 from app.utils.response import success
 from app.schemas.common import ApiResponse, PageResponse
 from app.schemas.common import ApiResponse, PageResponse
 from app.schemas.product import VasProductCreate, VasProductOut, VasProductUpdate
 from app.schemas.product import VasProductCreate, VasProductOut, VasProductUpdate
-from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingOut
+from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingOut, VasProductRoutingUpdate
 from app.schemas.schema import VasSchemaCreate, VasSchemaOut, VasSchemaUpdate
 from app.schemas.schema import VasSchemaCreate, VasSchemaOut, VasSchemaUpdate
 from app.services.product_routing_service import ProductRoutingService
 from app.services.product_routing_service import ProductRoutingService
 from app.services.product_service import ProductService
 from app.services.product_service import ProductService
@@ -79,8 +79,18 @@ async def vas_product_routing_create(
     return success(data=payload)
     return success(data=payload)
 
 
 
 
+@admin_required_router.post("/vas/product_routing/update", summary="更新商品路由", tags=["textskin"], response_model=ApiResponse[VasProductRoutingOut])
+async def vas_product_routing_update(
+    id: int,
+    payload: VasProductRoutingUpdate,
+    db: AsyncSession = Depends(get_db)
+):
+    routing = await ProductRoutingService.update(db, id, payload)
+    return success(data=routing)
+
+
 @admin_required_router.delete("/vas/product_routing/delete", summary="删除商品路由列表", tags=["textskin"], response_model=ApiResponse)
 @admin_required_router.delete("/vas/product_routing/delete", summary="删除商品路由列表", tags=["textskin"], response_model=ApiResponse)
-async def vas_product_routing_date(
+async def vas_product_routing_delete(
     id: int,
     id: int,
     db: AsyncSession = Depends(get_db)
     db: AsyncSession = Depends(get_db)
 ):
 ):

+ 22 - 3
app/schemas/product_routing.py

@@ -5,8 +5,13 @@ from datetime import datetime
 
 
 
 
 class VasProductRoutingBase(BaseModel):
 class VasProductRoutingBase(BaseModel):
+    product_id: Optional[int] = None
+    routing_key: Optional[str] = None
+    script_version: Optional[str] = None
+    priority: Optional[int] = None
     is_active: Optional[int] = None
     is_active: Optional[int] = None
     config: Optional[Dict[str, Any]] = None
     config: Optional[Dict[str, Any]] = None
+
     @field_validator("config", mode="before")
     @field_validator("config", mode="before")
     def normalize_json_field(cls, v):
     def normalize_json_field(cls, v):
         if v is None:
         if v is None:
@@ -22,18 +27,32 @@ class VasProductRoutingCreate(BaseModel):
     product_id: int
     product_id: int
     routing_key: str
     routing_key: str
     script_version: str
     script_version: str
-    priority: int
-    config: Dict[str, Any]
+    priority: int = 10
+    is_active: Optional[int] = 1
+    config: Optional[Dict[str, Any]] = None
+
+    @field_validator("config", mode="before")
+    def normalize_json_field(cls, v):
+        if v is None:
+            return None
+        if isinstance(v, str):
+            try:
+                return json.loads(v)
+            except Exception:
+                return {}
+        return v
 
 
 class VasProductRoutingUpdate(VasProductRoutingBase):
 class VasProductRoutingUpdate(VasProductRoutingBase):
     pass
     pass
 
 
-class VasProductRoutingOut(VasProductRoutingBase):
+class VasProductRoutingOut(BaseModel):
     id: int
     id: int
     product_id: int
     product_id: int
     priority: int
     priority: int
     routing_key: str
     routing_key: str
     script_version: str
     script_version: str
+    is_active: Optional[int] = 1
+    config: Optional[Dict[str, Any]] = None
 
 
     created_at: datetime
     created_at: datetime
     updated_at: datetime
     updated_at: datetime

+ 1 - 1
app/services/node_configuration_service.py

@@ -92,7 +92,7 @@ class NodeConfigurationService:
 
 
         total = await db.scalar(count_stmt) or 0
         total = await db.scalar(count_stmt) or 0
         offset = (page - 1) * page_size
         offset = (page - 1) * page_size
-        stmt = stmt.order_by(desc(model.updated_at), desc(model.id)).offset(offset).limit(page_size)
+        stmt = stmt.order_by(desc(model.enable), desc(model.updated_at), desc(model.id)).offset(offset).limit(page_size)
         result = await db.execute(stmt)
         result = await db.execute(stmt)
         items = list(result.scalars().all())
         items = list(result.scalars().all())
         return total, items
         return total, items

+ 26 - 5
app/services/product_routing_service.py

@@ -1,11 +1,11 @@
 # app/services/product_routing_service.py
 # app/services/product_routing_service.py
-
+from typing import List
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy import select, delete
 from sqlalchemy import select, delete
 
 
 from app.core.biz_exception import NotFoundError
 from app.core.biz_exception import NotFoundError
 from app.models.product_routing import VasProductRouting
 from app.models.product_routing import VasProductRouting
-from app.schemas.product_routing import VasProductRoutingCreate
+from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingUpdate
 
 
 
 
 class ProductRoutingService:
 class ProductRoutingService:
@@ -15,17 +15,38 @@ class ProductRoutingService:
         db: AsyncSession,
         db: AsyncSession,
         data: VasProductRoutingCreate,
         data: VasProductRoutingCreate,
     ) -> VasProductRouting:
     ) -> VasProductRouting:
-        rec = VasProductRouting(**data.dict())
+        rec = VasProductRouting(**data.model_dump(exclude_unset=True, by_alias=True))
         db.add(rec)
         db.add(rec)
         await db.commit()
         await db.commit()
         await db.refresh(rec)
         await db.refresh(rec)
         return rec
         return rec
 
 
+    @staticmethod
+    async def update(
+        db: AsyncSession,
+        id: int,
+        data: VasProductRoutingUpdate,
+    ) -> VasProductRouting:
+        stmt = select(VasProductRouting).where(
+            VasProductRouting.id == id
+        )
+        obj = (await db.execute(stmt)).scalar_one_or_none()
+        if not obj:
+            raise NotFoundError("Product routing not exist")
+
+        update_data = data.model_dump(exclude_unset=True, by_alias=True)
+        for k, v in update_data.items():
+            setattr(obj, k, v)
+
+        await db.commit()
+        await db.refresh(obj)
+        return obj
+
     @staticmethod
     @staticmethod
     async def list_by_product(
     async def list_by_product(
         db: AsyncSession,
         db: AsyncSession,
         product_id: int,
         product_id: int,
-    ):
+    ) -> List[VasProductRouting]:
         stmt = select(VasProductRouting).where(
         stmt = select(VasProductRouting).where(
             VasProductRouting.product_id == product_id
             VasProductRouting.product_id == product_id
         )
         )
@@ -36,7 +57,7 @@ class ProductRoutingService:
     async def delete(
     async def delete(
         db: AsyncSession,
         db: AsyncSession,
         id: int,
         id: int,
-    ):
+    ) -> None:
         stmt = select(VasProductRouting).where(
         stmt = select(VasProductRouting).where(
             VasProductRouting.id == id
             VasProductRouting.id == id
         )
         )

+ 56 - 0
tests/test_product_routing.py

@@ -0,0 +1,56 @@
+import pytest
+import unittest
+from unittest.mock import AsyncMock, MagicMock
+from datetime import datetime
+
+from app.models.product_routing import VasProductRouting
+from app.schemas.product_routing import VasProductRoutingCreate, VasProductRoutingUpdate
+from app.services.product_routing_service import ProductRoutingService
+
+
+class TestProductRoutingService(unittest.IsolatedAsyncioTestCase):
+
+    async def test_create_and_update_and_delete(self):
+        db = AsyncMock()
+
+        # Test create
+        create_payload = VasProductRoutingCreate(
+            product_id=32,
+            routing_key="auto.slot.sha.us.tourist",
+            script_version="latest",
+            priority=10,
+            config={"test": 1}
+        )
+        created = await ProductRoutingService.create(db, create_payload)
+        self.assertEqual(created.product_id, 32)
+        self.assertEqual(created.routing_key, "auto.slot.sha.us.tourist")
+        self.assertEqual(created.config, {"test": 1})
+        db.add.assert_called_once()
+        db.commit.assert_awaited()
+
+        # Test update
+        existing_obj = VasProductRouting(
+            id=44,
+            product_id=32,
+            routing_key="old.slot",
+            script_version="v1.0",
+            priority=5,
+            config={"old": True},
+            created_at=datetime.utcnow(),
+            updated_at=datetime.utcnow()
+        )
+        mock_result = MagicMock()
+        mock_result.scalar_one_or_none.return_value = existing_obj
+        db.execute.return_value = mock_result
+
+        update_payload = VasProductRoutingUpdate(
+            routing_key="auto.slot.sha.us.tourist",
+            script_version="latest",
+            priority=10,
+            config={"test": 1}
+        )
+        updated = await ProductRoutingService.update(db, 44, update_payload)
+        self.assertEqual(updated.routing_key, "auto.slot.sha.us.tourist")
+        self.assertEqual(updated.script_version, "latest")
+        self.assertEqual(updated.priority, 10)
+        self.assertEqual(updated.config, {"test": 1})