add code merge from test-clean

talkingq-url/services/card_service.py

@@ -1,12 +1,14 @@
 import asyncio
-from typing import Optional, Dict
-import time
-from sqlalchemy import select, update, insert
-from sqlalchemy.ext.asyncio import AsyncSession
-from utils.logger import session_logger
+from typing import Dict, Optional
+
 from pydantic import BaseModel
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
 from database.models import Card as DBCard
 from services.database_service_base import DatabaseServiceBase
+from utils.logger import session_logger
+
 
 class Card(BaseModel):
     card_id: Optional[int] = None
@@ -17,10 +19,9 @@ class Card(BaseModel):
     total_swaps: int = 0
     created_at: Optional[float] = None
     updated_at: Optional[float] = None
-    
+
     @classmethod
     def from_db_model(cls, db_model: DBCard):
-        """从数据库模型创建卡片对象"""
         return cls(
             card_id=db_model.card_id,
             card_uuid=db_model.card_uuid,
@@ -29,162 +30,205 @@ class Card(BaseModel):
             status=db_model.status,
             total_swaps=db_model.total_swaps,
             created_at=db_model.created_at.timestamp() if db_model.created_at else None,
-            updated_at=db_model.updated_at.timestamp() if db_model.updated_at else None
+            updated_at=db_model.updated_at.timestamp() if db_model.updated_at else None,
         )
 
+
 class CardService(DatabaseServiceBase):
     def __init__(self):
         super().__init__(service_name="card")
         self.cards: Dict[str, Card] = {}
         self.lock = asyncio.Lock()
-    
+
+    async def _cache_card(self, card: Card) -> None:
+        async with self.lock:
+            self.cards[card.card_uuid] = card
+
     async def _load_card_from_db(self, card_uuid: str, async_session: AsyncSession) -> Optional[Card]:
-        """从数据库加载卡片信息"""
         try:
             query = select(DBCard).where(DBCard.card_uuid == card_uuid)
             result = await async_session.execute(query)
             db_card = result.scalar_one_or_none()
-            
-            if db_card:
-                card = Card.from_db_model(db_card)
-                async with self.lock:
-                    self.cards[card_uuid] = card
-                return card
+
+            if not db_card:
+                return None
+
+            card = Card.from_db_model(db_card)
+            await self._cache_card(card)
+            return card
+        except Exception as exc:
+            session_logger.error("card", "service", f"load card failed: {exc}")
             return None
-        except Exception as e:
-            session_logger.error("card", "service", f"从数据库加载卡片失败: {str(e)}")
-            return None
-    
-    async def _save_card_to_db(self, card: Card, async_session: AsyncSession):
-        """保存卡片信息到数据库"""
+
+    async def _clear_existing_device_card(
+        self,
+        device_id: str,
+        card_uuid: str,
+        async_session: AsyncSession,
+    ) -> None:
+        query = select(DBCard).where(
+            DBCard.device_id == device_id,
+            DBCard.card_uuid != card_uuid,
+        )
+        result = await async_session.execute(query)
+        existing_cards = result.scalars().all()
+
+        for db_card in existing_cards:
+            db_card.device_id = None
+            db_card.status = 0
+
+            async with self.lock:
+                cached = self.cards.get(db_card.card_uuid)
+                if cached is not None:
+                    cached.device_id = None
+                    cached.status = 0
+
+        if existing_cards:
+            await async_session.flush()
+
+    async def _save_card_to_db(self, card: Card, async_session: AsyncSession, commit: bool = True) -> None:
         try:
             query = select(DBCard).where(DBCard.card_uuid == card.card_uuid)
             result = await async_session.execute(query)
             existing_card = result.scalar_one_or_none()
-            
+
             if existing_card:
-                stmt = update(DBCard).where(
-                    DBCard.card_uuid == card.card_uuid
-                ).values(
-                    device_id=card.device_id,
-                    card_name=card.card_name,
-                    status=card.status,
-                    total_swaps=card.total_swaps
-                )
+                existing_card.device_id = card.device_id
+                existing_card.card_name = card.card_name
+                existing_card.status = card.status
+                existing_card.total_swaps = card.total_swaps
+                db_card = existing_card
             else:
-                stmt = insert(DBCard).values(
+                db_card = DBCard(
                     card_uuid=card.card_uuid,
                     device_id=card.device_id,
                     card_name=card.card_name,
                     status=card.status,
-                    total_swaps=card.total_swaps
+                    total_swaps=card.total_swaps,
                 )
-            
-            await async_session.execute(stmt)
-            await async_session.commit()
-            
-            session_logger.info("card", "service", f"卡片已保存到数据库: {card.card_uuid}")
-        except Exception as e:
-            await async_session.rollback()
-            session_logger.error("card", "service", f"保存卡片到数据库失败: {str(e)}")
+                async_session.add(db_card)
+
+            await async_session.flush()
+            if commit:
+                await async_session.commit()
+
+            card.card_id = db_card.card_id
+            await self._cache_card(card)
+            session_logger.info("card", "service", f"card saved: {card.card_uuid}")
+        except Exception as exc:
+            if commit:
+                await async_session.rollback()
+            session_logger.error("card", "service", f"save card failed: {exc}")
             raise
-    
-    async def get_card_by_uuid(self, card_uuid: str, force_refresh: bool = False) -> Optional[Card]:
-        """根据UUID获取卡片信息"""
+
+    async def get_card_by_uuid(
+        self,
+        card_uuid: str,
+        force_refresh: bool = False,
+        db_session: Optional[AsyncSession] = None,
+    ) -> Optional[Card]:
         await self._init_database()
-        
+
         card = None
-        
         if not force_refresh:
             async with self.lock:
                 card = self.cards.get(card_uuid)
-        
-        if not card:
-            db_session = await self.db_manager.get_session()
-            try:
-                card = await self._load_card_from_db(card_uuid, db_session)
-            finally:
-                await db_session.close()
-        
-        return card
-    
+
+        if card:
+            return card
+
+        if db_session is not None:
+            return await self._load_card_from_db(card_uuid, db_session)
+
+        session = await self.db_manager.get_session()
+        try:
+            return await self._load_card_from_db(card_uuid, session)
+        finally:
+            await session.close()
+
     async def get_card_by_device_id(self, device_id: str) -> list[Card]:
-        """根据设备ID获取卡片列表"""
         await self._init_database()
-        
+
         db_session = await self.db_manager.get_session()
         try:
             query = select(DBCard).where(DBCard.device_id == device_id)
             result = await db_session.execute(query)
             db_cards = result.scalars().all()
-            
+
             cards = []
             for db_card in db_cards:
                 card = Card.from_db_model(db_card)
-                async with self.lock:
-                    self.cards[card.card_uuid] = card
+                await self._cache_card(card)
                 cards.append(card)
-            
             return cards
-        except Exception as e:
-            session_logger.error(device_id, "card", f"根据设备ID获取卡片失败: {str(e)}")
+        except Exception as exc:
+            session_logger.error(device_id, "card", f"load device cards failed: {exc}")
             return []
         finally:
             await db_session.close()
-    
-    async def activate_card(self, card_uuid: str, device_id: str, card_name: Optional[str] = None) -> Card:
-        """激活卡片并绑定到设备"""
+
+    async def activate_card(
+        self,
+        card_uuid: str,
+        device_id: str,
+        card_name: Optional[str] = None,
+        db_session: Optional[AsyncSession] = None,
+    ) -> Card:
         await self._init_database()
-        
-        db_session = await self.db_manager.get_session()
+
+        owns_session = db_session is None
+        if db_session is None:
+            db_session = await self.db_manager.get_session()
+
         try:
-            # 检查卡片是否已存在
-            existing_card = await self.get_card_by_uuid(card_uuid)
-            
+            existing_card = await self.get_card_by_uuid(card_uuid, db_session=db_session)
+            await self._clear_existing_device_card(device_id=device_id, card_uuid=card_uuid, async_session=db_session)
+
             if existing_card:
-                # 更新现有卡片
                 existing_card.device_id = device_id
                 existing_card.card_name = card_name
-                existing_card.status = 1  # 激活状态
-                await self._save_card_to_db(existing_card, db_session)
-                session_logger.info(device_id, "card", f"卡片已激活并绑定到设备: {card_uuid}")
+                existing_card.status = 1
+                await self._save_card_to_db(existing_card, db_session, commit=owns_session)
+                session_logger.info(device_id, "card", f"card activated: {card_uuid}")
                 return existing_card
-            else:
-                # 创建新卡片
-                new_card = Card(
-                    card_uuid=card_uuid,
-                    device_id=device_id,
-                    card_name=card_name,
-                    status=1,  # 激活状态
-                    total_swaps=0
-                )
-                await self._save_card_to_db(new_card, db_session)
-                session_logger.info(device_id, "card", f"新卡片已创建并激活: {card_uuid}")
-                return new_card
+
+            new_card = Card(
+                card_uuid=card_uuid,
+                device_id=device_id,
+                card_name=card_name,
+                status=1,
+                total_swaps=0,
+            )
+            await self._save_card_to_db(new_card, db_session, commit=owns_session)
+            session_logger.info(device_id, "card", f"new card activated: {card_uuid}")
+            return new_card
+        except Exception:
+            if owns_session:
+                await db_session.rollback()
+            raise
+        finally:
+            if owns_session:
+                await db_session.close()
+
+    async def increment_swap_count(self, card_uuid: str) -> Optional[Card]:
+        await self._init_database()
+
+        card = await self.get_card_by_uuid(card_uuid)
+        if not card:
+            return None
+
+        card.total_swaps += 1
+        db_session = await self.db_manager.get_session()
+        try:
+            await self._save_card_to_db(card, db_session)
+            session_logger.info("card", "service", f"swap count incremented: {card_uuid}, total={card.total_swaps}")
+            return card
         finally:
             await db_session.close()
-    
-    async def increment_swap_count(self, card_uuid: str) -> Optional[Card]:
-        """增加卡片交换次数"""
-        await self._init_database()
-        
-        card = await self.get_card_by_uuid(card_uuid)
-        if card:
-            card.total_swaps += 1
-            db_session = await self.db_manager.get_session()
-            try:
-                await self._save_card_to_db(card, db_session)
-                session_logger.info("card", "service", f"卡片交换次数已增加: {card_uuid}, 总次数: {card.total_swaps}")
-                return card
-            finally:
-                await db_session.close()
-        return None
-    
+
     async def check_card_ownership(self, card_uuid: str, device_id: str) -> bool:
-        """检查卡片是否属于指定设备"""
         card = await self.get_card_by_uuid(card_uuid)
-        if card and card.device_id == device_id:
-            return True
-        return False
+        return bool(card and card.device_id == device_id)
+
 
 card_service = CardService()