modified: basic_plugins/admin_bot_manage/_data_source.py

modified:   basic_plugins/admin_bot_manage/admin_config.py
	modified:   basic_plugins/admin_bot_manage/custom_welcome_message.py
	modified:   basic_plugins/admin_bot_manage/timing_task.py
	modified:   basic_plugins/apscheduler/__init__.py
	modified:   basic_plugins/ban/__init__.py
	modified:   basic_plugins/ban/data_source.py
	modified:   basic_plugins/chat_history/chat_message.py
	modified:   basic_plugins/chat_history/chat_message_handle.py
	modified:   basic_plugins/group_handle/__init__.py
	modified:   basic_plugins/hooks/_utils.py
	modified:   basic_plugins/hooks/ban_hook.py
	modified:   basic_plugins/hooks/chkdsk_hook.py
	modified:   basic_plugins/init_plugin_config/__init__.py
	deleted:    basic_plugins/init_plugin_config/init_group_manager.py
	modified:   basic_plugins/invite_manager/__init__.py
	new file:   basic_plugins/invite_manager/utils.py
	modified:   basic_plugins/nickname.py
	modified:   basic_plugins/plugin_shop/__init__.py
	modified:   basic_plugins/plugin_shop/data_source.py
	modified:   basic_plugins/scripts.py
	modified:   basic_plugins/shop/__init__.py
	modified:   basic_plugins/shop/buy.py
	modified:   basic_plugins/shop/gold.py
	modified:   basic_plugins/shop/my_props/__init__.py
	deleted:    basic_plugins/shop/reset_today_gold.py
	modified:   basic_plugins/shop/shop_handle/__init__.py
	modified:   basic_plugins/shop/shop_handle/data_source.py
	modified:   basic_plugins/shop/use/__init__.py
	modified:   basic_plugins/shop/use/data_source.py
	modified:   basic_plugins/super_cmd/__init__.py
	modified:   basic_plugins/super_cmd/bot_friend_group.py
	modified:   basic_plugins/super_cmd/clear_data.py
	modified:   basic_plugins/super_cmd/exec_sql.py
	modified:   basic_plugins/super_cmd/manager_group.py
	modified:   basic_plugins/super_cmd/reload_setting.py
	modified:   basic_plugins/super_cmd/set_admin_permissions.py
	deleted:    basic_plugins/super_cmd/super_task_switch.py
	modified:   basic_plugins/super_cmd/update_friend_group_info.py
	modified:   basic_plugins/super_help/__init__.py
	modified:   basic_plugins/update_info.py
	modified:   configs/config.py
	modified:   configs/utils/__init__.py
	modified:   models/bag_user.py
	modified:   models/ban_user.py
	modified:   models/chat_history.py
	modified:   models/friend_user.py
	modified:   models/goods_info.py
	modified:   models/group_info.py
	modified:   models/group_member_info.py
	modified:   models/level_user.py
	modified:   models/sign_group_user.py
	modified:   models/user_shop_gold_log.py
	modified:   plugins/aconfig/__init__.py
	modified:   plugins/ai/__init__.py
	modified:   plugins/ai/data_source.py
	modified:   plugins/bilibili_sub/__init__.py
	modified:   plugins/bilibili_sub/data_source.py
	modified:   plugins/bilibili_sub/model.py
	modified:   plugins/black_word/__init__.py
	modified:   plugins/black_word/model.py
	modified:   plugins/black_word/utils.py
	modified:   plugins/bt/data_source.py
	modified:   plugins/genshin/almanac/__init__.py
	modified:   plugins/genshin/material_remind/__init__.py
	modified:   plugins/genshin/query_user/_models/__init__.py
	modified:   plugins/genshin/query_user/_utils/__init__.py
	modified:   plugins/genshin/query_user/bind/__init__.py
	modified:   plugins/genshin/query_user/genshin_sign/__init__.py
	modified:   plugins/genshin/query_user/genshin_sign/data_source.py
	modified:   plugins/genshin/query_user/genshin_sign/init_task.py
	modified:   plugins/genshin/query_user/mihoyobbs_sign/__init__.py
	modified:   plugins/genshin/query_user/query_memo/__init__.py
	modified:   plugins/genshin/query_user/query_memo/data_source.py
	modified:   plugins/genshin/query_user/query_role/__init__.py
	modified:   plugins/genshin/query_user/query_role/data_source.py
	modified:   plugins/genshin/query_user/reset_today_query_user_data/__init__.py
	modified:   plugins/genshin/query_user/resin_remind/__init__.py
	modified:   plugins/genshin/query_user/resin_remind/init_task.py
	modified:   plugins/gold_redbag/model.py
	modified:   plugins/image_management/send_image/__init__.py
	modified:   plugins/my_info/__init__.py
	modified:   plugins/open_cases/models/buff_prices.py
	modified:   plugins/open_cases/models/open_cases_user.py
	modified:   plugins/open_cases/open_cases_c.py
	modified:   plugins/open_cases/utils.py
	modified:   plugins/parse_bilibili_json.py
	modified:   plugins/pid_search.py
	modified:   plugins/pix_gallery/__init__.py
	modified:   plugins/pix_gallery/_data_source.py
	modified:   plugins/pix_gallery/_model/omega_pixiv_illusts.py
	modified:   plugins/pix_gallery/_model/pixiv.py
	modified:   plugins/pix_gallery/_model/pixiv_keyword_user.py
	modified:   plugins/pix_gallery/pix_add_keyword.py
	modified:   plugins/pix_gallery/pix_pass_del_keyword.py
	modified:   plugins/pix_gallery/pix_show_info.py
	modified:   plugins/pix_gallery/pix_update.py
	modified:   plugins/pixiv_rank_search/data_source.py
	modified:   plugins/poke/__init__.py
	modified:   plugins/russian/__init__.py
	modified:   plugins/russian/data_source.py
	modified:   plugins/russian/model.py
	modified:   plugins/send_dinggong_voice/__init__.py
	modified:   plugins/send_setu_/_model.py
	modified:   plugins/send_setu_/send_setu/__init__.py
	modified:   plugins/send_setu_/send_setu/data_source.py
	modified:   plugins/send_setu_/update_setu/data_source.py
	modified:   plugins/sign_in/goods_register.py
	modified:   plugins/sign_in/group_user_checkin.py
	modified:   plugins/sign_in/random_event.py
	modified:   plugins/sign_in/utils.py
	modified:   plugins/statistics/_model.py
	modified:   plugins/statistics/statistics_handle.py
	modified:   plugins/statistics/statistics_hook.py
	modified:   plugins/update_picture.py
	modified:   plugins/web_ui/api/request.py
	modified:   plugins/word_bank/_model.py
	deleted:    plugins/word_bank/_old_model.py
	modified:   plugins/word_bank/_rule.py
	modified:   plugins/word_bank/word_handle.py
	modified:   plugins/word_clouds/data_source.py
	modified:   resources/image/sign/sign_res/bar.png
	modified:   resources/image/sign/sign_res/bar_white.png
	modified:   services/db_context.py
	modified:   services/log.py
	modified:   utils/browser.py
	modified:   utils/data_utils.py
	modified:   utils/depends/__init__.py
	modified:   utils/http_utils.py
	modified:   utils/image_utils.py
	modified:   utils/manager/admin_manager.py
	modified:   utils/message_builder.py
	modified:   utils/utils.py

models/bag_user.py

@@ -1,24 +1,37 @@
-from services.db_context import db
 from typing import Dict
-from typing import Optional, List
-from services.log import logger
+
+from tortoise import fields
+
+from services.db_context import Model
+
 from .goods_info import GoodsInfo
 
 
-class BagUser(db.Model):
-    __tablename__ = "bag_users"
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    group_id = db.Column(db.BigInteger(), nullable=False)
-    gold = db.Column(db.Integer(), default=100)
-    props = db.Column(db.TEXT(), nullable=False, default="")  # 旧道具字段（废弃）
-    spend_total_gold = db.Column(db.Integer(), default=0)
-    get_total_gold = db.Column(db.Integer(), default=0)
-    get_today_gold = db.Column(db.Integer(), default=0)
-    spend_today_gold = db.Column(db.Integer(), default=0)
-    property = db.Column(db.JSON(), nullable=False, default={})  # 新道具字段
+class BagUser(Model):
 
