Initial release of AstrBot reminder plugin

This commit is contained in:
itxiaohui committed 2026-10-05 19:22:07 +08:00
commit cf10c43e61
20 files changed
+1692

No files matched your search

+223
View File
@@ -0,0 +1,223 @@
"""Transactional SQLite persistence outside the installed plugin directory."""
import asyncio
import json
import sqlite3
import time
from contextlib import closing
from pathlib import Path
def scope_key(platform_id, group_id, user_id):
# Group UMO may include the sender when unique-session is enabled.
return json.dumps([platform_id, "group" if group_id else "private", group_id or user_id])
class ReminderStore:
def __init__(self, path):
self.path = Path(path)
self._lock = asyncio.Lock()
async def _run(self, operation):
def run():
with closing(sqlite3.connect(self.path, timeout=10)) as db, db:
db.row_factory = sqlite3.Row
return operation(db)
async with self._lock:
# Wait for the worker before releasing the lock even during unload.
worker = asyncio.create_task(asyncio.to_thread(run))
try:
return await asyncio.shield(worker)
except asyncio.CancelledError:
await worker
raise
async def initialize(self):
self.path.parent.mkdir(parents=True, exist_ok=True)
def create(db):
db.executescript("""
PRAGMA journal_mode=WAL;
CREATE TABLE IF NOT EXISTS reminders (
id INTEGER PRIMARY KEY AUTOINCREMENT,
scope TEXT NOT NULL, platform_id TEXT NOT NULL,
platform_name TEXT NOT NULL, destination TEXT NOT NULL,
scene TEXT NOT NULL, umo TEXT NOT NULL,
creator_id TEXT NOT NULL, creator_name TEXT NOT NULL DEFAULT '',
target_id TEXT NOT NULL, target_name TEXT NOT NULL DEFAULT '',
content TEXT NOT NULL, remind_at REAL NOT NULL,
timezone TEXT NOT NULL, repeat_type TEXT NOT NULL
CHECK(repeat_type IN ('none','daily','weekly')),
status TEXT NOT NULL DEFAULT 'active'
CHECK(status IN ('active','done','cancelled')),
failure_count INTEGER NOT NULL DEFAULT 0,
last_error TEXT NOT NULL DEFAULT '',
retry_at REAL NOT NULL DEFAULT 0,
lease_owner TEXT NOT NULL DEFAULT '', lease_until REAL NOT NULL DEFAULT 0,
created_at REAL NOT NULL
);
CREATE INDEX IF NOT EXISTS reminders_due ON reminders(status, remind_at);
CREATE INDEX IF NOT EXISTS reminders_scope ON reminders(scope, creator_id);
CREATE TABLE IF NOT EXISTS members (
scope TEXT NOT NULL, user_id TEXT NOT NULL,
nickname TEXT NOT NULL DEFAULT '', seen_at REAL NOT NULL,
PRIMARY KEY(scope, user_id)
);
""")
await self._run(create)
async def observe(self, scope, user_id, nickname=""):
await self._run(
lambda db: (
db.execute(
"INSERT INTO members VALUES (?,?,?,?) ON CONFLICT(scope,user_id) DO UPDATE SET "
"nickname=CASE WHEN excluded.nickname!='' THEN excluded.nickname ELSE members.nickname END, "
"seen_at=excluded.seen_at",
(scope, user_id, nickname or "", time.time()),
).rowcount
)
)
async def member(self, scope, value):
def read(db):
rows = db.execute(
"SELECT * FROM members WHERE scope=? AND (user_id=? OR nickname=?)",
(scope, value, value),
).fetchall()
exact = [r for r in rows if r["user_id"] == value]
if exact:
return dict(exact[0])
if len(rows) > 1:
raise ValueError("本群有重名用户,请使用真实 @ 或 /tx identity 获取的用户标识。")
return dict(rows[0]) if rows else None
return await self._run(read)
async def add(self, record, limit):
def insert(db):
db.execute("BEGIN IMMEDIATE")
count = db.execute(
"SELECT COUNT(*) FROM reminders WHERE scope=? AND creator_id=? AND status='active'",
(record["scope"], record["creator_id"]),
).fetchone()[0]
if count >= limit:
raise ValueError(f"你在当前会话最多只能设置 {limit} 个提醒,请先取消一些。")
columns = (
"scope",
"platform_id",
"platform_name",
"destination",
"scene",
"umo",
"creator_id",
"creator_name",
"target_id",
"target_name",
"content",
"remind_at",
"timezone",
"repeat_type",
)
cursor = db.execute(
f"INSERT INTO reminders ({','.join(columns)},created_at) "
f"VALUES ({','.join('?' for _ in range(len(columns) + 1))})",
tuple(record[c] for c in columns) + (time.time(),),
)
return cursor.lastrowid
return await self._run(insert)
async def list(self, scope, creator_id=None, history=False):
def read(db):
sql, params = "SELECT * FROM reminders WHERE scope=?", [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if not history:
sql += " AND status='active'"
sql += " ORDER BY remind_at,id"
return [dict(r) for r in db.execute(sql, params).fetchall()]
return await self._run(read)
async def get(self, reminder_id, scope):
def read(db):
row = db.execute(
"SELECT * FROM reminders WHERE id=? AND scope=?", (reminder_id, scope)
).fetchone()
return dict(row) if row else None
return await self._run(read)
async def cancel(self, scope, creator_id, reminder_id=None):
def write(db):
sql = "UPDATE reminders SET status='cancelled', lease_owner='', lease_until=0 WHERE scope=? AND status='active'"
params = [scope]
if creator_id is not None:
sql += " AND creator_id=?"
params.append(creator_id)
if reminder_id is not None:
sql += " AND id=?"
params.append(reminder_id)
return db.execute(sql, params).rowcount
return await self._run(write)
async def due(self, now):
return await self._run(
lambda db: [
dict(r)
for r in db.execute(
"SELECT * FROM reminders WHERE status='active' AND remind_at<=? "
"AND retry_at<=? AND lease_until<=? ORDER BY remind_at,id LIMIT 100",
(now, now, now),
)
]
)
async def claim(self, reminder_id, owner, now):
# One lease per send prevents overlapping hot reloads from sending twice.
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner=?,lease_until=? WHERE id=? AND status='active' "
"AND lease_until<=? AND remind_at<=? AND retry_at<=?",
(owner, now + 120, reminder_id, now, now, now),
).rowcount
== 1
)
)
async def success(self, reminder_id, owner, next_time=None):
return await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET status=?,remind_at=COALESCE(?,remind_at),failure_count=0,"
"last_error='',retry_at=0,lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
("active" if next_time is not None else "done", next_time, reminder_id, owner),
).rowcount
)
)
async def failure(self, reminder_id, owner, error, maximum, retry_at):
def write(db):
db.execute(
"UPDATE reminders SET failure_count=failure_count+1,last_error=?,retry_at=?,"
"status=CASE WHEN failure_count+1>=? THEN 'cancelled' ELSE 'active' END,"
"lease_owner='',lease_until=0 WHERE id=? AND lease_owner=? AND status='active'",
(str(error)[:500], retry_at, maximum, reminder_id, owner),
)
await self._run(write)
async def release(self, reminder_id, owner):
await self._run(
lambda db: (
db.execute(
"UPDATE reminders SET lease_owner='',lease_until=0 WHERE id=? AND lease_owner=?",
(reminder_id, owner),
).rowcount
)
)