nonebot-plugin-lazy 0.1.0__py3-none-any.whl

nonebot_plugin_lazy/__init__.py

@@ -0,0 +1,53 @@
+"""nonebot_plugin_lazy — Nonebot2 插件入口。
+
+启动时自动加载 APScheduler，可选注册 .env 账号，然后启动定时轮询。
+
+消息处理器在 handler.py 中通过 import 副效应注册到 Nonebot2。"""
+
+from nonebot.plugin import require
+from nonebot import get_driver
+from nonebot.log import logger
+
+require("nonebot_plugin_apscheduler")
+from nonebot_plugin_apscheduler import scheduler
+
+from .config import config
+from .state import user_mgr
+from .auth import TokenManager
+from .monitor import Poller
+
+from . import handler  # noqa: F401 — 注册消息处理器
+
+driver = get_driver()
+
+poller = Poller()
+
+
+@driver.on_startup
+async def startup():
+    if config.studentid and config.password:
+        tm = TokenManager(
+            config.server_url, config.studentid, config.password,
+        )
+        try:
+            token = await tm.login()
+            qq_id = config.owner_qq if config.owner_qq > 0 else -1
+            user_mgr.add_user(
+                qq_id,
+                config.studentid,
+                config.password,
+                token,
+                config.server_url,
+            )
+            logger.success(
+                f".env 账号 {config.studentid} 自动注册成功"
+            )
+        except Exception as e:
+            logger.error(f".env 账号注册失败: {e}")
+
+    scheduler.add_job(
+        poller.run,
+        "interval",
+        seconds=config.poll_interval,
+        id="lazy_poll",
+    )

nonebot_plugin_lazy/auth.py

@@ -0,0 +1,64 @@
+"""Token 管理。
+
+TokenManager 为纯工具类，每次使用时独立实例化以避免多会话冲突。
+不再保留模块级单例。
+
+认证流程：
+1. POST /api/auth/login → 返回 UUID token
+2. 404 → 用户未注册，自动调 POST /api/auth/register
+3. 401 → 密码错误
+"""
+
+import httpx
+from nonebot.log import logger
+
+
+class TokenManager:
+    """管理单个用户的 LAZY SERVER token。"""
+
+    def __init__(self, server_url: str, studentid: str, password: str):
+        self.server_url = server_url
+        self.studentid = studentid
+        self.password = password
+        self.token: str | None = None
+
+    async def login(self) -> str:
+        """登录获取 token，如未注册则自动注册。返回 token 字符串。"""
+        async with httpx.AsyncClient() as client:
+            resp = await client.post(
+                f"{self.server_url}/api/auth/login",
+                json={"studentid": self.studentid, "password": self.password},
+                timeout=10,
+            )
+            if resp.status_code == 404:
+                logger.info("用户未注册，尝试自动注册")
+                resp = await client.post(
+                    f"{self.server_url}/api/auth/register",
+                    json={"studentid": self.studentid, "password": self.password},
+                    timeout=10,
+                )
+            if resp.status_code == 401:
+                raise RuntimeError("学号或密码错误")
+            if resp.status_code != 200:
+                raise RuntimeError(
+                    f"认证失败 (HTTP {resp.status_code}): {resp.text}"
+                )
+            data = resp.json()
+            self.token = data["token"]
+            return self.token
+
+    async def ensure_token(self) -> str:
+        """确保 token 可用，如为 None 则自动登录。"""
+        if self.token is None:
+            await self.login()
+        return self.token
+
+    async def handle_401(self):
+        """处理 token 过期：置空后重新登录。"""
+        logger.warning("Token 失效，尝试重新登录")
+        self.token = None
+        try:
+            await self.login()
+        except Exception as e:
+            logger.error(f"重新登录失败: {e}")
+            raise

nonebot_plugin_lazy/config.py

@@ -0,0 +1,33 @@
+"""LAZY 监控插件配置模型。
+
+通过 Nonebot2 的 get_plugin_config 自动绑定 .env 中
+LAZY_MONITOR__* 前缀的环境变量到 Pydantic 模型。
+"""
+
+from pydantic import BaseModel
+from nonebot import get_plugin_config
+
+
+class LazyMonitorConfig(BaseModel):
+    """插件核心配置，所有字段均可通过 .env 覆盖。"""
+
+    server_url: str = "http://127.0.0.1:8765"
+    studentid: str = ""
+    password: str = ""
+    owner_qq: int = 0
+    poll_interval: int = 30
+    notify_groups: list[int] = []
+    notify_users: list[int] = []
+    enable_rollcall: bool = True
+    enable_todo: bool = True
+    max_retries: int = 3
+    retry_delay: int = 5
+
+
+class Config(BaseModel):
+    """Nonebot2 需要顶层模型来解析嵌套的 LAZY_MONITOR__* 配置。"""
+
+    lazy_monitor: LazyMonitorConfig
+
+
+config = get_plugin_config(Config).lazy_monitor