-    _idx1 = db.Index("bag_group_users_idx1", "user_qq", "group_id", unique=True)
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    gold = fields.IntField(default=100)
+    """金币数量"""
+    spend_total_gold = fields.IntField(default=0)
+    """花费金币总数"""
+    get_total_gold = fields.IntField(default=0)
+    """获取金币总数"""
+    get_today_gold = fields.IntField(default=0)
+    """今日获取金币"""
+    spend_today_gold = fields.IntField(default=0)
+    """今日获取金币"""
+    property: Dict[str, int] = fields.JSONField(default={})
+    """道具"""
+
+    class Meta:
+        table = "bag_users"
+        table_description = "用户道具数据表"
+        unique_together = ("user_qq", "group_id")
 
     @classmethod
     async def get_user_total_gold(cls, user_qq: int, group_id: int) -> str:
@@ -29,13 +42,7 @@ class BagUser(db.Model):
             :param user_qq: qq号
             :param group_id: 所在群号
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        user = await query.gino.first()
-        if not user:
-            user = await cls.create(
-                user_qq=user_qq,
-                group_id=group_id,
-            )
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
         return (
             f"当前金币：{user.gold}\n今日获取金币：{user.get_today_gold}\n今日花费金币：{user.spend_today_gold}"
             f"\n今日收益：{user.get_today_gold - user.spend_today_gold}"
@@ -51,19 +58,13 @@ class BagUser(db.Model):
             :param user_qq: qq号
             :param group_id: 所在群号
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        user = await query.gino.first()
-        if user:
-            return user.gold
-        else:
-            await cls.create(
-                user_qq=user_qq,
-                group_id=group_id,
-            )
-            return 100
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        return user.gold
 
     @classmethod
-    async def get_property(cls, user_qq: int, group_id: int, only_active: bool = False) -> Dict[str, int]:
+    async def get_property(
+        cls, user_qq: int, group_id: int, only_active: bool = False
+    ) -> Dict[str, int]:
         """
         说明:
             获取当前道具
@@ -72,22 +73,18 @@ class BagUser(db.Model):
             :param group_id: 所在群号
             :param only_active: 仅仅获取主动使用的道具
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        user = await query.gino.first()
-        if user:
-            if only_active and user.property:
-                data = {}
-                name_list = [x.goods_name for x in await GoodsInfo.get_all_goods() if not x.is_passive]
-                for key in [x for x in user.property.keys() if x in name_list]:
-                    data[key] = user.property[key]
-                return data
-            return user.property
-        else:
-            await cls.create(
-                user_qq=user_qq,
-                group_id=group_id,
-            )
-            return {}
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        if only_active and user.property:
+            data = {}
+            name_list = [
+                x.goods_name
+                for x in await GoodsInfo.get_all_goods()
+                if not x.is_passive
+            ]
+            for key in [x for x in user.property if x in name_list]:
+                data[key] = user.property[key]
+            return data
+        return user.property
 
     @classmethod
     async def add_gold(cls, user_qq: int, group_id: int, num: int):
@@ -99,23 +96,11 @@ class BagUser(db.Model):
             :param group_id: 所在群号
             :param num: 金币数量
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user:
-            await user.update(
-                gold=user.gold + num,
-                get_total_gold=user.get_total_gold + num,
-                get_today_gold=user.get_today_gold + num,
-            ).apply()
-        else:
-            await cls.create(
-                user_qq=user_qq,
-                group_id=group_id,
-                gold=100 + num,
-                get_total_gold=num,
-                get_today_gold=num,
-            )
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        user.gold = user.gold + num
+        user.get_total_gold = user.get_total_gold + num
+        user.get_today_gold = user.get_today_gold + num
+        await user.save(update_fields=["gold", "get_today_gold", "get_total_gold"])
 
     @classmethod
     async def spend_gold(cls, user_qq: int, group_id: int, num: int):
@@ -127,26 +112,14 @@ class BagUser(db.Model):
             :param group_id: 所在群号
             :param num: 金币数量
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user:
-            await user.update(
-                gold=user.gold - num,
-                spend_total_gold=user.spend_total_gold + num,
-                spend_today_gold=user.spend_today_gold + num,
-            ).apply()
-        else:
-            await cls.create(
-                user_qq=user_qq,
-                group_id=group_id,
-                gold=100 - num,
-                spend_total_gold=num,
-                spend_today_gold=num,
-            )
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        user.gold = user.gold - num
+        user.spend_total_gold = user.spend_total_gold + num
+        user.spend_today_gold = user.spend_today_gold + num
+        await user.save(update_fields=["gold", "spend_total_gold", "spend_today_gold"])
 
     @classmethod
-    async def add_property(cls, user_qq: int, group_id: int, name: str):
+    async def add_property(cls, user_qq: int, group_id: int, name: str, num: int = 1):
         """
         说明:
             增加道具
@@ -154,19 +127,15 @@ class BagUser(db.Model):
             :param user_qq: qq号
             :param group_id: 所在群号
             :param name: 道具名称
+            :param num: 道具数量
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user:
-            p = user.property
-            if p.get(name) is None:
-                p[name] = 1
-            else:
-                p[name] += 1
-            await user.update(property=p).apply()
-        else:
-            await cls.create(user_qq=user_qq, group_id=group_id, property={name: 1})
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        property_ = user.property
+        if property_.get(name) is None:
+            property_[name] = 0
+        property_[name] += num
+        user.property = property_
+        await user.save(update_fields=["property"])
 
     @classmethod
     async def delete_property(
@@ -181,54 +150,15 @@ class BagUser(db.Model):
             :param name: 道具名称
             :param num: 使用个数
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user:
-            property_ = user.property
-            if name in property_:
-                if property_.get(name) == num:
-                    del property_[name]
-                else:
-                    property_[name] -= num
-                await user.update(property=property_).apply()
-                return True
-        return False
-
-    @classmethod
-    async def buy_property(
-        cls, user_qq: int, group_id: int, goods: "GoodsInfo", goods_num: int
-    ) -> bool:
-        """
-        说明:
-            购买道具
-        参数:
-            :param user_qq: 用户qq
-            :param group_id: 所在群聊
-            :param goods: 商品
-            :param goods_num: 商品数量
-        """
-        try:
-            # 折扣后金币
-            spend_gold = goods.goods_discount * goods.goods_price * goods_num
-            await BagUser.spend_gold(user_qq, group_id, spend_gold)
-            for _ in range(goods_num):
-                await BagUser.add_property(user_qq, group_id, goods.goods_name)
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        property_ = user.property
+        if name in property_:
+            if (n := property_.get(name, 0)) < num:
+                return False
+            if n == num:
+                del property_[name]
+            else:
+                property_[name] -= num
+            await user.save(update_fields=["property"])
             return True
-        except Exception as e:
-            logger.error(f"buy_property 发生错误 {type(e)}：{e}")
         return False
-
-    @classmethod
-    async def get_all_users(cls, group_id: Optional[int] = None) -> List["BagUser"]:
-        """
-        说明:
-            获取所有用户数据
-        参数:
-            :param group_id: 群号
-        """
-        if not group_id:
-            query = await cls.query.gino.all()
-        else:
-            query = await cls.query.where((cls.group_id == group_id)).gino.all()
-        return query

models/ban_user.py

@@ -1,16 +1,26 @@
-from services.db_context import db
 import time
+from typing import Union
+
+from tortoise import fields
+
+from services.db_context import Model
+from services.log import logger
 
 
-class BanUser(db.Model):
-    __tablename__ = "ban_users"
+class BanUser(Model):
 
-    user_qq = db.Column(db.BigInteger(), nullable=False, primary_key=True)
-    ban_level = db.Column(db.Integer(), nullable=False)
-    ban_time = db.Column(db.BigInteger())
-    duration = db.Column(db.BigInteger())
+    user_qq = fields.IntField(pk=True)
+    """用户id"""
+    ban_level = fields.IntField()
+    """使用ban命令的用户等级"""
+    ban_time = fields.BigIntField()
+    """ban开始的时间"""
+    duration = fields.BigIntField()
+    """ban时长"""
 
-    _idx1 = db.Index("ban_group_users_idx1", "user_qq", unique=True)
+    class Meta:
+        table = "ban_users"
+        table_description = ".ban/b了 封禁人员数据表"
 
     @classmethod
     async def check_ban_level(cls, user_qq: int, level: int) -> bool:
@@ -21,30 +31,34 @@ class BanUser(db.Model):
             :param user_qq: unban用户的qq号
             :param level: ban掉目标用户的权限等级
         """
-        user = await cls.query.where((cls.user_qq == user_qq)).gino.first()
-        if not user:
-            return False
-        if user.ban_level > level:
-            return True
+        user = await cls.filter(user_qq=user_qq).first()
+        if user:
+            logger.debug(
+                f"检测用户被ban等级，user_level: {user.ban_level}，level: {level}",
+                target=user_qq,
+            )
+            return bool(user and user.ban_level > level)
         return False
 
     @classmethod
-    async def check_ban_time(cls, user_qq: int) -> str:
+    async def check_ban_time(cls, user_qq: int) -> Union[str, int]:
         """
         说明:
             检测用户被ban时长
         参数:
             :param user_qq: qq号
         """
-        query = cls.query.where((cls.user_qq == user_qq))
-        user = await query.gino.first()
-        if not user:
-            return ""
-        if time.time() - (user.ban_time + user.duration) > 0 and user.duration != -1:
-            return ""
-        if user.duration == -1:
-            return "∞"
-        return time.time() - user.ban_time - user.duration
+        logger.debug(f"获取用户ban时长", target=user_qq)
+        if user := await cls.filter(user_qq=user_qq).first():
+            if (
+                time.time() - (user.ban_time + user.duration) > 0
+                and user.duration != -1
+            ):
+                return ""
+            if user.duration == -1:
+                return "∞"
+            return int(time.time() - user.ban_time - user.duration)
+        return ""
 
     @classmethod
     async def is_ban(cls, user_qq: int) -> bool:
@@ -54,28 +68,29 @@ class BanUser(db.Model):
         参数:
             :param user_qq: qq号
         """
+        logger.debug(f"检测是否被ban", target=user_qq)
         if await cls.check_ban_time(user_qq):
             return True
         else:
             await cls.unban(user_qq)
-            return False
+        return False
 
     @classmethod
     async def is_super_ban(cls, user_qq: int) -> bool:
         """
         说明:
-            判断用户是否被ban
+            判断用户是否被超级用户ban / b了
         参数:
             :param user_qq: qq号
         """
-        user = await cls.query.where((cls.user_qq == user_qq)).gino.first()
-        if not user:
-            return False
-        if user.ban_level == 10:
-            return True
+        logger.debug(f"检测是否被超级用户权限封禁", target=user_qq)
+        if user := await cls.filter(user_qq=user_qq).first():
+            if user.ban_level == 10:
+                return True
+        return False
 
     @classmethod
-    async def ban(cls, user_qq: int, ban_level: int, duration: int) -> bool:
+    async def ban(cls, user_qq: int, ban_level: int, duration: int):
         """
         说明:
             ban掉目标用户
@@ -84,22 +99,15 @@ class BanUser(db.Model):
             :param ban_level: 使用ban命令用户的权限
             :param duration:  ban时长，秒
         """
-        query = cls.query.where((cls.user_qq == user_qq))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if not await cls.check_ban_time(user_qq):
+        logger.debug(f"封禁用户，等级:{ban_level}，时长: {duration}", target=user_qq)
+        if await cls.filter(user_qq=user_qq).first():
             await cls.unban(user_qq)
-            user = None
-        if user is None:
-            await cls.create(
-                user_qq=user_qq,
-                ban_level=ban_level,
-                ban_time=time.time(),
-                duration=duration,
-            )
-            return True
-        else:
-            return False
+        await cls.create(
+            user_qq=user_qq,
+            ban_level=ban_level,
+            ban_time=time.time(),
+            duration=duration,
+        )
 
     @classmethod
     async def unban(cls, user_qq: int) -> bool:
@@ -109,11 +117,8 @@ class BanUser(db.Model):
         参数:
             :param user_qq: qq号
         """
-        query = cls.query.where((cls.user_qq == user_qq))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user is None:
-            return False
-        else:
-            await cls.delete.where((cls.user_qq == user_qq)).gino.status()
+        logger.debug("解除封禁", target=user_qq)
+        if user := await cls.filter(user_qq=user_qq).first():
+            await user.delete()
             return True
+        return False

models/chat_history.py

@@ -1,81 +1,30 @@
 from datetime import datetime, timedelta
-from typing import List, Literal, Optional, Tuple, Union
+from typing import Any, List, Literal, Optional, Tuple, Union
 
-from services.db_context import db
+from tortoise import fields
+from tortoise.functions import Count
+
+from services.db_context import Model
 
 
-class ChatHistory(db.Model):
-    __tablename__ = "chat_history"
+class ChatHistory(Model):
 
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    group_id = db.Column(db.BigInteger())
-    text = db.Column(db.Text())
-    plain_text = db.Column(db.Text())
-    create_time = db.Column(db.DateTime(timezone=True), nullable=False)
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    text = fields.TextField()
+    """文本内容"""
+    plain_text = fields.TextField()
+    """纯文本"""
+    create_time = fields.DatetimeField(auto_now_add=True)
+    """创建时间"""
 
-    @classmethod
-    async def add_chat_msg(cls, user_qq: int, group_id: Optional[int], text: str, plain_text: str):
-        await cls.create(
-            user_qq=user_qq, group_id=group_id, text=text, plain_text=plain_text, create_time=datetime.now()
-        )
-
-    @classmethod
-    async def get_user_msg(
-        cls,
-        uid: int,
-        msg_type: Optional[Literal["private", "group"]],
-        days: Optional[int] = None,
-    ) -> List["ChatHistory"]:
-        """
-        说明:
-            获取用户消息
-        参数:
-            :param uid: 用户qq
-            :param msg_type: 消息类型，私聊或群聊
-            :param days: 限制日期
-        """
-        return await cls._get_msg(uid, None, "user", msg_type, days).gino.all()
-
-    @classmethod
-    async def get_group_user_msg(
-        cls,
-        uid: int,
-        gid: int,
-        limit: int = 10,
-        date_scope: Tuple[datetime, datetime] = None,
-    ) -> List["ChatHistory"]:
-        """
-        说明:
-            获取群聊指定用户聊天记录
-        参数:
-            :param uid: qq
-            :param gid: 群号
-            :param limit: 获取数量
-            :param date_scope: 日期范围，默认None为全搜索
-        """
-        return (
-            await cls._get_msg(uid, gid, "group", days=date_scope)
-            .limit(limit)
-            .gino.all()
-        )
-
-    @classmethod
-    async def get_group_user_msg_count(cls, uid: int, gid: int) -> Optional[int]:
-        """
-        说明:
-             查询群聊指定用户的聊天记录数量
-        参数:
-            :param uid: qq
-            :param gid: 群号
-        """
-        if x := await db.first(
-            db.text(
-                f"SELECT COUNT(id) as sum FROM public.chat_history WHERE user_qq = {uid} AND group_id = {gid}"
-            )
-        ):
-            return x[0]
-        return None
+    class Meta:
+        table = "chat_history"
+        table_description = "聊天记录数据表"
 
     @classmethod
     async def get_group_msg_rank(
@@ -84,7 +33,7 @@ class ChatHistory(db.Model):
         limit: int = 10,
         order: str = "DESC",
         date_scope: Optional[Tuple[datetime, datetime]] = None,
-    ) -> Optional[Tuple[int, int]]:
+    ) -> List["ChatHistory"]:
         """
         说明:
             获取排行数据
@@ -94,89 +43,39 @@ class ChatHistory(db.Model):
             :param order: 排序类型，desc，des
             :param date_scope: 日期范围
         """
-        sql = f"SELECT user_qq, COUNT(id) as sum FROM public.chat_history WHERE group_id = {gid} "
-        if date_scope:
-            sql += f"AND create_time BETWEEN '{date_scope[0]}' AND '{date_scope[1]}' "
-        sql += f"GROUP BY user_qq ORDER BY sum {order if order and order.upper() != 'DES' else ''} LIMIT {limit}"
-        return await db.all(db.text(sql))
+        return list(
+            await cls.filter(group_id=gid, create_time__range=date_scope)
+            .annotate(count=Count("user_qq"))
+            .order_by(order)
+            .group_by("user_qq")
+            .limit(limit)
+            .values_list("user_qq", "count")
+        )
 
     @classmethod
-    async def get_group_first_msg_datetime(cls, gid: int) -> Optional[datetime]:
+    async def get_group_first_msg_datetime(cls, group_id: int) -> Optional[datetime]:
         """
         说明:
             获取群第一条记录消息时间
         参数:
-            :param gid:
+            :param group_id: 群聊id
         """
         if (
-            msg := await cls.query.where(cls.group_id == gid)
-            .order_by(cls.create_time)
-            .gino.first()
+            message := await cls.filter(group_id=group_id)
+            .order_by("create_time")
+            .first()
         ):
-            return msg.create_time
-        return None
+            return message.create_time
 
     @classmethod
-    async def get_user_msg_count(
-        cls,
-        uid: int,
-        msg_type: Optional[Literal["private", "group"]],
-        days: Optional[int] = None,
-    ) -> int:
-        """
-        说明:
-            获取用户消息数量
-        参数:
-            :param uid: 用户qq
-            :param msg_type: 消息类型，私聊或群聊
-            :param days: 限制日期
-        """
-        return (
-            await cls._get_msg(uid, None, "user", msg_type, days, True).gino.first()
-        )[0]
-
-    @classmethod
-    async def get_group_msg(
-        cls,
-        gid: int,
-        days: Optional[int] = None,
-    ) -> List["ChatHistory"]:
-        """
-        说明:
-            获取群聊消息
-        参数:
-            :param gid: 用户qq
-            :param days: 限制日期
-        """
-        return await cls._get_msg(None, gid, "group", None, days).gino.all()
-
-    @classmethod
-    async def get_group_msg_count(
-        cls,
-        gid: int,
-        days: Optional[int] = None,
-    ) -> List["ChatHistory"]:
-        """
-        说明:
-            获取群聊消息数量
-        参数:
-            :param gid: 用户qq
-            :param days: 限制日期
-        """
-        return (await cls._get_msg(None, gid, "group", None, days, True).gino.first())[
-            0
-        ]
-
-    @classmethod
-    def _get_msg(
+    async def get_message(
         cls,
         uid: Optional[int],
         gid: Optional[int],
         type_: Literal["user", "group"],
         msg_type: Optional[Literal["private", "group"]] = None,
         days: Optional[Union[int, Tuple[datetime, datetime]]] = None,
-        is_select_count: bool = False,
-    ):
+    ) -> List["ChatHistory"]:
         """
         说明:
             获取消息查询query
@@ -187,28 +86,21 @@ class ChatHistory(db.Model):
             :param msg_type: 消息类型，用户或群聊
             :param days: 限制日期
         """
-        if is_select_count:
-            setattr(ChatHistory, "count", db.func.count(cls.id).label("count"))
-            query = cls.select("count")
-        else:
-            query = cls.query
         if type_ == "user":
-            query = query.where(cls.user_qq == uid)
+            query = cls.filter(user_qq=uid)
             if msg_type == "private":
-                query = query.where(cls.group_id == None)
+                query = query.filter(group_id__isnull=True)
             elif msg_type == "group":
-                query = query.where(cls.group_id != None)
+                query = query.filter(group_id__not_isnull=True)
         else:
-            query = query.where(cls.group_id == gid)
+            query = cls.filter(group_id=gid)
             if uid:
-                query = query.where(cls.user_qq == uid)
+                query = query.filter(user_qq=uid)
         if days:
             if isinstance(days, int):
-                query = query.where(
-                    cls.create_time >= datetime.now() - timedelta(days=days)
+                query = query.filter(
+                    create_time__gte=datetime.now() - timedelta(days=days)
                 )
             elif isinstance(days, tuple):
-                query = query.where(cls.create_time >= days[0]).where(
-                    cls.create_time <= days[1]
-                )
-        return query
+                query = query.filter(create_at__range=days)
+        return await query.all()

models/friend_user.py

@@ -1,16 +1,23 @@
-from services.db_context import db
+from tortoise import fields
+
 from configs.config import Config
+from services.db_context import Model
 
 
-class FriendUser(db.Model):
-    __tablename__ = "friend_users"
+class FriendUser(Model):
 
-    id = db.Column(db.Integer(), primary_key=True)
-    user_id = db.Column(db.BigInteger(), nullable=False)
-    user_name = db.Column(db.Unicode(), nullable=False, default="")
-    nickname = db.Column(db.Unicode())
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_id = fields.BigIntField(unique=True)
+    """用户id"""
+    user_name = fields.CharField(max_length=255, default="")
+    """用户名称"""
+    nickname = fields.CharField(max_length=255, null=True)
+    """私聊下自定义昵称"""
 
-    _idx1 = db.Index("friend_users_idx1", "user_id", unique=True)
+    class Meta:
+        table = "friend_users"
+        table_description = "好友信息数据表"
 
     @classmethod
     async def get_user_name(cls, user_id: int) -> str:
@@ -20,77 +27,29 @@ class FriendUser(db.Model):
         参数:
             :param user_id: qq号
         """
-        query = cls.query.where(cls.user_id == user_id)
-        user = await query.gino.first()
-        if user:
+        if user := await cls.get_or_none(user_id=user_id):
             return user.user_name
-        else:
-            return ""
+        return ""
 
     @classmethod
-    async def add_friend_info(cls, user_id: int, user_name: str) -> bool:
-        """
-        说明:
-            添加好友信息
-        参数:
-            :param user_id: qq号
-            :param user_name: 用户名称
-        """
-        try:
-            query = cls.query.where(cls.user_id == user_id)
-            user = await query.with_for_update().gino.first()
-            if not user:
-                await cls.create(
-                    user_id=user_id,
-                    user_name=user_name,
-                )
-            else:
-                await user.update(
-                    user_name=user_name,
-                ).apply()
-            return True
-        except Exception:
-            return False
-
-    @classmethod
-    async def delete_friend_info(cls, user_id: int) -> bool:
-        """
-        说明:
-            删除好友信息
-        参数:
-            :param user_id: qq号
-        """
-        try:
-            query = cls.query.where(cls.user_id == user_id)
-            user = await query.with_for_update().gino.first()
-            if user:
-                await user.delete()
-            return True
-        except Exception:
-            return False
-
-    @classmethod
-    async def get_friend_nickname(cls, user_id: int) -> str:
+    async def get_user_nickname(cls, user_id: int) -> str:
         """
         说明:
             获取用户昵称
         参数:
             :param user_id: qq号
         """
-        query = cls.query.where(cls.user_id == user_id)
-        user = await query.gino.first()
-        if user:
+        if user := await cls.get_or_none(user_id=user_id):
             if user.nickname:
                 _tmp = ""
-                black_word = Config.get_config("nickname", "BLACK_WORD")
-                if black_word:
+                if black_word := Config.get_config("nickname", "BLACK_WORD"):
                     for x in user.nickname:
                         _tmp += "*" if x in black_word else x
                 return _tmp
         return ""
 
     @classmethod
-    async def set_friend_nickname(cls, user_id: int, nickname: str) -> bool:
+    async def set_user_nickname(cls, user_id: int, nickname: str):
         """
         说明:
             设置用户昵称
@@ -98,18 +57,4 @@ class FriendUser(db.Model):
             :param user_id: qq号
             :param nickname: 昵称
         """
-        try:
-            query = cls.query.where(cls.user_id == user_id)
-            user = await query.with_for_update().gino.first()
-            if not user:
-                await cls.create(
-                    user_id=user_id,
-                    nickname=nickname,
-                )
-            else:
-                await user.update(
-                    nickname=nickname,
-                ).apply()
-            return True
-        except Exception:
-            return False
+        await cls.update_or_create(user_id=user_id, defaults={"nickname": nickname})

models/goods_info.py

@@ -1,38 +1,50 @@
-from services.db_context import db
-from typing import Optional, List, Tuple
-from services.log import logger
+from typing import Dict, List, Optional, Tuple
+
+from tortoise import fields
+
+from services.db_context import Model
 
 
-class GoodsInfo(db.Model):
+class GoodsInfo(Model):
     __tablename__ = "goods_info"
 
-    id = db.Column(db.Integer(), primary_key=True)
-    goods_name = db.Column(db.TEXT(), nullable=False)  # 名称
-    goods_price = db.Column(db.Integer(), nullable=False)  # 价格
-    goods_description = db.Column(db.TEXT(), nullable=False)  # 商品描述
-    goods_discount = db.Column(db.Numeric(scale=3, asdecimal=False), default=1)  # 打折
-    goods_limit_time = db.Column(db.BigInteger(), default=0)  # 限时
-    daily_limit = db.Column(db.Integer(), nullable=False, default=0)  # 每日购买限制
-    daily_purchase_limit = db.Column(
-        db.JSON(), nullable=False, default={}
-    )  # 每日购买限制数据存储
-    is_passive = db.Column(db.Boolean(), nullable=False, default=0)  # 是否为被动
-    icon = db.Column(db.String(), default=0)  # 图标
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    goods_name = fields.CharField(255, unique=True)
+    """商品名称"""
+    goods_price = fields.IntField()
+    """价格"""
+    goods_description = fields.TextField()
+    """描述"""
+    goods_discount = fields.FloatField(default=1)
+    """折扣"""
+    goods_limit_time = fields.BigIntField(default=0)
+    """限时"""
+    daily_limit = fields.IntField(default=0)
+    """每日限购"""
+    daily_purchase_limit: Dict[str, Dict[str, int]] = fields.JSONField(default={})
+    """用户限购记录"""
+    is_passive = fields.BooleanField(default=False)
+    """是否为被动道具"""
+    icon = fields.TextField(null=True)
+    """图标路径"""
 
-    _idx1 = db.Index("goods_group_users_idx1", "goods_name", unique=True)
+    class Meta:
+        table = "goods_info"
+        table_description = "商品数据表"
 
     @classmethod
     async def add_goods(
-            cls,
-            goods_name: str,
-            goods_price: int,
-            goods_description: str,
-            goods_discount: float = 1,
-            goods_limit_time: int = 0,
-            daily_limit: int = 0,
-            is_passive: bool = False,
-            icon: Optional[str] = None,
-    ) -> bool:
+        cls,
+        goods_name: str,
+        goods_price: int,
+        goods_description: str,
+        goods_discount: float = 1,
+        goods_limit_time: int = 0,
+        daily_limit: int = 0,
+        is_passive: bool = False,
+        icon: Optional[str] = None,
+    ):
         """
         说明:
             添加商品
@@ -46,22 +58,17 @@ class GoodsInfo(db.Model):
             :param is_passive: 是否为被动道具
             :param icon: 图标
         """
-        try:
-            if not await cls.get_goods_info(goods_name):
-                await cls.create(
-                    goods_name=goods_name,
-                    goods_price=goods_price,
-                    goods_description=goods_description,
-                    goods_discount=goods_discount,
-                    goods_limit_time=goods_limit_time,
-                    daily_limit=daily_limit,
-                    is_passive=is_passive,
-                    icon=icon
-                )
-                return True
-        except Exception as e:
-            logger.error(f"GoodsInfo add_goods {goods_name} 发生错误 {type(e)}：{e}")
-        return False
+        if not await cls.filter(goods_name=goods_name).first():
+            await cls.create(
+                goods_name=goods_name,
+                goods_price=goods_price,
+                goods_description=goods_description,
+                goods_discount=goods_discount,
+                goods_limit_time=goods_limit_time,
+                daily_limit=daily_limit,
+                is_passive=is_passive,
+                icon=icon,
+            )
 
     @classmethod
     async def delete_goods(cls, goods_name: str) -> bool:
@@ -71,28 +78,23 @@ class GoodsInfo(db.Model):
         参数:
             :param goods_name: 商品名称
         """
-        query = (
-            await cls.query.where(cls.goods_name == goods_name)
-                .with_for_update()
-                .gino.first()
-        )
-        if not query:
-            return False
-        await query.delete()
-        return True
+        if goods := await cls.get_or_none(goods_name=goods_name):
+            await goods.delete()
+            return True
+        return False
 
     @classmethod
     async def update_goods(
-            cls,
-            goods_name: str,
-            goods_price: Optional[int] = None,
-            goods_description: Optional[str] = None,
-            goods_discount: Optional[float] = None,
-            goods_limit_time: Optional[int] = None,
-            daily_limit: Optional[int] = None,
-            is_passive: Optional[bool] = None,
-            icon: Optional[str] = None,
-    ) -> bool:
+        cls,
+        goods_name: str,
+        goods_price: Optional[int] = None,
+        goods_description: Optional[str] = None,
+        goods_discount: Optional[float] = None,
+        goods_limit_time: Optional[int] = None,
+        daily_limit: Optional[int] = None,
+        is_passive: Optional[bool] = None,
+        icon: Optional[str] = None,
+    ):
         """
         说明:
             更新商品信息
@@ -106,37 +108,25 @@ class GoodsInfo(db.Model):
             :param is_passive: 是否为被动
             :param icon: 图标
         """
-        try:
-            query = (
-                await cls.query.where(cls.goods_name == goods_name)
-                    .with_for_update()
-                    .gino.first()
+        if goods := await cls.get_or_none(goods_name=goods_name):
+            await cls.update_or_create(
+                goods_name=goods_name,
+                defaults={
+                    "goods_price": goods_price or goods.goods_price,
+                    "goods_description": goods_description or goods.goods_description,
+                    "goods_discount": goods_discount or goods.goods_discount,
+                    "goods_limit_time": goods_limit_time
+                    if goods_limit_time is not None
+                    else goods.goods_limit_time,
+                    "daily_limit": daily_limit
+                    if daily_limit is not None
+                    else goods.daily_limit,
+                    "is_passive": is_passive
+                    if is_passive is not None
+                    else goods.is_passive,
+                    "icon": icon or goods.icon,
+                },
             )
-            if not query:
-                return False
-            await query.update(
-                goods_price=goods_price or query.goods_price,
-                goods_description=goods_description or query.goods_description,
-                goods_discount=goods_discount or query.goods_discount,
-                goods_limit_time=goods_limit_time if goods_limit_time is not None else query.goods_limit_time,
-                daily_limit=daily_limit if daily_limit is not None else query.daily_limit,
-                is_passive=is_passive if is_passive is not None else query.is_passive,
-                icon=icon or query.icon
-            ).apply()
-            return True
-        except Exception as e:
-            logger.error(f"GoodsInfo update_goods 发生错误 {type(e)}：{e}")
-        return False
-
-    @classmethod
-    async def get_goods_info(cls, goods_name: str) -> "GoodsInfo":
-        """
-        说明:
-            获取商品对象
-        参数:
-            :param goods_name: 商品名称
-        """
-        return await cls.query.where(cls.goods_name == goods_name).gino.first()
 
     @classmethod
     async def get_all_goods(cls) -> List["GoodsInfo"]:
@@ -144,7 +134,7 @@ class GoodsInfo(db.Model):
         说明:
             获得全部有序商品对象
         """
-        query = await cls.query.gino.all()
+        query = await cls.all()
         id_lst = [x.id for x in query]
         goods_lst = []
         for _ in range(len(query)):
@@ -155,7 +145,7 @@ class GoodsInfo(db.Model):
 
     @classmethod
     async def add_user_daily_purchase(
-            cls, goods: "GoodsInfo", user_id: int, group_id: int, num: int = 1
+        cls, goods: "GoodsInfo", user_id_: int, group_id_: int, num: int = 1
     ):
         """
         说明:
@@ -166,19 +156,19 @@ class GoodsInfo(db.Model):
             :param group_id: 群号
             :param num: 数量
         """
-        user_id = str(user_id)
-        group_id = str(group_id)
+        user_id = str(user_id_)
+        group_id = str(group_id_)
         if goods and goods.daily_limit and goods.daily_limit > 0:
             if not goods.daily_purchase_limit.get(group_id):
                 goods.daily_purchase_limit[group_id] = {}
             if not goods.daily_purchase_limit[group_id].get(user_id):
                 goods.daily_purchase_limit[group_id][user_id] = 0
             goods.daily_purchase_limit[group_id][user_id] += num
-            await goods.update(daily_purchase_limit=goods.daily_purchase_limit).apply()
+            await goods.save(update_fields=["daily_purchase_limit"])
 
     @classmethod
     async def check_user_daily_purchase(
-            cls, goods: "GoodsInfo", user_id: int, group_id: int, num: int = 1
+        cls, goods: "GoodsInfo", user_id_: int, group_id_: int, num: int = 1
     ) -> Tuple[bool, int]:
         """
         说明:
@@ -189,8 +179,8 @@ class GoodsInfo(db.Model):
             :param group_id: 群号
             :param num: 数量
         """
-        user_id = str(user_id)
-        group_id = str(group_id)
+        user_id = str(user_id_)
+        group_id = str(group_id_)
         if goods and goods.daily_limit > 0:
             if (
                 not goods.daily_limit
@@ -204,10 +194,3 @@ class GoodsInfo(db.Model):
                     goods.daily_limit - goods.daily_purchase_limit[group_id][user_id],
                 )
         return False, 0
-
-    @classmethod
-    async def reset_daily_purchase(cls):
-        """
-        重置每次次数限制
-        """
-        await cls.update.values(daily_purchase_limit={}).gino.status()

models/group_info.py

@@ -1,111 +1,24 @@
-from services.db_context import db
-from services.log import logger
 from typing import List, Optional
 
+from tortoise import fields
 
-class GroupInfo(db.Model):
-    __tablename__ = "group_info"
+from services.db_context import Model
+from services.log import logger
 
-    group_id = db.Column(db.BigInteger(), nullable=False, primary_key=True)
-    group_name = db.Column(db.Unicode(), nullable=False, default="")
-    max_member_count = db.Column(db.Integer(), nullable=False, default=0)
-    member_count = db.Column(db.Integer(), nullable=False, default=0)
-    group_flag = db.Column(db.Integer(), nullable=False, default=0)
 
-    _idx1 = db.Index("group_info_idx1", "group_id", unique=True)
+class GroupInfo(Model):
 
-    @classmethod
-    async def get_group_info(cls, group_id: int) -> "GroupInfo":
-        """
-        说明:
-            获取群信息
-        参数:
-            :param group_id: 群号
-        """
-        query = cls.query.where(cls.group_id == group_id)
-        return await query.gino.first()
+    group_id = fields.BigIntField(pk=True)
+    """群聊id"""
+    group_name = fields.TextField(default="")
+    """群聊名称"""
+    max_member_count = fields.IntField(default=0)
+    """最大人数"""
+    member_count = fields.IntField(default=0)
+    """当前人数"""
+    group_flag: int = fields.IntField(default=0)
+    """群认证标记"""
 
-    @classmethod
-    async def add_group_info(
-        cls,
-        group_id: int,
-        group_name: str,
-        max_member_count: int,
-        member_count: int,
-        group_flag: Optional[int] = None,
-    ) -> bool:
-        """
-        说明:
-            添加群信息
-        参数:
-            :param group_id: 群号
-            :param group_name: 群名称
-            :param max_member_count: 群员最大数量
-            :param member_count: 群员数量
-            :param group_flag: 群认证，0为未认证，1为认证
-        """
-        try:
-            group = (
-                await cls.query.where(cls.group_id == group_id)
-                .with_for_update()
-                .gino.first()
-            )
-            if group:
-                await group.update(
-                    group_name=group_name,
-                    max_member_count=max_member_count,
-                    member_count=member_count,
-                ).apply()
-                if group_flag is not None:
-                    await group.update(group_flag=group_flag).apply()
-            else:
-                await cls.create(
-                    group_id=group_id,
-                    group_name=group_name,
-                    max_member_count=max_member_count,
-                    member_count=member_count,
-                    group_flag=group_flag,
-                )
-            return True
-        except Exception as e:
-            logger.info(f"GroupInfo 调用 add_group_info 发生错误 {type(e)}：{e}")
-            return False
-
-    @classmethod
-    async def delete_group_info(cls, group_id: int):
-        """
-        说明:
-            删除群信息
-        参数:
-            :param group_id: 群号
-        """
-        await cls.delete.where(cls.group_id == group_id).gino.status()
-
-    @classmethod
-    async def get_all_group(cls) -> List["GroupInfo"]:
-        """
-        说明:
-            获取所有群对象
-        """
-        query = await cls.query.gino.all()
-        return query
-
-    @classmethod
-    async def set_group_flag(cls, group_id: int, group_flag: int) -> bool:
-        """
-        设置群认证
-        :param group_id: 群号
-        :param group_flag: 群认证，0为未认证，1为认证
-        """
-        group = (
-            await cls.query.where(cls.group_id == group_id)
-            .with_for_update()
-            .gino.first()
-        )
-        if group:
-            if group.group_flag != group_flag:
-                await group.update(
-                    group_flag=group_flag,
-                ).apply()
-            return True
-        return False
+    class Meta:
+        table = "group_info"
+        table_description = "群聊信息表"

models/group_member_info.py

@@ -1,116 +1,48 @@
 from datetime import datetime
+from typing import List, Optional, Set
+
+from tortoise import fields
+
 from configs.config import Config
-from services.db_context import db
-from typing import List, Optional
+from services.db_context import Model
 
 
-class GroupInfoUser(db.Model):
-    __tablename__ = "group_info_users"
+class GroupInfoUser(Model):
 
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    user_name = db.Column(db.Unicode(), nullable=False)
-    group_id = db.Column(db.BigInteger(), nullable=False)
-    user_join_time = db.Column(db.DateTime(), nullable=False)
-    nickname = db.Column(db.Unicode())
-    uid = db.Column(db.BigInteger())
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    user_name = fields.CharField(255, default="")
+    """用户昵称"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    user_join_time = fields.DatetimeField(null=True)
+    """用户入群时间"""
+    nickname = fields.CharField(255, null=True)
+    """群聊昵称"""
+    uid = fields.BigIntField(null=True)
+    """用户uid"""
 
-    _idx1 = db.Index("info_group_users_idx1", "user_qq", "group_id", unique=True)
+    class Meta:
+        table = "group_info_users"
+        table_description = "群员信息数据表"
+        unique_together = ("user_qq", "group_id")
 
     @classmethod
-    async def add_member_info(
-        cls,
-        user_qq: int,
-        group_id: int,
-        user_name: str,
-        user_join_time: datetime,
-        uid: Optional[int] = None,
-    ) -> bool:
-        """
-        说明:
-            添加群内用户信息
-        参数:
-            :param user_qq: qq号
-            :param group_id: 群号
-            :param user_name: 用户名称
-            :param user_join_time: 入群时间
-            :param uid: 用户唯一 id（自动生成）
-        """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        try:
-            if not await query.gino.first():
-                await cls.create(
-                    user_qq=user_qq,
-                    user_name=user_name,
-                    group_id=group_id,
-                    user_join_time=user_join_time,
-                    uid=uid
-                )
-            return True
-        except Exception:
-            return False
-
-    @classmethod
-    async def get_member_info(
-        cls, user_qq: int, group_id: int
-    ) -> "GroupInfoUser":
-        """
-        说明:
-            查询群员信息
-        参数:
-            :param user_qq: qq号
-            :param group_id: 群号
-        """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        return await query.gino.first()
-
-    @classmethod
-    async def delete_member_info(cls, user_qq: int, group_id: int) -> bool:
-        """
-        说明:
-            删除群员信息
-        参数:
-            :param user_qq: qq号
-            :param group_id: 群号
-        """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        query = query.with_for_update()
-        user = await query.gino.first()
-        try:
-            if user is None:
-                return True
-            else:
-                await cls.delete.where(
-                    (cls.user_qq == user_qq) & (cls.group_id == group_id)
-                ).gino.status()
-                return True
-        except Exception:
-            return False
-
-    @classmethod
-    async def get_group_member_id_list(cls, group_id: int) -> List[int]:
+    async def get_group_member_id_list(cls, group_id: int) -> Set[int]:
         """
         说明:
             获取该群所有用户qq
         参数:
             :param group_id: 群号
         """
-        member_list = []
-        query = cls.query.where((cls.group_id == group_id))
-        for user in await query.gino.all():
-            member_list.append(user.user_qq)
-        return member_list
+        return set(
+            await cls.filter(group_id=group_id).values_list("user_qq", flat=True)
+        )
 
     @classmethod
-    async def set_group_member_nickname(
-        cls, user_qq: int, group_id: int, nickname: str
-    ) -> bool:
+    async def set_user_nickname(cls, user_qq: int, group_id: int, nickname: str):
         """
         说明:
             设置群员在该群内的昵称
@@ -119,14 +51,11 @@ class GroupInfoUser(db.Model):
             :param group_id: 群号
             :param nickname: 昵称
         """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
+        await cls.update_or_create(
+            user_qq=user_qq,
+            group_id=group_id,
+            defaults={"nickname": nickname},
         )
-        user = await query.with_for_update().gino.first()
-        if user:
-            await user.update(nickname=nickname).apply()
-            return True
-        return False
 
     @classmethod
     async def get_user_all_group(cls, user_qq: int) -> List[int]:
@@ -136,13 +65,12 @@ class GroupInfoUser(db.Model):
         参数:
             :param user_qq: 用户qq
         """
-        query = await cls.query.where(cls.user_qq == user_qq).gino.all()
-        if query:
-            query = [x.group_id for x in query]
-        return query
+        return list(
+            await cls.filter(user_qq=user_qq).values_list("group_id", flat=True)
+        )
 
     @classmethod
-    async def get_group_member_nickname(cls, user_qq: int, group_id: int) -> str:
+    async def get_user_nickname(cls, user_qq: int, group_id: int) -> str:
         """
         说明:
             获取用户在该群的昵称
@@ -150,46 +78,34 @@ class GroupInfoUser(db.Model):
             :param user_qq: qq号
             :param group_id: 群号
         """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        user = await query.gino.first()
-        if user:
+        if user := await cls.get_or_none(user_qq=user_qq, group_id=group_id):
             if user.nickname:
-                _tmp = ""
-                black_word = Config.get_config("nickname", "BLACK_WORD")
-                if black_word:
+                nickname = ""
+                if black_word := Config.get_config("nickname", "BLACK_WORD"):
                     for x in user.nickname:
-                        _tmp += "*" if x in black_word else x
-                return _tmp
+                        nickname += "*" if x in black_word else x
+                    return nickname
+                return user.nickname
         return ""
 
     @classmethod
-    async def get_group_member_uid(cls, user_qq: int, group_id: int) -> Optional[str]:
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        user = await query.gino.first()
-        _max_uid = cls.query.where((cls.user_qq == 114514) & (cls.group_id == 114514)).with_for_update()
-        _max_uid_user = await _max_uid.gino.first()
+    async def get_group_member_uid(cls, user_qq: int, group_id: int) -> Optional[int]:
+        user, _ = await cls.get_or_create(user_qq=user_qq, group_id=group_id)
+        _max_uid_user, _ = await cls.get_or_create(user_qq=114514, group_id=114514)
         _max_uid = _max_uid_user.uid
-        if not user or not user.uid:
-            all_user = await cls.query.where(cls.user_qq == user_qq).gino.all()
+        if not user.uid:
+            all_user = await cls.filter(user_qq=user_qq).all()
             for x in all_user:
                 if x.uid:
                     return x.uid
-            else:
-                if not user:
-                    await GroupInfoUser.add_member_info(user_qq, group_id, '', datetime.min)
-                    user = await cls.query.where(
-                        (cls.user_qq == user_qq) & (cls.group_id == group_id)
-                    ).gino.first()
-                await user.update(
-                    uid=_max_uid + 1,
-                ).apply()
-                await _max_uid_user.update(
-                    uid=_max_uid + 1,
-                ).apply()
-
-        return user.uid if user and user.uid else None
+            user.uid = _max_uid + 1
+            _max_uid_user.uid = _max_uid + 1
+            await cls.bulk_update([user, _max_uid_user], ["uid"])
+        return user.uid
 
+    @classmethod
+    async def _run_script(cls):
+        await cls.raw(
+            "alter table group_info_users alter user_join_time drop not null;"
+        )
+        """允许 user_join_time 为空"""

models/level_user.py

@@ -1,18 +1,25 @@
-from asyncpg import UniqueViolationError
+from tortoise import fields
 
-from services.db_context import db
+from services.db_context import Model
 
 
-class LevelUser(db.Model):
-    __tablename__ = "level_users"
+class LevelUser(Model):
 
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    group_id = db.Column(db.BigInteger(), nullable=False)
-    user_level = db.Column(db.BigInteger(), nullable=False)
-    group_flag = db.Column(db.Integer(), nullable=False, default=0)
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    user_level = fields.BigIntField()
+    """用户权限等级"""
+    group_flag = fields.IntField(default=0)
+    """特殊标记，是否随群管理员变更而设置权限"""
 
-    _idx1 = db.Index("level_group_users_idx1", "user_qq", "group_id", unique=True)
+    class Meta:
+        table = "level_users"
+        table_description = "用户权限数据库"
+        unique_together = ("user_qq", "group_id")
 
     @classmethod
     async def get_user_level(cls, user_qq: int, group_id: int) -> int:
@@ -23,17 +30,14 @@ class LevelUser(db.Model):
             :param user_qq: qq号
             :param group_id: 群号
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        user = await query.gino.first()
-        if user:
+        if user := await cls.get_or_none(user_qq=user_qq, group_id=group_id):
             return user.user_level
-        else:
-            return -1
+        return -1
 
     @classmethod
     async def set_level(
         cls, user_qq: int, group_id: int, level: int, group_flag: int = 0
-    ) -> bool:
+    ):
         """
         说明:
             设置用户在群内的权限
@@ -43,23 +47,11 @@ class LevelUser(db.Model):
             :param level: 权限等级
             :param group_flag: 是否被自动更新刷新权限 0：是，1：否
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        try:
-            if not user:
-                await cls.create(
-                    user_qq=user_qq,
-                    group_id=group_id,
-                    user_level=level,
-                    group_flag=group_flag,
-                )
-                return True
-            else:
-                await user.update(user_level=level, group_flag=group_flag).apply()
-                return False
-        except UniqueViolationError:
-            return False
+        await cls.update_or_create(
+            user_qq=user_qq,
+            group_id=group_id,
+            defaults={"user_level": level, "group_flag": group_flag},
+        )
 
     @classmethod
     async def delete_level(cls, user_qq: int, group_id: int) -> bool:
@@ -70,14 +62,10 @@ class LevelUser(db.Model):
             :param user_qq: qq号
             :param group_id: 群号
         """
