版本更新

2026-10-06 04:10:02 +08:00 · 2024-10-20 21:11:16 +08:00
parent 4e33bf3a50
commit d594d17bf6
253 changed files with 34987 additions and 2241 deletions
@@ -1,16 +1,18 @@
 from nonebot import on_notice
-from nonebot.adapters.onebot.v11 import GroupAdminNoticeEvent
 from nonebot.plugin import PluginMetadata
+from nonebot.adapters.onebot.v11 import GroupAdminNoticeEvent

-from zhenxun.configs.config import Config
-from zhenxun.configs.utils import PluginExtraData, RegisterConfig
-from zhenxun.models.level_user import LevelUser
 from zhenxun.services.log import logger
+from zhenxun.configs.config import Config
 from zhenxun.utils.enum import PluginType
+from zhenxun.utils.rules import notice_rule
+from zhenxun.models.level_user import LevelUser
+from zhenxun.configs.utils import RegisterConfig, PluginExtraData

 __plugin_meta__ = PluginMetadata(
    name="群管理员变动监测",
-    description="检测群管理员变动, 添加与删除管理员默认权限, 当配置项 ADMIN_DEFAULT_AUTH 为空时, 不会添加管理员权限",
+    description="""检测群管理员变动, 添加与删除管理员默认权限,
+    当配置项 ADMIN_DEFAULT_AUTH 为空时, 不会添加管理员权限""",
    usage="",
    extra=PluginExtraData(
        author="HibiKier",
@@ -29,7 +31,7 @@ __plugin_meta__ = PluginMetadata(
 )


-admin_notice = on_notice(priority=5)
+admin_notice = on_notice(priority=5, rule=notice_rule(GroupAdminNoticeEvent))

 base_config = Config.get("admin_bot_manage")

@@ -52,7 +54,8 @@ async def _(event: GroupAdminNoticeEvent):
            )
        else:
            logger.warning(
-                f"配置项 MODULE: [<u><y>admin_bot_manage</y></u>] | KEY: [<u><y>ADMIN_DEFAULT_AUTH</y></u>] 为空"
+                "配置项 MODULE: [<u><y>admin_bot_manage</y></u>] |"
+                " KEY: [<u><y>ADMIN_DEFAULT_AUTH</y></u>] 为空"
            )
    elif event.sub_type == "unset":
        await LevelUser.delete_level(str(event.user_id), str(event.group_id))
@@ -30,7 +30,7 @@ __plugin_meta__ = PluginMetadata(
    usage="""
    普通管理员
        格式:
-        ban [At用户] -t [时长(分钟)]
+        ban [At用户] ?[-t [时长(分钟)]]

        示例:
        ban @用户          : 永久拉黑用户
@@ -44,7 +44,8 @@ __plugin_meta__ = PluginMetadata(
        superuser_help="""
        超级管理员额外命令
        格式:
-        ban [At用户/用户Id] [时长]
+        ban [At用户/用户Id] ?[-t [时长]]
+        unban --id [idx]  : 通过id来进行unban操作
        ban列表: 获取所有Ban数据

        群组ban列表: 获取群组Ban数据
@@ -98,6 +99,7 @@ _unban_matcher = on_alconna(
        "unban",
        Args["user?", [str, At]],
        Option("-g|--group", Args["group_id", str]),
+        Option("--id", Args["idx", int]),
    ),
    rule=admin_check("ban", "BAN_LEVEL"),
    priority=5,
@@ -238,8 +240,10 @@ async def _(
    arparma: Arparma,
    user: Match[str | At],
    group_id: Match[str],
+    idx: Match[int],
 ):
    user_id = ""
+    _idx = idx.result if idx.available else None
    if user.available:
        if isinstance(user.result, At):
            user_id = user.result.target
@@ -248,48 +252,44 @@ async def _(
                await MessageUtils.build_message("权限不足捏...").finish(reply_to=True)
            user_id = user.result
    if gid := session.id3 or session.id2:
-        u_d = user_id
        if group_id.available:
-            u_d = gid
            gid = group_id.result
-        if await BanManage.unban(
-            user_id, gid, session, session.id1 in bot.config.superusers
-        ):
-            logger.info(
-                "管理员UnBan",
-                arparma.header_result,
-                session=session,
-                target=f"{gid}:{user_id}",
-            )
-            await MessageUtils.build_message(
-                [
-                    "将 ",
-                    (
-                        At(flag="user", target=user_id)
-                        if isinstance(user.result, At)
-                        else u_d
-                    ),  # type: ignore
-                    " 从黑屋中拉了出来并急救了一下!",
-                ]
-            ).finish(reply_to=True)
-        else:
-            await MessageUtils.build_message("该用户不在黑名单中捏...").finish(
-                reply_to=True
-            )
+        is_unban, result = await BanManage.unban(
+            user_id, gid, session, _idx, session.id1 in bot.config.superusers
+        )
+        if not is_unban:
+            await MessageUtils.build_message(result).finish(reply_to=True)
+        logger.info(
+            "管理员UnBan",
+            arparma.header_result,
+            session=session,
+            target=f"{gid}:{result}",
+        )
+        await MessageUtils.build_message(
+            [
+                "将 ",
+                (
+                    At(flag="user", target=user_id)
+                    if isinstance(user.result, At)
+                    else result
+                ),  # type: ignore
+                " 从黑屋中拉了出来并急救了一下!",
+            ]
+        ).finish(reply_to=True)
    elif session.id1 in bot.config.superusers:
        _group_id = group_id.result if group_id.available else None
-        if await BanManage.unban(user_id, _group_id, session, True):
-            logger.info(
-                "超级用户UnBan",
-                arparma.header_result,
-                session=session,
-                target=f"{_group_id}:{user_id}",
-            )
-            at_msg = user_id or f"群组:{_group_id}"
-            await MessageUtils.build_message(
-                f"对 {at_msg} 从黑屋中拉了出来并急救了一下!"
-            ).finish(reply_to=True)
-        else:
-            await MessageUtils.build_message("该用户不在黑名单中捏...").finish(
-                reply_to=True
-            )
+        is_unban, result = await BanManage.unban(
+            user_id, _group_id, session, _idx, True
+        )
+        if not is_unban:
+            await MessageUtils.build_message(result).finish(reply_to=True)
+        logger.info(
+            "超级用户UnBan",
+            arparma.header_result,
+            session=session,
+            target=f"{_group_id}:{user_id}",
+        )
+        at_msg = user_id or f"群组:{result}"
+        await MessageUtils.build_message(
+            f"对 {at_msg} 从黑屋中拉了出来并急救了一下!"
+        ).finish(reply_to=True)
@@ -32,11 +32,10 @@ class BanManage:
            query = query.filter(user_id=user_id)
        elif group_id:
            query = query.filter(group_id=group_id)
-        else:
-            if filter_type == "user":
-                query = query.filter(group_id__isnull=True)
-            elif filter_type == "group":
-                query = query.filter(user_id__isnull=True)
+        elif filter_type == "user":
+            query = query.filter(group_id__isnull=True)
+        elif filter_type == "group":
+            query = query.filter(user_id__isnull=True)
        data_list = await query.all()
        if not data_list:
            return None
@@ -85,26 +84,36 @@ class BanManage:
        user_id: str | None,
        group_id: str | None,
        session: EventSession,
+        idx: int | None = None,
        is_superuser: bool = False,
-    ) -> bool:
+    ) -> tuple[bool, str]:
        """unban目标用户

        参数:
            user_id: 用户id
            group_id: 群组id
            session: Session
+            idx: 指定id
            is_superuser: 是否为超级用户操作

        返回:
-            bool: 是否unban成功
+            tuple[bool, str]: 是否unban成功, 群组/用户id或提示
        """
        user_level = 9999
        if not is_superuser and user_id and session.id1:
            user_level = await LevelUser.get_user_level(session.id1, group_id)
-        if await BanConsole.check_ban_level(user_id, group_id, user_level):
+        if idx:
+            ban_data = await BanConsole.get_or_none(id=idx)
+            if not ban_data:
+                return False, "该用户/群组不在黑名单中不足捏..."
+            if ban_data.ban_level > user_level:
+                return False, "unBan权限等级不足捏..."
+            await ban_data.delete()
+            return True, str(ban_data.user_id or ban_data.group_id)
+        elif await BanConsole.check_ban_level(user_id, group_id, user_level):
            await BanConsole.unban(user_id, group_id)
-            return True
-        return False
+            return True, str(group_id)
+        return False, "该用户/群组不在黑名单中不足捏..."

    @classmethod
    async def ban(
@@ -1,19 +1,19 @@
 import nonebot
 from nonebot import on_notice
 from nonebot.adapters import Bot
-from nonebot.adapters.onebot.v11 import GroupIncreaseNoticeEvent
 from nonebot.plugin import PluginMetadata
-from nonebot_plugin_alconna import Alconna, Arparma, on_alconna
-from nonebot_plugin_apscheduler import scheduler
 from nonebot_plugin_session import EventSession
+from nonebot_plugin_apscheduler import scheduler
+from nonebot_plugin_alconna import Alconna, Arparma, on_alconna
+from nonebot.adapters.onebot.v11 import GroupIncreaseNoticeEvent

-from zhenxun.configs.config import BotConfig
-from zhenxun.configs.utils import PluginExtraData
 from zhenxun.services.log import logger
 from zhenxun.utils.enum import PluginType
+from zhenxun.configs.config import BotConfig
 from zhenxun.utils.message import MessageUtils
 from zhenxun.utils.platform import PlatformUtils
-from zhenxun.utils.rules import admin_check, ensure_group
+from zhenxun.configs.utils import PluginExtraData
+from zhenxun.utils.rules import admin_check, notice_rule, ensure_group

 from ._data_source import MemberUpdateManage

@@ -42,25 +42,22 @@ _matcher = on_alconna(
 )


-_notice = on_notice(priority=1, block=False)
+_notice = on_notice(priority=1, block=False, rule=notice_rule(GroupIncreaseNoticeEvent))


@_matcher.handle()
 async def _(bot: Bot, session: EventSession, arparma: Arparma):
    if gid := session.id3 or session.id2:
        logger.info("更新群组成员信息", arparma.header_result, session=session)
-        await MemberUpdateManage.update(bot, gid)
-        await MessageUtils.build_message("已经成功更新了群组成员信息!").finish(
-            reply_to=True
-        )
+        result = await MemberUpdateManage.update_group_member(bot, gid)
+        await MessageUtils.build_message(result).finish(reply_to=True)
    await MessageUtils.build_message("群组id为空...").send()


@_notice.handle()
 async def _(bot: Bot, event: GroupIncreaseNoticeEvent):
-    # TODO: 其他适配器的加群自动更新群组成员信息
    if str(event.user_id) == bot.self_id:
-        await MemberUpdateManage.update(bot, str(event.group_id))
+        await MemberUpdateManage.update_group_member(bot, str(event.group_id))
        logger.info(
            f"{BotConfig.self_nickname}加入群聊更新群组信息",
            "更新群组成员列表",
@@ -81,7 +78,9 @@ async def _():
                if group_list:
                    for group in group_list:
                        try:
-                            await MemberUpdateManage.update(bot, group.group_id)
+                            await MemberUpdateManage.update_group_member(
+                                bot, group.group_id
+                            )
                            logger.debug("自动更新群组成员信息成功...")
                        except Exception as e:
                            logger.error(
@@ -1,213 +1,132 @@
-from datetime import datetime, timezone, timedelta
+from datetime import datetime

+import nonebot
 from nonebot.adapters import Bot
-
-# from nonebot.adapters.kaiheila import Bot as KaiheilaBot
-from nonebot.adapters.onebot.v11 import Bot as v11Bot
-from nonebot.adapters.onebot.v12 import Bot as v12Bot
+from nonebot_plugin_uninfo import Member, SceneType, get_interface

 from zhenxun.services.log import logger
 from zhenxun.configs.config import Config
 from zhenxun.models.level_user import LevelUser
+from zhenxun.utils.platform import PlatformUtils
 from zhenxun.models.group_member_info import GroupInfoUser

-# from nonebot.adapters.discord import Bot as DiscordBot
-# from nonebot.adapters.dodo import Bot as DodoBot
-

 class MemberUpdateManage:
-
    @classmethod
-    async def update(cls, bot: Bot, group_id: str):
-        if not group_id:
-            return logger.warning(
-                f"bot: {bot.self_id}，group_id为空，无法更新群成员信息..."
-            )
-        if isinstance(bot, v11Bot):
-            await cls.v11(bot, group_id)
-        elif isinstance(bot, v12Bot):
-            await cls.v12(bot, group_id)
-        # elif isinstance(bot, KaiheilaBot):
-        #     await cls.kaiheila(bot, group_id)
-        # elif isinstance(bot, DodoBot):
-        #     await cls.dodo(bot, group_id)
-        # elif isinstance(bot, DiscordBot):
-        #     await cls.discord(bot, group_id)
+    async def __handle_user(
+        cls,
+        member: Member,
+        db_user: list[GroupInfoUser],
+        group_id: str,
+        data_list: tuple[list, list, list],
+        platform: str | None,
+    ):
+        """单个成员操作

-    # @classmethod
-    # async def discord(cls, bot: DiscordBot, group_id: str):
-    #     # TODO: discord更新群组成员信息
-    #     pass
-
-    # @classmethod
-    # async def dodo(cls, bot: DodoBot, group_id: str):
-    #     page_size = 100
-    #     result_size = 100
-    #     max_id = 0
-    #     exist_member_list = []
-    #     group_member_list: list[MemberInfo] = []
-    #     while result_size == page_size:
-    #         group_member_data = await bot.get_member_list(
-    #             island_source_id=group_id, page_size=page_size
-    #         )
-    #         result_size = len(group_member_data.list)
-    #         group_member_list += group_member_data.list
-    #         max_id = group_member_data.max_id
-    #     if group_member_list:
-    #         for user in group_member_list:
-    #             exist_member_list.append(user.dodo_source_id)
-    #             await GroupInfoUser.update_or_create(
-    #                 user_id=user.dodo_source_id,
-    #                 group_id=group_id,
-    #                 defaults={
-    #                     "user_name": user.nick_name or user.personal_nick_name,
-    #                     "user_join_time": user.join_time,
-    #                     "platform": "dodo",
-    #                 },
-    #             )
-    #     if delete_member_list := list(
-    #         set(exist_member_list).difference(
-    #             set(await GroupInfoUser.get_group_member_id_list(group_id))
-    #         )
-    #     ):
-    #         await GroupInfoUser.filter(
-    #             user_id__in=delete_member_list, group_id=group_id
-    #         ).delete()
-    #         logger.info(
-    #             f"删除已退群用户",
-    #             "更新群组成员信息",
-    #             group_id=group_id,
-    #             platform="dodo",
-    #         )
-
-    # @classmethod
-    # async def kaiheila(cls, bot: KaiheilaBot, group_id: str):
-    #     # TODO: kaiheila 更新群组成员信息
-    #     pass
-
-    @classmethod
-    async def v11(cls, bot: v11Bot, group_id: str):
-        exist_member_list = []
+        参数:
+            member: Member
+            db_user: db成员数据
+            group_id: 群组id
+            data_list: 数据列表
+            platform: 平台
+        """
+        driver = nonebot.get_driver()
        default_auth = Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH")
-        group_member_list = await bot.get_group_member_list(group_id=int(group_id))
-        db_user = await GroupInfoUser.filter(group_id=group_id).all()
+        nickname = member.nick or member.user.name or ""
+        role = member.role
        db_user_uid = [u.user_id for u in db_user]
        uid2name = {u.user_id: u.user_name for u in db_user}
-        create_list = []
-        update_list = []
-        delete_list = []
-        for user_info in group_member_list:
-            user_id = str(user_info["user_id"])
-            nickname = user_info["card"] or user_info["nickname"]
-            role = user_info["role"]
-            if (
-                default_auth
-                and role in ["owner", "admin"]
-                and not await LevelUser.is_group_flag(user_id, group_id)
+        if member.id in driver.config.superusers:
+            await LevelUser.set_level(member.id, group_id, 9)
+        elif role and default_auth:
+            if role.id != "MEMBER" and not await LevelUser.is_group_flag(
+                member.id, group_id
            ):
-                if role == "owner":
-                    await LevelUser.set_level(user_id, group_id, default_auth + 1)
-                else:
-                    await LevelUser.set_level(user_id, group_id, default_auth)
-            if user_id in bot.config.superusers:
-                await LevelUser.set_level(user_id, group_id, 9)
-            join_time = datetime.fromtimestamp(
-                user_info["join_time"], timezone(timedelta(hours=8))
-            )
-            if cnt := db_user_uid.count(user_id):
-                users = [u for u in db_user if u.user_id == user_id]
-                if cnt > 1:
-                    for u in users[1:]:
-                        delete_list.append(u.id)
-                if nickname != uid2name.get(user_id):
-                    user = users[0]
-                    user.user_name = nickname
-                    update_list.append(user)
-            else:
-                create_list.append(
-                    GroupInfoUser(
-                        user_id=user_id,
-                        group_id=group_id,
-                        user_name=nickname,
-                        user_join_time=join_time,
-                        platform="qq",
-                    )
+                if role.id == "OWNER":
+                    await LevelUser.set_level(member.id, group_id, default_auth + 1)
+                elif role.id == "ADMINISTRATOR":
+                    await LevelUser.set_level(member.id, group_id, default_auth)
+        if cnt := db_user_uid.count(member.id):
+            users = [u for u in db_user if u.user_id == member.id]
+            if cnt > 1:
+                for u in users[1:]:
+                    data_list[2].append(u.id)
+            if nickname != uid2name.get(member.id):
+                user = users[0]
+                user.user_name = nickname
+                data_list[1].append(user)
+        else:
+            data_list[0].append(
+                GroupInfoUser(
+                    user_id=member.id,
+                    group_id=group_id,
+                    user_name=nickname,
+                    user_join_time=member.joined_at or datetime.now(),
+                    platform=platform,
                )
-            exist_member_list.append(user_id)
-        if create_list:
-            await GroupInfoUser.bulk_create(create_list, 30)
-            logger.debug(
-                f"创建用户数据 {len(create_list)} 条",
-                "更新群组成员信息",
-                target=group_id,
-            )
-        if update_list:
-            await GroupInfoUser.bulk_update(update_list, ["user_name"], 30)
-            logger.debug(
-                f"更新户数据 {len(update_list)} 条", "更新群组成员信息", target=group_id
-            )
-        if delete_list:
-            await GroupInfoUser.filter(id__in=delete_list).delete()
-            logger.debug(f"删除重复数据 Ids: {delete_list}", "更新群组成员信息")
-
-        if delete_member_list := [
-            uid for uid in db_user_uid if uid not in exist_member_list
-        ]:
-            await GroupInfoUser.filter(
-                user_id__in=delete_member_list, group_id=group_id
-            ).delete()
-            logger.info(
-                f"删除已退群用户 {len(delete_member_list)} 条",
-                "更新群组成员信息",
-                group_id=group_id,
-                platform="qq",
            )

    @classmethod
-    async def v12(cls, bot: v12Bot, group_id: str):
-        # TODO: v12更新群组成员信息
-        pass
-        # exist_member_list = []
-        # default_auth = Config.get_config("admin_bot_manage", "ADMIN_DEFAULT_AUTH")
-        # group_member_list: list[GetGroupMemberInfoResp] =
-        # await bot.get_group_member_list(
-        #     group_id=group_id
-        # )
-        # for user_info in group_member_list:
-        #     user_id = user_info.user_id
-        #     nickname = user_info.user_displayname or user_info.user_name
-        #     role = user_info["role"]
-        #     if default_auth:
-        #         if role in ["owner", "admin"] and not LevelUser.is_group_flag(
-        #             str(user_id), group_id
-        #         ):
-        #             await LevelUser.set_level(user_id, group_id, default_auth)
-        #     if str(user_id) in bot.config.superusers:
-        #         await LevelUser.set_level(str(user_id), group_id, 9)
-        #     join_time = datetime.strptime(
-        #         time.strftime("%Y-%m-%d %H:%M:%S",
-        # time.localtime(user_info["join_time"])),
-        #         "%Y-%m-%d %H:%M:%S",
-        #     )
-        #     await GroupInfoUser.update_or_create(
-        #         user_id=str(user_id),
-        #         group_id=group_id,
-        #         defaults={
-        #             "user_name": nickname,
-        #             "user_join_time": join_time.replace(
-        #                 tzinfo=timezone(timedelta(hours=8))
-        #             ),
-        #         },
-        #     )
-        #     exist_member_list.append(str(user_id))
-        #     logger.debug("更新成功", "更新群组成员信息",
-        # session=user_id, group_id=group_id)
-        # if delete_member_list := list(
-        #     set(exist_member_list).difference(
-        #         set(await GroupInfoUser.get_group_member_id_list(group_id))
-        #     )
-        # ):
-        #     await GroupInfoUser.filter(
-        #         user_id__in=delete_member_list, group_id=group_id
-        #     ).delete()
-        #     logger.info(f"删除已退群用户", "更新群组成员信息", group_id=group_id)
+    async def update_group_member(cls, bot: Bot, group_id: str) -> str:
+        """更新群组成员信息
+
+        参数:
+            bot: Bot
+            group_id: 群组id
+
+        返回:
+            str: 返回消息
+        """
+        if not group_id:
+            logger.warning(f"bot: {bot.self_id}，group_id为空，无法更新群成员信息...")
+            return "群组id为空..."
+        if interface := get_interface(bot):
+            scenes = await interface.get_scenes()
+            platform = PlatformUtils.get_platform(bot)
+            group_list = [s for s in scenes if s.is_group and s.id == group_id]
+            if not group_list:
+                logger.warning(
+                    f"bot: {bot.self_id}，group_id: {group_id}，群组不存在，"
+                    "无法更新群成员信息..."
+                )
+                return "更新群组失败，群组不存在..."
+            members = await interface.get_members(SceneType.GROUP, group_list[0].id)
+            db_user = await GroupInfoUser.filter(group_id=group_id).all()
+            db_user_uid = [u.user_id for u in db_user]
+            data_list = ([], [], [])
+            exist_member_list = []
+            for member in members:
+                logger.debug(f"即将更新群组成员: {member}", "更新群组成员信息")
+                await cls.__handle_user(member, db_user, group_id, data_list, platform)
+                exist_member_list.append(member.id)
+            if data_list[0]:
+                await GroupInfoUser.bulk_create(data_list[0], 30)
+                logger.debug(
+                    f"创建用户数据 {len(data_list[0])} 条",
+                    "更新群组成员信息",
+                    target=group_id,
+                )
+            if data_list[1]:
+                await GroupInfoUser.bulk_update(data_list[1], ["user_name"], 30)
+                logger.debug(
+                    f"更新户数据 {len(data_list[1])} 条",
+                    "更新群组成员信息",
+                    target=group_id,
+                )
+            if data_list[2]:
+                await GroupInfoUser.filter(id__in=data_list[2]).delete()
+                logger.debug(f"删除重复数据 Ids: {data_list[2]}", "更新群组成员信息")
+
+            if delete_member_list := [
+                uid for uid in db_user_uid if uid not in exist_member_list
+            ]:
+                await GroupInfoUser.filter(
+                    user_id__in=delete_member_list, group_id=group_id
+                ).delete()
+                logger.info(
+                    f"删除已退群用户 {len(delete_member_list)} 条",
+                    "更新群组成员信息",
+                    group_id=group_id,
+                    platform="qq",
+                )
+        return "群组成员信息更新完成!"
@@ -133,7 +133,7 @@ async def build_task(group_id: str | None) -> BuildImage:
                    task.id,
                    task.module,
                    task.name,
-                    "开启" if task.module not in group.block_task else "关闭",
+                    "开启" if f"<{task.module}," not in group.block_task else "关闭",
                    "开启" if task.status else "关闭",
                    task.run_time or "-",
                ]
@@ -211,12 +211,10 @@ class PluginManage:
                if status:
                    for module in module_list:
                        group.block_plugin = group.block_plugin.replace(
-                            f"{module},", ""
+                            f"<{module},", ""
                        )
                else:
-                    module_list = await PluginInfo.filter(
-                        plugin_type=PluginType.NORMAL
-                    ).values_list("module", flat=True)
+                    module_list = [f"<{module}" for module in module_list]
                    group.block_plugin = ",".join(module_list) + ","  # type: ignore
                await group.save(update_fields=["block_plugin"])
                return f'成功将此群组所有功能状态修改为: {"开启" if status else "关闭"}'
@@ -413,7 +411,7 @@ class PluginManage:
        参数:
            task_name: 被动技能名称
            group_id: 群组Id
-            status: 状态
+            status: 状态，为True时是关闭
            is_all: 所有群被动

        返回:
@@ -426,6 +424,7 @@ class PluginManage:
                group, _ = await GroupConsole.get_or_create(
                    group_id=group_id, channel_id__isnull=True
                )
+                modules = [f"<{module}" for module in modules]
                if status:
                    group.block_task = ",".join(modules) + ","  # type: ignore
                else:
@@ -434,16 +433,12 @@ class PluginManage:
                await group.save(update_fields=["block_task"])
                return f"已成功{status_str}全部被动技能!"
        elif task := await TaskInfo.get_or_none(name=task_name):
-            group, _ = await GroupConsole.get_or_create(
-                group_id=group_id, channel_id__isnull=True
-            )
            if status:
-                group.block_task += f"{task.module},"
-            elif f"super:{task.module}," in group.block_task:
+                await GroupConsole.set_block_task(group_id, task.module)
+            elif await GroupConsole.is_superuser_block_task(group_id, task.module):
                return f"{status_str} {task_name} 被动技能失败，当前群组该被动已被管理员禁用"  # noqa: E501
            else:
-                group.block_task = group.block_task.replace(f"{task.module},", "")
-            await group.save(update_fields=["block_task"])
+                await GroupConsole.set_unblock_task(group_id, task.module)
            return f"已成功{status_str} {task_name} 被动技能!"
        return "没有找到这个被动技能喔..."

@@ -469,20 +464,13 @@ class PluginManage:
                name=plugin_name, load_status=True, plugin_type__not=PluginType.PARENT
            )
        if plugin:
-            group, _ = await GroupConsole.get_or_create(
-                group_id=group_id, channel_id__isnull=True
-            )
            status_str = "开启" if status else "关闭"
            if status:
-                if plugin.module in group.block_plugin:
-                    group.block_plugin = group.block_plugin.replace(
-                        f"{plugin.module},", ""
-                    )
-                    await group.save(update_fields=["block_plugin"])
+                if await GroupConsole.is_normal_block_plugin(group_id, plugin.module):
+                    await GroupConsole.set_unblock_plugin(group_id, plugin.module)
                    return f"已成功{status_str} {plugin.name} 功能!"
-            elif plugin.module not in group.block_plugin:
-                group.block_plugin += f"{plugin.module},"
-                await group.save(update_fields=["block_plugin"])
+            elif not await GroupConsole.is_normal_block_plugin(group_id, plugin.module):
+                await GroupConsole.set_block_plugin(group_id, plugin.module)
                return f"已成功{status_str} {plugin.name} 功能!"
            return f"该功能已经{status_str}了喔，不要重复{status_str}..."
        return "没有找到这个功能喔..."
@@ -504,14 +492,10 @@ class PluginManage:
        if not (task := await TaskInfo.get_or_none(name=task_name)):
            return "没有找到这个功能喔..."
        if group_id:
-            group, _ = await GroupConsole.get_or_create(
-                group_id=group_id, channel_id__isnull=True
-            )
            if status:
-                group.block_task = group.block_task.replace(f"super:{task.module},", "")
+                await GroupConsole.set_unblock_task(group_id, task.module, True)
            else:
-                group.block_task += f"super:{task.module},"
-            await group.save(update_fields=["block_task"])
+                await GroupConsole.set_block_task(group_id, task.module, True)
            status_str = "开启" if status else "关闭"
            return f"已成功将群组 {group_id} 被动技能 {task_name} {status_str}!"
        return "没有找到这个群组喔..."
@@ -538,17 +522,12 @@ class PluginManage:
            )
        if plugin:
            if group_id:
-                if group := await GroupConsole.get_or_none(
-                    group_id=group_id, channel_id__isnull=True
+                if not await GroupConsole.is_superuser_block_plugin(
+                    group_id, plugin.module
                ):
-                    if f"super:{plugin.module}," not in group.block_plugin:
-                        group.block_plugin += f"super:{plugin.module},"
-                        await group.save(update_fields=["block_plugin"])
-                        return (
-                            f"已成功关闭群组 {group.group_name} 的 {plugin_name} 功能!"
-                        )
-                    return "此群组该功能已被超级用户关闭，不要重复关闭..."
-                return "群组信息未更新，请先更新群组信息..."
+                    await GroupConsole.set_block_plugin(group_id, plugin.module, True)
+                    return f"已成功关闭群组 {group_id} 的 {plugin_name} 功能!"
+                return "此群组该功能已被超级用户关闭，不要重复关闭..."
            plugin.block_type = block_type
            plugin.status = not bool(block_type)
            await plugin.save(update_fields=["status", "block_type"])
@@ -584,19 +563,12 @@ class PluginManage:
            )
        if plugin:
            if group_id:
-                if group := await GroupConsole.get_or_none(
-                    group_id=group_id, channel_id__isnull=True
+                if await GroupConsole.is_superuser_block_plugin(
+                    group_id, plugin.module
                ):
-                    if f"super:{plugin.module}," in group.block_plugin:
-                        group.block_plugin = group.block_plugin.replace(
-                            f"super:{plugin.module},", ""
-                        )
-                        await group.save(update_fields=["block_plugin"])
-                        return (
-                            f"已成功开启群组 {group.group_name} 的 {plugin_name} 功能!"
-                        )
-                    return "此群组该功能已被超级用户开启，不要重复开启..."
-                return "群组信息未更新，请先更新群组信息..."
+                    await GroupConsole.set_unblock_plugin(group_id, plugin.module, True)
+                    return f"已成功开启群组 {group_id} 的 {plugin_name} 功能!"
+                return "此群组该功能已被超级用户开启，不要重复开启..."
            plugin.block_type = block_type
            plugin.status = not bool(block_type)
            await plugin.save(update_fields=["status", "block_type"])