feat：添加新的message类为s4u服务，添加s4u config，添加sc和gift的解析，修复关系构建的一些问题

2025-07-15 17:04:30 +08:00
parent 4ebcf4e056
commit 5ec0d42cde
22 changed files with 1371 additions and 136 deletions
--- a/src/person_info/person_info.py
+++ b/src/person_info/person_info.py
@@ -161,6 +161,60 @@ class PersonInfoManager:

        await asyncio.to_thread(_db_create_sync, final_data)

+    async def _safe_create_person_info(self, person_id: str, data: Optional[dict] = None):
+        """安全地创建用户信息，处理竞态条件"""
+        if not person_id:
+            logger.debug("创建失败，person_id不存在")
+            return
+
+        _person_info_default = copy.deepcopy(person_info_default)
+        model_fields = PersonInfo._meta.fields.keys()  # type: ignore
+
+        final_data = {"person_id": person_id}
+
+        # Start with defaults for all model fields
+        for key, default_value in _person_info_default.items():
+            if key in model_fields:
+                final_data[key] = default_value
+
+        # Override with provided data
+        if data:
+            for key, value in data.items():
+                if key in model_fields:
+                    final_data[key] = value
+
+        # Ensure person_id is correctly set from the argument
+        final_data["person_id"] = person_id
+
+        # Serialize JSON fields
+        for key in JSON_SERIALIZED_FIELDS:
+            if key in final_data:
+                if isinstance(final_data[key], (list, dict)):
+                    final_data[key] = json.dumps(final_data[key], ensure_ascii=False)
+                elif final_data[key] is None:  # Default for lists is [], store as "[]"
+                    final_data[key] = json.dumps([], ensure_ascii=False)
+
+        def _db_safe_create_sync(p_data: dict):
+            try:
+                # 首先检查是否已存在
+                existing = PersonInfo.get_or_none(PersonInfo.person_id == p_data["person_id"])
+                if existing:
+                    logger.debug(f"用户 {p_data['person_id']} 已存在，跳过创建")
+                    return True
+                
+                # 尝试创建
+                PersonInfo.create(**p_data)
+                return True
+            except Exception as e:
+                if "UNIQUE constraint failed" in str(e):
+                    logger.debug(f"检测到并发创建用户 {p_data.get('person_id')}，跳过错误")
+                    return True  # 其他协程已创建，视为成功
+                else:
+                    logger.error(f"创建 PersonInfo 记录 {p_data.get('person_id')} 失败 (Peewee): {e}")
+                    return False
+
+        await asyncio.to_thread(_db_safe_create_sync, final_data)
+
    async def update_one_field(self, person_id: str, field_name: str, value, data: Optional[Dict] = None):
        """更新某一个字段，会补全"""
        if field_name not in PersonInfo._meta.fields:  # type: ignore
@@ -221,7 +275,8 @@ class PersonInfoManager:
            if data and "user_id" in data:
                creation_data["user_id"] = data["user_id"]

-            await self.create_person_info(person_id, creation_data)
+            # 使用安全的创建方法，处理竞态条件
+            await self._safe_create_person_info(person_id, creation_data)

    @staticmethod
    async def has_one_field(person_id: str, field_name: str):
@@ -529,36 +584,65 @@ class PersonInfoManager:
        """
        根据 platform 和 user_id 获取 person_id。
        如果对应的用户不存在，则使用提供的可选信息创建新用户。
+        使用try-except处理竞态条件，避免重复创建错误。
        """
        person_id = self.get_person_id(platform, user_id)

-        def _db_check_exists_sync(p_id: str):
-            return PersonInfo.get_or_none(PersonInfo.person_id == p_id)
+        def _db_get_or_create_sync(p_id: str, init_data: dict):
+            """原子性的获取或创建操作"""
+            # 首先尝试获取现有记录
+            record = PersonInfo.get_or_none(PersonInfo.person_id == p_id)
+            if record:
+                return record, False  # 记录存在，未创建
+                
+            # 记录不存在，尝试创建
+            try:
+                PersonInfo.create(**init_data)
+                return PersonInfo.get(PersonInfo.person_id == p_id), True  # 创建成功
+            except Exception as e:
+                # 如果创建失败（可能是因为竞态条件），再次尝试获取
+                if "UNIQUE constraint failed" in str(e):
+                    logger.debug(f"检测到并发创建用户 {p_id}，获取现有记录")
+                    record = PersonInfo.get_or_none(PersonInfo.person_id == p_id)
+                    if record:
+                        return record, False  # 其他协程已创建，返回现有记录
+                # 如果仍然失败，重新抛出异常
+                raise e

-        record = await asyncio.to_thread(_db_check_exists_sync, person_id)
+        unique_nickname = await self._generate_unique_person_name(nickname)
+        initial_data = {
+            "person_id": person_id,
+            "platform": platform,
+            "user_id": str(user_id),
+            "nickname": nickname,
+            "person_name": unique_nickname,  # 使用群昵称作为person_name
+            "name_reason": "从群昵称获取",
+            "know_times": 0,
+            "know_since": int(datetime.datetime.now().timestamp()),
+            "last_know": int(datetime.datetime.now().timestamp()),
+            "impression": None,
+            "points": [],
+            "forgotten_points": [],
+        }
+        
+        # 序列化JSON字段
+        for key in JSON_SERIALIZED_FIELDS:
+            if key in initial_data:
+                if isinstance(initial_data[key], (list, dict)):
+                    initial_data[key] = json.dumps(initial_data[key], ensure_ascii=False)
+                elif initial_data[key] is None:
+                    initial_data[key] = json.dumps([], ensure_ascii=False)
+        
+        model_fields = PersonInfo._meta.fields.keys()  # type: ignore
+        filtered_initial_data = {k: v for k, v in initial_data.items() if v is not None and k in model_fields}

-        if record is None:
+        record, was_created = await asyncio.to_thread(_db_get_or_create_sync, person_id, filtered_initial_data)
+        
+        if was_created:
            logger.info(f"用户 {platform}:{user_id} (person_id: {person_id}) 不存在，将创建新记录 (Peewee)。")
-            unique_nickname = await self._generate_unique_person_name(nickname)
-            initial_data = {
-                "person_id": person_id,
-                "platform": platform,
-                "user_id": str(user_id),
-                "nickname": nickname,
-                "person_name": unique_nickname,  # 使用群昵称作为person_name
-                "name_reason": "从群昵称获取",
-                "know_times": 0,
-                "know_since": int(datetime.datetime.now().timestamp()),
-                "last_know": int(datetime.datetime.now().timestamp()),
-                "impression": None,
-                "points": [],
-                "forgotten_points": [],
-            }
-            model_fields = PersonInfo._meta.fields.keys()  # type: ignore
-            filtered_initial_data = {k: v for k, v in initial_data.items() if v is not None and k in model_fields}
-
-            await self.create_person_info(person_id, data=filtered_initial_data)
            logger.info(f"已为 {person_id} 创建新记录，初始数据 (filtered for model): {filtered_initial_data}")
+        else:
+            logger.debug(f"用户 {platform}:{user_id} (person_id: {person_id}) 已存在，返回现有记录。")

        return person_id