-        query = cls.query.where((cls.user_qq == user_qq) & (cls.group_id == group_id))
-        query = query.with_for_update()
-        user = await query.gino.first()
-        if user is None:
-            return False
-        else:
+        if user := await cls.get_or_none(user_qq=user_qq, group_id=group_id):
             await user.delete()
             return True
+        return False
 
     @classmethod
     async def check_level(cls, user_qq: int, group_id: int, level: int) -> bool:
@@ -89,25 +77,14 @@ class LevelUser(db.Model):
             :param group_id: 群号
             :param level: 权限等级
         """
-        if group_id != 0:
-            query = cls.query.where(
-                (cls.user_qq == user_qq) & (cls.group_id == group_id)
-            )
-            user = await query.gino.first()
-            if user is None:
-                return False
-            user_level = user.user_level
+        if group_id:
+            if user := await cls.get_or_none(user_qq=user_qq, group_id=group_id):
+                return user.user_level > level
         else:
-            query = cls.query.where(cls.user_qq == user_qq)
-            highest_level = 0
-            for user in await query.gino.all():
-                if user.user_level > highest_level:
-                    highest_level = user.user_level
-            user_level = highest_level
-        if user_level >= level:
-            return True
-        else:
-            return False
+            user_list = await cls.filter(user_qq=user_qq).all()
+            user = max(user_list, key=lambda x: x.user_level)
+            return user.user_level > level
+        return False
 
     @classmethod
     async def is_group_flag(cls, user_qq: int, group_id: int) -> bool:
@@ -118,12 +95,6 @@ class LevelUser(db.Model):
             :param user_qq: qq号
             :param group_id: 群号
         """