nonebot_plugin_lazy/handler.py

@@ -0,0 +1,234 @@
+"""用户交互命令处理器。
+
+包含两大功能：
+1. `/register` — 私聊四步骤注册 / 群聊拒绝引导
+2. `/task` — 任务管理（list / enable / disable / interval / reset）
+
+所有命令使用 Nonebot2 标准 Matcher.got() 实现多步骤对话。"""
+
+import httpx
+from nonebot import on_command
+from nonebot.rule import is_type, to_me
+from nonebot.adapters.onebot.v11 import (
+    Bot,
+    MessageEvent,
+    PrivateMessageEvent,
+    GroupMessageEvent,
+    MessageSegment,
+    Message,
+)
+from nonebot.params import ArgPlainText, CommandArg
+from nonebot.log import logger
+
+from .config import config
+from .state import user_mgr
+from .auth import TokenManager
+
+
+# ── 注册 ──────────────────────────────────────────
+
+register = on_command(
+    "register",
+    rule=to_me() & is_type(PrivateMessageEvent),
+)
+
+@register.handle()
+async def _(event: PrivateMessageEvent):
+    if user_mgr.get_user(event.user_id):
+        await register.finish(
+            "您已经注册过了。如需重新注册，请联系管理员。"
+        )
+
+@register.got(
+    "confirm",
+    prompt=(
+        "⚠️ 安全提示：\n"
+        "您的学号和密码将存储在服务器上，"
+        "Bot管理员可以查看这些信息。\n\n"
+        "是否继续注册？（回复 是/否）"
+    ),
+)
+async def _(event: PrivateMessageEvent, confirm: str = ArgPlainText()):
+    if confirm.strip() not in ("是", "y", "yes", "Y", "Yes"):
+        await register.finish(
+            "注册已取消。如需重新注册，请再次发送 /register。"
+        )
+
+@register.got("studentid", prompt="请输入您的学号：")
+async def _(studentid: str = ArgPlainText()):
+    if not studentid.strip().isdigit():
+        await register.reject("学号格式不正确，请输入纯数字学号：")
+
+@register.got(
+    "password",
+    prompt="请输入密码（密码仅用于验证，验证后加密存储）：",
+)
+async def _(
+    event: PrivateMessageEvent,
+    studentid: str = ArgPlainText("studentid"),
+    password: str = ArgPlainText(),
+):
+    """最终步骤：验证凭据 → 存入 UserManager → 完成注册。"""
+    sid = studentid.strip()
+    pwd = password.strip()
+    tm = TokenManager(config.server_url, sid, pwd)
+    try:
+        token = await tm.login()
+    except RuntimeError as e:
+        await register.reject(
+            f"验证失败：{e}\n请检查后重新输入密码"
+            "（或发送 取消 中止）："
+        )
+    except Exception as e:
+        logger.error(f"注册验证异常: {e}")
+        await register.reject("验证失败：服务器异常，请稍后重试。")
+        return
+
+    user_mgr.add_user(
+        event.user_id, sid, pwd, token, config.server_url,
+    )
+    await register.finish(
+        f"✅ 注册成功！\n"
+        f"学号：{sid}\n"
+        f"您将会收到点名和待办的通知。"
+    )
+
+
+register_group = on_command(
+    "register",
+    rule=is_type(GroupMessageEvent),
+)
+
+@register_group.handle()
+async def _(bot: Bot, event: GroupMessageEvent):
+    """群聊中发送 /register 时 @ 用户并引导至私聊。"""
+    await bot.send(
+        event=event,
+        message=(
+            MessageSegment.at(event.user_id)
+            + " 请在私聊中使用 /register 进行注册"
+        ),
+    )
+
+
+# ── 任务管理 ───────────────────────────────────────
+
+task = on_command("task", rule=to_me())
+
+@task.handle()
+async def _(event: MessageEvent, args: Message = CommandArg()):
+    """解析 /task 子命令并分发到对应处理函数。"""
+    user = user_mgr.get_user(event.user_id)
+    if not user:
+        await task.finish(
+            "您还没有注册。请在私聊中使用 /register 注册。"
+        )
+
+    text = args.extract_plain_text().strip().split()
+    cmd = text[0] if text else "list"
+
+    if cmd == "list":
+        await _task_list(user)
+    elif cmd in ("enable", "disable") and len(text) >= 2:
+        enabled = cmd == "enable"
+        await _task_update(user, text[1], {"enabled": enabled})
+    elif cmd == "interval" and len(text) >= 3:
+        try:
+            interval = int(text[2])
+        except ValueError:
+            await task.finish("间隔必须为数字（秒）。")
+            return
+        await _task_update(user, text[1], {"interval": interval})
+    elif cmd == "reset" and len(text) >= 2:
+        await _task_reset(user, text[1])
+    else:
+        await task.finish(
+            "可用命令：\n"
+            "/task list                     列出所有任务\n"
+            "/task enable <task_id>         启用任务\n"
+            "/task disable <task_id>        停用任务\n"
+            "/task interval <task_id> <秒>  修改轮询间隔\n"
+            "/task reset <task_id>          恢复默认"
+        )
+
+
+async def _task_list(user):
+    """发送 GET /api/tasks 并格式化输出。"""
+    async with httpx.AsyncClient() as client:
+        try:
+            resp = await client.get(
+                f"{config.server_url}/api/tasks",
+                params={"token": user.token},
+                timeout=10,
+            )
+            resp.raise_for_status()
+            data = resp.json()
+        except Exception as e:
+            logger.error(f"获取任务列表失败: {e}")
+            await task.finish(f"获取任务列表失败：{e}")
+            return
+
+    tasks = data.get("tasks", [])
+    if not tasks:
+        await task.finish("暂无可用任务。")
+        return
+
+    lines = ["📋 任务列表"]
+    for t in tasks:
+        status = "✅" if t.get("enabled") else "⏹"
+        override = " (已覆写)" if t.get("has_override") else ""
+        lines.append(
+            f"{status} {t['task_id']} — {t.get('description', '')}"
+        )
+        lines.append(
+            f"   间隔: {t.get('interval')}s"
+            f" | 状态: {t.get('cache_status')}{override}"
+        )
+    await task.finish("\n".join(lines))
+
+
+async def _task_update(user, task_id: str, body: dict):
+    """发送 PUT /api/tasks/{id} 修改任务配置。"""
+    async with httpx.AsyncClient() as client:
+        try:
+            resp = await client.put(
+                f"{config.server_url}/api/tasks/{task_id}",
+                params={"token": user.token},
+                json=body,
+                timeout=10,
+            )
+            if resp.status_code == 401:
+                await task.finish(
+                    "Token 已失效，请在私聊中重新注册。"
+                )
+                return
+            if resp.status_code == 404:
+                await task.finish(f"任务 {task_id} 不存在。")
+                return
+            resp.raise_for_status()
+            await task.finish(f"✅ 任务 {task_id} 已更新。")
+        except Exception as e:
+            logger.error(f"更新任务失败: {e}")
+            await task.finish(f"更新任务失败：{e}")
+
+
+async def _task_reset(user, task_id: str):
+    """发送 DELETE /api/tasks/{id} 重置为系统默认。"""
+    async with httpx.AsyncClient() as client:
+        try:
+            resp = await client.delete(
+                f"{config.server_url}/api/tasks/{task_id}",
+                params={"token": user.token},
+                timeout=10,
+            )
+            if resp.status_code == 401:
+                await task.finish(
+                    "Token 已失效，请在私聊中重新注册。"
+                )
+                return
+            resp.raise_for_status()
+            msg = resp.json().get("message", "已重置")
+            await task.finish(f"✅ 任务 {task_id} {msg}。")
+        except Exception as e:
+            logger.error(f"重置任务失败: {e}")
+            await task.finish(f"重置任务失败：{e}")

