main.py

import json
import re
from dataclasses import dataclass, field
from datetime import datetime, timezone, timedelta
from typing import Dict, List, Optional, Set, Tuple
from astrbot.api.star import Context, Star, register
from astrbot.api.event import filter, AstrMessageEvent
from astrbot.api import logger
from pathlib import Path
DATA_DIR = Path(__file__).resolve().parent / "data" / "plugin_data" / "astrbot-plugin-queue"
DATA_FILE = DATA_DIR / "queue.json"


CST = timezone(timedelta(hours=8))
TIME_FMT = "%H:%M"
DATE_TIME_FMT = "%d号%H:%M"


@dataclass
class QueueMember:
    user_id: str
    display_name: str
    joined_at: str
#队列成员类

@dataclass
class QueueState:
    name: str
    aliases: Set[str] = field(default_factory=set)
    members: List[QueueMember] = field(default_factory=list)
    last_updated: str = ""
    last_reset: str = ""
    last_editor: str = ""
#数据类

class QueueStore:
    def __init__(self):
        self.queues: Dict[str, Dict[str, QueueState]] = {}
        self.alias_map: Dict[str, Dict[str, str]] = {}
        self.clear_times: Dict[str, str] = {}
        self._reset_dates: Dict[str, str] = {}

    @staticmethod
    def _canon(name: str) -> str:
        return name.strip()

    @staticmethod
    def _now_hm() -> str:
        return datetime.now(CST).strftime(TIME_FMT)

    @staticmethod
    def _now_dm_hm() -> str:
        return datetime.now(CST).strftime(DATE_TIME_FMT)

    def _ensure_group(self, gid: str) -> None:
        self.queues.setdefault(gid, {})
        self.alias_map.setdefault(gid, {})
        self.clear_times.setdefault(gid, "00:00")
        self._reset_dates.setdefault(gid, "")

    def _resolve(self, gid: str, key: str) -> Optional[QueueState]:
        key = self._canon(key)
        q = self.queues.get(gid, {}).get(key)
        if q:
            return q
        real = self.alias_map.get(gid, {}).get(key)
        return self.queues.get(gid, {}).get(real) if real else None

    def _user_in_queue(self, q: QueueState, user_id: str) -> bool:
        return any(m.user_id == user_id for m in q.members)

    def _user_position(self, q: QueueState, user_id: str) -> int:
        for i, m in enumerate(q.members, 1):
            if m.user_id == user_id:
                return i
        return 0

    def _touch(self, q: QueueState, editor_name: str) -> None:
        q.last_updated = self._now_hm()
        q.last_editor = editor_name

    def split_modify(self, gid: str, msg: str) -> Optional[Tuple[str, str]]:
        self._ensure_group(gid)
        msg = msg.strip()
    
        candidates = set(self.queues.get(gid, {}).keys()) | set(self.alias_map.get(gid, {}).keys())
        candidates = sorted(candidates, key=len, reverse=True)
    
        for name in candidates:
            if msg == name:
                return None
    
            if not msg.startswith(name):
                continue
    
            tail = msg[len(name):].strip()
            if not tail:
                return None
    
            if re.fullmatch(r"[=+-]\d+", tail):
                expr = tail
            elif re.fullmatch(r"\d+", tail):
                expr = "=" + tail
            else:
                return None

            real_key = self.alias_map.get(gid, {}).get(name, name)
            return real_key, expr
        return None
    def to_dict(self) -> dict:
        groups = {}
        for gid, qmap in self.queues.items():
            groups[gid] = {
                "queues": {
                    name: {
                        "aliases": list(q.aliases),
                        "members": [
                            {
                                "user_id": m.user_id,
                                "display_name": m.display_name,
                                "joined_at": m.joined_at,
                            }
                            for m in q.members
                        ],
                        "last_updated": q.last_updated,
                        "last_reset": q.last_reset,
                        "last_editor": q.last_editor,
                    }
                    for name, q in qmap.items()
                },
                "alias_map": dict(self.alias_map.get(gid, {})),
                "clear_time": self.clear_times.get(gid, "00:00"),
                "last_reset_date": self._reset_dates.get(gid, ""),
            }
        return {"groups": groups}

    def from_dict(self, data: dict) -> None:
        self.queues.clear()
        self.alias_map.clear()
        self.clear_times.clear()
        self._reset_dates.clear()

        for gid, g_data in data.get("groups", {}).items():
            self._ensure_group(gid)
            self.clear_times[gid] = g_data.get("clear_time", "00:00")
            self._reset_dates[gid] = g_data.get("last_reset_date", "")

            for name, q_data in g_data.get("queues", {}).items():
                self.queues[gid][name] = QueueState(
                    name=name,
                    aliases=set(q_data.get("aliases", [])),
                    members=[QueueMember(**m) for m in q_data.get("members", [])],
                    last_updated=q_data.get("last_updated", ""),
                    last_reset=q_data.get("last_reset", ""),
                    last_editor=q_data.get("last_editor", ""),
                )

            self.alias_map[gid].update(g_data.get("alias_map", {}))

    def reset_group(self, gid: str) -> None:
        now_dm_hm = self._now_dm_hm()
        now_hm = self._now_hm()
        for q in self.queues.get(gid, {}).values():
            q.members.clear()
            q.last_reset = now_dm_hm
            q.last_updated = now_hm
            q.last_editor = "系统"

    def check_daily_reset(self, gid: str) -> None:
        self._ensure_group(gid)
        now = datetime.now(CST)
        current_hm = now.strftime(TIME_FMT)
        current_date = now.strftime("%Y-%m-%d")
        if current_hm >= self.clear_times[gid] and self._reset_dates[gid] != current_date:
            self.reset_group(gid)
            self._reset_dates[gid] = current_date
            logger.info(f"queue: 群 {gid} 已自动清空")
    #自动清空时间设置
    def create_queue(self, gid: str, name: str) -> str:
        self._ensure_group(gid)
        name = self._canon(name)
        if not name:
            return "用法: 创建队列 [队列名]"
        if name in self.queues[gid] or name in self.alias_map[gid]:
            return f"{name} 已存在"
        self.queues[gid][name] = QueueState(name=name, last_updated=self._now_hm(), last_editor="系统")
        return f"创建队列成功 {name}"
    #创建队列
    def delete_queue(self, gid: str, key: str) -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""
        for alias in list(q.aliases):
            self.alias_map[gid].pop(alias, None)
        self.queues[gid].pop(q.name, None)
        return f"删除队列成功 {q.name}"

    def add_alias(self, gid: str, queue_name: str, alias: str, editor_name: str = "系统") -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, queue_name)
        if not q:
            return ""
        alias = self._canon(alias)
        if not alias:
            return "别名不能为空"
        if alias in self.queues[gid] or alias in self.alias_map[gid]:
            return f"{alias} 已被占用"
        q.aliases.add(alias)
        self.alias_map[gid][alias] = q.name
        self._touch(q, editor_name)
        return f"给队列 {q.name} 添加别名 {alias} 成功"

    def set_clear_time(self, gid: str, value: str) -> str:
        self._ensure_group(gid)
        m = re.fullmatch(r"(\d{1,2})[:：](\d{1,2})", value.strip())
        if not m:
            return "时间格式不对，示例：08:00"
        hh, mm = int(m.group(1)), int(m.group(2))
        if not (0 <= hh <= 23 and 0 <= mm <= 59):
            return "时间格式不对，必须在 00:00~23:59"
        self.clear_times[gid] = f"{hh:02d}:{mm:02d}"
        return f"清空时间已修改为 {self.clear_times[gid]}"

    def query(self, gid: str, key: str) -> str:
        self.check_daily_reset(gid)
        q = self._resolve(gid, key)
        if not q:
            return f"{key} 不存在"

        if not q.members:
            if q.last_reset:
                return f"{q.name} 队列当前为空，上次清空时间（{q.last_reset}）"
            return f"{q.name} 现在有 0 人"

        road_count = sum(1 for m in q.members if m.user_id == "road")
        head = f"{q.name} 现在有 {len(q.members)} 人"
        if road_count:
            head += f"（{road_count} 名路人）"
        head += f"，由 {q.last_editor or '系统'} 最后更新于（{q.last_updated}）"

        lines = [head]
        for i, m in enumerate(q.members, 1):
            lines.append(f"{i}. {m.display_name}（{m.joined_at}）")
        return "\n".join(lines)

    def sign(self, gid: str, key: str, pos: int, user_id: str, name: str) -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""
        if pos < 1 or pos > len(q.members):
            return f"位置不对，当前队列共 {len(q.members)} 人"
        if self._user_in_queue(q, user_id):
            return f"你已在队列位置 {self._user_position(q, user_id)}，不能重复报名"
        if q.members[pos - 1].user_id != "road":
            return f"该卡已有人报名，请联系管理员修改"

        q.members[pos - 1] = QueueMember(user_id=user_id, display_name=name, joined_at=self._now_hm())
        q.last_updated = self._now_hm()
        q.last_editor = name
        return f"报名成功，你已替换位置 {pos} 的路人（{q.name}）"

    def modify(self, gid: str, key: str, expr: str, user_id: str, name: str, no_self: bool) -> str:
        self.check_daily_reset(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""

        expr = expr.replace("＝", "=")
        now = self._now_hm()

        m = re.fullmatch(r"([+-])(\d+)", expr)
        if m:
            delta = int(m.group(2)) * (1 if m.group(1) == "+" else -1)
            if delta == 0:
                return "人数变化不能为 0"

            if delta > 0:
                if no_self:
                    q.members.extend(QueueMember("road", "路人", now) for _ in range(delta))
                    msg = f"上传成功✅\n{q.name} 现在增加 {delta} 人 人数更新为 {len(q.members)} 人"
                else:
                    if self._user_in_queue(q, user_id):
                        q.members.extend(QueueMember("road", "路人", now) for _ in range(delta))
                        msg = f"上传成功✅\n{q.name} 现在增加 {delta} 人 人数更新为 {len(q.members)} 人"
                    else:
                        q.members.extend(QueueMember("road", "路人", now) for _ in range(max(0, delta - 1)))
                        q.members.append(QueueMember(user_id, name, now))
                        msg = (
                            "您已加入队列，若并非入队，请在命令后携带 -p 参数\n"
                            f"上传成功✅\n{q.name} 现在增加 {delta} 人 人数更新为 {len(q.members)} 人"
                        )
            else:
                remove_count = -delta
                removed_self = False

                if not no_self:
                    new_members = []
                    for member in q.members:
                        if not removed_self and member.user_id == user_id:
                            removed_self = True
                            remove_count -= 1
                            continue
                        new_members.append(member)
                    q.members = new_members

                if remove_count > 0:
                    new_members = []
                    for member in q.members:
                        if remove_count > 0 and member.user_id == "road":
                            remove_count -= 1
                            continue
                        new_members.append(member)
                    q.members = new_members

                if remove_count > 0:
                    q.members = q.members[: max(0, len(q.members) - remove_count)]

                if removed_self and -delta == 1:
                    msg = f"你已退出队列（{q.name}），若并非离队，请在命令后携带 -p 参数\n"
                else:
                    msg = f"上传成功✅\n{q.name} 现在减少 {-delta} 人 人数更新为 {len(q.members)} 人"

            q.last_updated = now
            q.last_editor = name
            return msg

        if expr.startswith("="):
            target = int(expr[1:])
            if target < 0:
                return "人数不能为负数"

            if no_self:
                if target > len(q.members):
                    q.members.extend(QueueMember("road", "路人", now) for _ in range(target - len(q.members)))
                else:
                    q.members = q.members[:target]
            else:
                q.members = [x for x in q.members if x.user_id != user_id]
                need = max(0, target - 1)
                if need > len(q.members):
                    q.members.extend(QueueMember("road", "路人", now) for _ in range(need - len(q.members)))
                else:
                    q.members = q.members[:need]
                if target > 0:
                    q.members.append(QueueMember(user_id, name, now))

            q.last_updated = now
            q.last_editor = name
            return f"上传成功✅\n{q.name} 人数更新为 {len(q.members)} 人"

        return "格式不对，请使用/排队帮助查询指令格式"

    def change_card(self, gid: str, key: str, pos: int, target: str, editor_name: str) -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""
        if pos < 1 or pos > len(q.members):
            return f"位置不对，当前队列共 {len(q.members)} 人"

        q.members[pos - 1] = QueueMember(user_id=target, display_name=target, joined_at=self._now_hm())
        q.last_updated = self._now_hm()
        q.last_editor = editor_name
        return f"改卡成功，位置 {pos} 已替换为 {target}（{q.name}）"

    def clear_card(self, gid: str, key: str, pos: int, editor_name: str = "系统") -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""
        if pos < 1 or pos > len(q.members):
            return f"位置不对，当前队列共 {len(q.members)} 人"

        q.members[pos - 1] = QueueMember(user_id="road", display_name="路人", joined_at=self._now_hm())
        q.last_updated = self._now_hm()
        q.last_editor = editor_name
        return f"擦卡成功，位置 {pos} 已替换为路人（{q.name}）"

    def kick_card(self, gid: str, key: str, pos: int, editor_name: str = "系统") -> str:
        self._ensure_group(gid)
        q = self._resolve(gid, key)
        if not q:
            return ""
        if pos < 1 or pos > len(q.members):
            return f"位置不对，当前队列共 {len(q.members)} 人"

        removed = q.members.pop(pos - 1)
        q.last_updated = self._now_hm()
        q.last_editor = editor_name
        return f"踢卡成功，已移除位置 {pos} 的 {removed.display_name}（{q.name}）"

    def leave(self, gid: str, user_id: str, name: str, key: Optional[str]) -> str:
        self.check_daily_reset(gid)
        if key:
            q = self._resolve(gid, key)
            if not q:
                return ""
            targets = [q]
        else:
            targets = list(self.queues.get(gid, {}).values())

        left = []
        for q in targets:
            if not q:
                continue
            before = len(q.members)
            q.members = [m for m in q.members if m.user_id != user_id]
            if len(q.members) != before:
                left.append(q.name)
                q.last_updated = self._now_hm()
                q.last_editor = name
        return "你没有在任何队列中" if not left else f"退出成功 队列: {', '.join(left)}"


store = QueueStore()


@register("astrbot-plugin-queue", "NeoBot", "用于管理排队系统的插件", "0.1.0", "")
class QueueManagerRewrite(Star):
    def __init__(self, context: Context):
        super().__init__(context)

    @staticmethod
    def _gid(event: AstrMessageEvent) -> str:
        return str(event.message_obj.group_id) if event.message_obj.group_id else "private"

    @staticmethod
    def _is_admin(event: AstrMessageEvent) -> bool:
        try:
            return event.get_permission_type() == filter.PermissionType.ADMIN
        except Exception:
            return False

    def _help_user(self) -> str:
        return (
            "排队基础指令\n"
            "/查队列 [队列名或别名]\n"
            "[队列名] j / 几 / 有几人 / 有谁 / 都谁\n"
            "用于查询队列的人数以及队列情况\n"
            "/报名 [队列名或别名] [位置]\n"
            "用于将队列中指定位置的路人替换为自己\n"
            "[队列名或别名][+N/-N/=N/N][-p(可选)]\n"
            "用于修改队列人数为增加N人/减少N人/总共N人\n"
            "携带-p参数代表自身不加入/退出队列\n"
            "不携带代表人数增加时自身加入队列，人数减少时自身退出队列\n"
            "退队/退勤 [队列名或别名(可选)]\n"
            "用于退出队列，若未指定所退出的队列则退出所有队列\n"
            ""
        )

    def _help_admin(self) -> str:
        return (
            "排队管理指令\n"
            "/创建队列 [队列名]\n"
            "用于创建一个队列\n"
            "/删除队列 [队列名或别名]\n"
            "用于删除队列\n"
            "/添加别名 [队列名] [别名]\n"
            "用于为队列添加别名\n"
            "/修改清空队列时间 [HH:mm]\n"
            "用于修改每日队列清空的时间，默认0:00，请使用小时:分钟格式\n"
            "/改卡 [队列名或别名] [位置] [群友qq号/名称]\n"
            "用于替换队列某处的成员为指定成员\n"
            "/擦卡 [队列名或别名] [位置]\n"
            "用于将队列某处的成员改为游客\n"
            "/踢卡 [队列名或别名] [位置]\n"
            "用于将队列某处的成员踢出队列\n"
        )

    def _usage_reply(self, usage: str) -> str:
        return f"参数格式错误\n{usage}\n\n发送 /排队帮助 查看完整帮助"

        
    async def on_loaded(self):

    
        try:

        
            if DATA_FILE.exists():

            
                raw = DATA_FILE.read_text(encoding="utf-8")

            
            if raw:

                store.from_dict(json.loads(raw))

                logger.info("queue: 数据已加载")

        
        except Exception as e:

            logger.error(f"queue: 加载队列数据失败: {e}")



    async def terminate(self):
        try:
            await self.put_kv_data("queue_data", json.dumps(store.to_dict(), ensure_ascii=False))
            logger.info("queue: 数据已保存")
        except Exception as e:
            logger.error(f"queue: 保存队列数据失败: {e}")

    async def _save(self):
        try:
            DATA_DIR.mkdir(parents=True, exist_ok=True)
            DATA_FILE.write_text(
                json.dumps(store.to_dict(), ensure_ascii=False, indent=2),
                encoding="utf-8",
            )
        except Exception as e:
            logger.error(f"queue: 保存失败: {e}")

    @filter.regex(r"^\s*(?:/)?排队帮助\s*$")
    async def help_cmd(self, event: AstrMessageEvent):
        text = self._help_user()
        if self._is_admin(event):
            text += "\n\n" + self._help_admin()
        yield event.plain_result(text)

    @filter.regex(r"^创建队列(?:\s+.*)?$")
    async def create_queue(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^创建队列\s+(\S+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 创建队列 [队列名]"))
            return
        res = store.create_queue(self._gid(event), m.group(1))
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^删除队列(?:\s+.*)?$")
    async def delete_queue(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^删除队列\s+(\S+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 删除队列 [队列名或别名]"))
            return
        res = store.delete_queue(self._gid(event), m.group(1))
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^添加别名(?:\s+.*)?$")
    async def add_alias(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^添加别名\s+(\S+)\s+(\S+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 添加别名 [队列名] [别名]"))
            return
        sender = str(event.get_sender_name() or event.get_sender_id() or "系统")
        res = store.add_alias(self._gid(event), m.group(1), m.group(2), sender)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^修改清空队列时间(?:\s+.*)?$")
    async def set_clear(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^修改清空队列时间\s+(\S+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 修改清空队列时间 [HH:mm]"))
            return
        res = store.set_clear_time(self._gid(event), m.group(1))
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^(?:查队列|队列)(?:\s+.*)?$")
    async def query(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^(?:查队列|队列)\s+(\S+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 查队列 [队列名或别名]"))
            return
        yield event.plain_result(store.query(self._gid(event), m.group(1)))

    @filter.regex(r"^报名(?:\s+.*)?$")
    async def sign(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^报名\s+(\S+)\s+(\d+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 报名 [队列名或别名] [位置]"))
            return
        sid = str(event.get_sender_id() or "")
        sname = str(event.get_sender_name() or sid)
        res = store.sign(self._gid(event), m.group(1), int(m.group(2)), sid, sname)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^(.+?)(?:j|几|有几人|有谁|都谁)$")
    async def short_query(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^(.+?)(?:j|几|有几人|有谁|都谁)$", msg)
        if not m:
            return
        key = m.group(1).strip()
        if not key:
            yield event.plain_result(self._usage_reply("用法: [队列名]j / 几 / 有几人 / 有谁 / 都谁"))
            return
        yield event.plain_result(store.query(self._gid(event), key))

    @filter.regex(r"^(.+?)(?:\s+-p)?$")
    async def modify(self, event: AstrMessageEvent):#修改队列相关
        msg = event.message_str.strip()

        no_self = False
        if msg.endswith(" -p"):
            msg = msg[:-3].strip()
            no_self = True

        parsed = store.split_modify(self._gid(event), msg)
        if not parsed:
            return

        key, expr = parsed
        sid = str(event.get_sender_id() or "")
        sname = str(event.get_sender_name() or sid)

        res = store.modify(self._gid(event), key, expr, sid, sname, no_self)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.permission_type(filter.PermissionType.ADMIN)
    @filter.regex(r"^改卡(?:\s+.*)?$")
    async def change_card(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^改卡\s+(.+?)\s+(\d+)\s+(.+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 改卡 [队列名或别名] [位置] [群友qq号/名称]"))
            return
        sender = str(event.get_sender_name() or event.get_sender_id() or "系统")
        res = store.change_card(self._gid(event), m.group(1), int(m.group(2)), m.group(3), sender)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.permission_type(filter.PermissionType.ADMIN)
    @filter.regex(r"^擦卡(?:\s+.*)?$")
    async def clear_card(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^擦卡\s+(.+?)\s+(\d+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 擦卡 [队列名或别名] [位置]"))
            return
        sender = str(event.get_sender_name() or event.get_sender_id() or "系统")
        res = store.clear_card(self._gid(event), m.group(1), int(m.group(2)), sender)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.permission_type(filter.PermissionType.ADMIN)
    @filter.regex(r"^踢卡(?:\s+.*)?$")
    async def kick_card(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^踢卡\s+(.+?)\s+(\d+)$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 踢卡 [队列名或别名] [位置]"))
            return
        sender = str(event.get_sender_name() or event.get_sender_id() or "系统")
        res = store.kick_card(self._gid(event), m.group(1), int(m.group(2)), sender)
        if res:
            yield event.plain_result(res)
            await self._save()

    @filter.regex(r"^退(?:队|勤)(?:\s+.*)?$")
    async def leave(self, event: AstrMessageEvent):
        msg = event.message_str.strip()
        m = re.fullmatch(r"^退(?:队|勤)(?:\s+(\S+))?$", msg)
        if not m:
            yield event.plain_result(self._usage_reply("用法: 退队 或 退勤 [队列名或别名]"))
            return
        sid = str(event.get_sender_id() or "")
        sname = str(event.get_sender_name() or sid)
        res = store.leave(self._gid(event), sid, sname, m.group(1))
        if res and "你没有在任何队列中" not in res:
            yield event.plain_result(res)
            await self._save()