-        user = await cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        ).gino.first()
-        if not user:
-            return False
-        if user.group_flag == 1:
-            return True
-        else:
-            return False
+        if user := await cls.get_or_none(user_qq=user_qq, group_id=group_id):
+            return user.group_flag == 1
+        return False

models/sign_group_user.py

@@ -1,99 +1,78 @@
 from datetime import datetime
-from typing import List
-from services.db_context import db
+from typing import Dict, List, Literal, Optional, Tuple, Union
+
+from tortoise import fields
+
+from services.db_context import Model
 
 
-class SignGroupUser(db.Model):
-    __tablename__ = "sign_group_users"
+class SignGroupUser(Model):
 
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    group_id = db.Column(db.BigInteger(), nullable=False)
-    checkin_count = db.Column(db.Integer(), nullable=False)
-    checkin_time_last = db.Column(db.DateTime(timezone=True), nullable=False)
-    impression = db.Column(db.Numeric(scale=3, asdecimal=False), nullable=False)
-    add_probability = db.Column(
-        db.Numeric(scale=3, asdecimal=False), nullable=False, default=0
-    )
-    specify_probability = db.Column(
-        db.Numeric(scale=3, asdecimal=False), nullable=False, default=0
-    )
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    checkin_count = fields.IntField(default=0)
+    """签到次数"""
+    checkin_time_last = fields.DatetimeField(auto_now=True)
+    """最后签到时间"""
+    impression = fields.DecimalField(10, 3, default=0)
+    """好感度"""
+    add_probability = fields.DecimalField(10, 3, default=0)
+    """双倍签到增加概率"""
+    specify_probability = fields.DecimalField(10, 3, default=0)
+    """使用指定双倍概率"""
+    # specify_probability = fields.DecimalField(10, 3, default=0)
 