nonebot_plugin_lazy/monitor.py

@@ -0,0 +1,155 @@
+"""轮询引擎 — 多用户差异检测。
+
+Poller 遍历 UserManager 中所有注册用户，每人独立：
+1. 确保 Token 有效
+2. 拉取点名/待办数据
+3. 与 seen_ids 做 diff，发现新项后触发通知
+4. 更新 seen_ids
+
+首次启动时所有 seen_ids 为空，自动跳过第一轮通知。
+"""
+
+import httpx
+from nonebot.log import logger
+
+from .config import config
+from .state import user_mgr, UserSession
+from .auth import TokenManager
+from .notifier import notifier
+
+
+def _extract_items(data, key: str) -> list[dict]:
+    """从 LAZY SERVER 响应中提取数据项列表。
+
+    兼容多种返回格式：list 直接返回，dict 尝试预设 key 列表，
+    保证与 LAZY server 侧 _extract_items 逻辑一致。
+    """
+    if isinstance(data, list):
+        return data
+    if isinstance(data, dict):
+        for k in (
+            key, "rollcalls", "todos", "items",
+            "data", "list", "uploads", "activities",
+        ):
+            if k in data and isinstance(data[k], list):
+                return data[k]
+        for v in data.values():
+            if isinstance(v, list):
+                return v
+    return []
+
+
+class Poller:
+    """定时轮询调度器，处理所有注册用户的数据拉取和通知触发。"""
+
+    async def run(self):
+        """一次完整的轮询：遍历所有用户。"""
+        for user in list(user_mgr.all_users()):
+            try:
+                await self._poll_user(user)
+            except Exception as e:
+                logger.error(
+                    f"轮询用户 {user.studentid} 时发生未预期错误: {e}"
+                )
+
+    async def _poll_user(self, user: UserSession):
+        """处理单个用户的轮询（Token 管理 → 数据拉取 → diff 通知）。"""
+        tm = TokenManager(user.server_url, user.studentid, user.password)
+        tm.token = user.token
+
+        try:
+            await tm.ensure_token()
+        except Exception as e:
+            user.consecutive_failures += 1
+            logger.error(
+                f"用户 {user.studentid} Token 失败"
+                f" ({user.consecutive_failures}/5): {e}"
+            )
+            if user.consecutive_failures >= 5:
+                await notifier.alert_superusers(
+                    f"用户 {user.studentid} 连续 5 次轮询失败"
+                )
+            return
+
+        user.consecutive_failures = 0
+        user.token = tm.token
+
+        async with httpx.AsyncClient() as client:
+            if config.enable_rollcall:
+                await self._poll_rollcall(client, user, tm)
+            if config.enable_todo:
+                await self._poll_todo(client, user, tm)
+
+    async def _fetch_data(
+        self, client: httpx.AsyncClient,
+        tm: TokenManager, task_id: str,
+    ) -> dict | None:
+        """拉取单任务数据，自动处理 401 重新认证。"""
+        url = f"{config.server_url}/api/data/{task_id}"
+        try:
+            resp = await client.get(
+                url, params={"token": tm.token}, timeout=10,
+            )
+            if resp.status_code == 401:
+                logger.warning("Token 失效 (401)，尝试重新登录")
+                await tm.handle_401()
+                resp = await client.get(
+                    url, params={"token": tm.token}, timeout=10,
+                )
+            resp.raise_for_status()
+            return resp.json()
+        except Exception as e:
+            logger.error(f"拉取 {task_id} 数据失败: {e}")
+            return None
+
+    async def _poll_rollcall(
+        self, client: httpx.AsyncClient,
+        user: UserSession, tm: TokenManager,
+    ):
+        body = await self._fetch_data(client, tm, "rollcall_watch")
+        if body is None:
+            return
+        if body.get("status") != "ok" or body.get("data") is None:
+            return
+
+        items = _extract_items(body["data"], "rollcalls")
+        if not items:
+            return
+
+        new_items = [
+            item for item in items
+            if item.get("rollcall_id")
+            not in user.state.seen_rollcall_ids
+        ]
+        if new_items:
+            await notifier.notify_rollcalls(new_items, user.qq_id)
+
+        user.state.seen_rollcall_ids.update(
+            item["rollcall_id"]
+            for item in items if "rollcall_id" in item
+        )
+
+    async def _poll_todo(
+        self, client: httpx.AsyncClient,
+        user: UserSession, tm: TokenManager,
+    ):
+        body = await self._fetch_data(client, tm, "todo_watch")
+        if body is None:
+            return
+        if body.get("status") != "ok" or body.get("data") is None:
+            return
+
+        items = _extract_items(body["data"], "todos")
+        if not items:
+            return
+
+        new_items = [
+            item for item in items
+            if item.get("id") not in user.state.seen_todo_ids
+        ]
+        if new_items:
+            await notifier.notify_todos(new_items, user.qq_id)
+
+        user.state.seen_todo_ids.update(
+            item["id"] for item in items if "id" in item
+        )