-    _idx1 = db.Index("sign_group_users_idx1", "user_qq", "group_id", unique=True)
+    class Meta:
+        table = "sign_group_users"
+        table_description = "群员签到数据表"
+        unique_together = ("user_qq", "group_id")
 
     @classmethod
-    async def ensure(
-        cls, user_qq: int, group_id: int, for_update: bool = False
-    ) -> "SignGroupUser":
-        """
-        说明:
-            获取签到用户
-        参数:
-            :param user_qq: 用户qq
-            :param group_id: 所在群聊
-            :param for_update: 是否存在修改数据
-        """
-        query = cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_id == group_id)
-        )
-        if for_update:
-            query = query.with_for_update()
-        user = await query.gino.first()
-        return user or await cls.create(
-            user_qq=user_qq,
-            group_id=group_id,
-            checkin_count=0,
-            checkin_time_last=datetime.min,  # 从未签到过
-            impression=0,
-        )
-
-    @classmethod
-    async def get_user_all_data(cls, user_qq: int) -> List["SignGroupUser"]:
-        """
-        说明:
-            获取某用户所有数据
-        参数:
-            :param user_qq: 用户qq
-        """
-        query = cls.query.where(cls.user_qq == user_qq)
-        query = query.with_for_update()
-        return await query.gino.all()
-
-    @classmethod
-    async def sign(cls, user: "SignGroupUser", impression: float, checkin_time_last: datetime):
+    async def sign(cls, user: "SignGroupUser", impression: float):
         """
         说明:
             签到
         说明:
             :param user: 用户
             :param impression: 增加的好感度
-            :param checkin_time_last: 签到时间
         """
-        await user.update(
-            checkin_count=user.checkin_count + 1,
-            checkin_time_last=checkin_time_last,
-            impression=user.impression + impression,
-            add_probability=0,
-            specify_probability=0,
-        ).apply()
+        user.checkin_count = user.checkin_count + 1
+        user.add_probability = 0
+        user.specify_probability = 0
+        user.impression = float(user.impression) + impression
+        await user.save(
+            update_fields=[
+                "checkin_count",
+                "add_probability",
+                "specify_probability",
+                "impression",
+            ]
+        )
 
     @classmethod
-    async def get_all_impression(cls, group_id: int) -> "list, list, list":
+    async def get_all_impression(
+        cls, group_id: Optional[int]
+    ) -> Tuple[List[int], List[int], List[float]]:
         """
         说明:
             获取该群所有用户 id 及对应 好感度
         参数:
             :param group_id: 群号
         """
-        impression_list = []
-        user_qq_list = []
-        user_group = []
         if group_id:
-            query = cls.query.where(cls.group_id == group_id)
+            query = cls.filter(group_id=group_id)
         else:
-            query = cls.query
-        for user in await query.gino.all():
-            impression_list.append(user.impression)
-            user_qq_list.append(user.user_qq)
-            user_group.append(user.group_id)
-        return user_qq_list, impression_list, user_group
+            query = cls
+        value_list = await query.all().values_list("user_qq", "group_id", "impression")  # type: ignore
+        qq_list = []
+        group_list = []
+        impression_list = []
+        for value in value_list:
+            qq_list.append(value[0])
+            group_list.append(value[1])
+            impression_list.append(float(value[2]))
+        return qq_list, impression_list, group_list