nonebot_plugin_lazy/notifier.py

@@ -0,0 +1,131 @@
+"""通知格式化与消息发送。
+
+支持两种通道：
+- 群通知：@ 特定用户（数据触发者或 owner_qq）
+- 私聊通知：直接发送给数据触发者
+
+发送异常不会阻塞后续通知。"""
+
+from nonebot import get_bot
+from nonebot.adapters.onebot.v11 import MessageSegment, Message
+from nonebot.log import logger
+
+from .config import config
+
+
+class Notifier:
+    """格式化点名/待办消息并通过 OneBot API 发送。"""
+
+    @staticmethod
+    def _format_rollcall(item: dict) -> str:
+        rollcall_type = "雷达点名" if item.get("is_radar") else "数字点名"
+        return (
+            f"🔔 新点名通知\n"
+            f"————————\n"
+            f"课程：{item.get('course_title', '未知')}\n"
+            f"发起人：{item.get('created_by_name', '未知')}\n"
+            f"类型：{rollcall_type}"
+        )
+
+    @staticmethod
+    def _format_todo(item: dict) -> str:
+        return (
+            f"📋 新待办通知\n"
+            f"————————\n"
+            f"标题：{item.get('title', '未知')}\n"
+            f"课程：{item.get('course_name', '未知')}\n"
+            f"截止时间：{item.get('end_time', '未知')}"
+        )
+
+    def _resolve_at_qq(self, qq_id: int) -> int:
+        """确定群通知中 @ 的 QQ 号。DM 注册用户 @ 自己，.env 账号 @ owner_qq。"""
+        if qq_id > 0:
+            return qq_id
+        if config.owner_qq > 0:
+            return config.owner_qq
+        return -1
+
+    async def notify_rollcalls(self, items: list[dict], qq_id: int):
+        """批量发送点名通知。"""
+        try:
+            bot = get_bot()
+        except ValueError:
+            logger.error("没有可用的 Bot 实例")
+            return
+
+        at_qq = self._resolve_at_qq(qq_id)
+
+        for item in items:
+            msg = self._format_rollcall(item)
+            for group in config.notify_groups:
+                try:
+                    if at_qq > 0:
+                        full_msg = Message(
+                            MessageSegment.at(at_qq) + f"\n{msg}"
+                        )
+                    else:
+                        full_msg = Message(msg)
+                    await bot.send_group_msg(
+                        group_id=group, message=full_msg,
+                    )
+                except Exception as e:
+                    logger.error(f"发送点名群通知失败 ({group}): {e}")
+
+            if qq_id > 0:
+                try:
+                    await bot.send_private_msg(user_id=qq_id, message=msg)
+                except Exception as e:
+                    logger.error(
+                        f"发送点名私聊通知失败 ({qq_id}): {e}"
+                    )
+
+    async def notify_todos(self, items: list[dict], qq_id: int):
+        """批量发送待办通知。"""
+        try:
+            bot = get_bot()
+        except ValueError:
+            logger.error("没有可用的 Bot 实例")
+            return
+
+        at_qq = self._resolve_at_qq(qq_id)
+
+        for item in items:
+            msg = self._format_todo(item)
+            for group in config.notify_groups:
+                try:
+                    if at_qq > 0:
+                        full_msg = Message(
+                            MessageSegment.at(at_qq) + f"\n{msg}"
+                        )
+                    else:
+                        full_msg = Message(msg)
+                    await bot.send_group_msg(
+                        group_id=group, message=full_msg,
+                    )
+                except Exception as e:
+                    logger.error(f"发送待办群通知失败 ({group}): {e}")
+
+            if qq_id > 0:
+                try:
+                    await bot.send_private_msg(user_id=qq_id, message=msg)
+                except Exception as e:
+                    logger.error(
+                        f"发送待办私聊通知失败 ({qq_id}): {e}"
+                    )
+
+    async def alert_superusers(self, msg: str):
+        """给所有 SUPERUSERS 发送告警（用于连续失败场景）。"""
+        try:
+            bot = get_bot()
+            for sid in bot.config.superusers:
+                try:
+                    await bot.send_private_msg(
+                        user_id=int(sid), message=msg,
+                    )
+                except Exception:
+                    pass
+        except Exception:
+            logger.error(f"无法发送告警消息: {msg}")
+
+
+notifier = Notifier()