models/user_shop_gold_log.py

@@ -1,59 +1,29 @@
 from datetime import datetime
 
-from services.db_context import db
+from tortoise import fields
+
+from services.db_context import Model
 
 
-class UserShopGoldLog(db.Model):
-    __tablename__ = "user_shop_gold_log"
-    id = db.Column(db.Integer(), primary_key=True)
-    user_qq = db.Column(db.BigInteger(), nullable=False)
-    group_id = db.Column(db.BigInteger(), nullable=False)
-    type = db.Column(db.Integer(), nullable=False)  # 0: 购买，1: 使用，2: 插件
-    name = db.Column(db.String())
-    spend_gold = db.Column(db.Integer(), nullable=False)
-    num = db.Column(db.Integer(), nullable=False)
-    create_time = db.Column(db.DateTime(timezone=True), nullable=False)
+class UserShopGoldLog(Model):
 
-    @classmethod
-    async def add_shop_log(
-        cls,
-        user_qq: int,
-        group_id: int,
-        type_: int,
-        name: str,
-        num: int,
-        spend_gold: int = 0,
-    ):
-        """
-        说明:
-            添加商店购买或使用日志
-        参数:
-            :param user_qq: qq号
-            :param group_id: 所在群号
-            :param type_: 类型
-            :param name: 商品名称
-            :param num: 数量
-            :param spend_gold: 花费金币
-        """
-        await cls.create(
-            user_qq=user_qq,
-            group_id=group_id,
-            type=type_,
-            name=name,
-            num=num,
-            spend_gold=spend_gold,
-            create_time=datetime.now(),
-        )
+    id = fields.IntField(pk=True, generated=True, auto_increment=True)
+    """自增id"""
+    user_qq = fields.BigIntField()
+    """用户id"""
+    group_id = fields.BigIntField()
+    """群聊id"""
+    type = fields.IntField()
+    """金币使用类型 0: 购买, 1: 使用, 2: 插件"""
+    name = fields.CharField(255)
+    """商品/插件 名称"""
+    spend_gold = fields.IntField(default=0)
+    """花费金币"""
+    num = fields.IntField()
+    """数量"""
+    create_time = fields.DatetimeField(auto_now_add=True)
+    """创建时间"""
 
-    @classmethod
-    async def get_user_log(cls, user_qq: int, group_id: int) -> "UserShopGoldLog":
-        """
-        说明:
-            获取用户日志
-        参数:
-            :param user_qq: qq号
-            :param group_id: 所在群号
-        """
-        return await cls.query.where(
-            (cls.user_qq == user_qq) & (cls.group_qq == group_id)
-        ).first()
+    class Meta:
+        table = "user_shop_gold_log"
+        table_description = "金币使用日志表"