mioku-plugin-deerpipe 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# mioku-plugin-deerpipe
+
+> 本插件移植自 https://github.com/SamuNatsu/nonebot-plugin-deer-pipe ，欢迎原作者接手维护
+> 侵权请发 issue 联系删除，谢谢 :)
+
+每月🦌管签到插件。Mioku/TypeScript 版
+
+## ✨ 功能
+
+- 自🦌：每天签到
+- 帮🦌：帮别人签到
+- 补🦌：补本月之前漏签的日子
+- 🦌历：查看自己/别人的本月🦌签到日历
+- 🦌榜：查看本群本月🦌签到排行榜
+- 帮🦌 on/off：允许/禁止被别人帮🦌
+- 禁🦌：管理员禁止某人在一段时间内🦌
+
+所有命令中的「🦌」都可以用「鹿」字代替。
+
+## 🎉 指令
+
+| 指令                | 说明                  | 权限   |
+|-------------------|---------------------|------|
+| `🦌` / `鹿`        | 自🦌一次               | 全员   |
+| `🦌 @某人`          | 帮某人🦌一次（仅群组）        | 全员   |
+| `补🦌 <日>`         | 补签本月某天              | 全员   |
+| `🦌历` / `🦌历 @某人` | 查看本月🦌日历            | 全员   |
+| `🦌榜`             | 查看本月本群🦌排行榜（仅群组）    | 全员   |
+| `帮🦌 on/off`      | 允许/禁止别人帮自己🦌        | 全员   |
+| `帮🦌 on/off @某人`  | 允许/禁止帮某人🦌          | 群管理员 |
+| `禁🦌 @某人 [时长]`    | 禁止某人🦌一段时间，省略时长视为解禁 | 群管理员 |
+
+时长支持 `30s` / `5m` / `2h` / `1d` / `1w` 等写法，最长 30 天。

package/commands.ts

@@ -0,0 +1,384 @@
+import type { ScreenshotService } from "mioku";
+import type { MiokiContext } from "mioki";
+import type { DeerDatabase } from "./db";
+import { generateCalendarImage, generateRankImage } from "./image";
+import {
+  formatDateTime,
+  getAtUserId,
+  parseDuration,
+  replyImage,
+  resolveScene,
+  resolveUserName,
+} from "./utils";
+
+const MAX_NO_DEER_DURATION_S = 30 * 86400;
+
+interface CommandContext {
+  ctx: MiokiContext;
+  db: DeerDatabase;
+  screenshot: ScreenshotService;
+  event: any;
+}
+
+function normalize(text: string): string {
+  return text.replace(/鹿/g, "🦌").trim();
+}
+
+function isGroupAdmin(event: any): boolean {
+  const role = event?.sender?.role;
+  return role === "admin" || role === "owner";
+}
+
+export type DeerCommand =
+  | { type: "deer"; targetUserId?: number }
+  | { type: "past"; day: number }
+  | { type: "calendar"; targetUserId?: number }
+  | { type: "rank" }
+  | { type: "set_can_be_helped"; allowed: boolean; targetUserId?: number }
+  | { type: "set_no_deer"; targetUserId: number; durationText?: string }
+  | { type: "invalid_past" }
+  | { type: "none" };
+
+/**
+ * Parse a message into a deer command.
+ * Returns "none" if the message doesn't look like a deer command at all.
+ */
+export function parseDeerCommand(
+  text: string,
+  message: any[],
+): DeerCommand {
+  const normalized = normalize(text);
+  if (!normalized) return { type: "none" };
+  const tokens = normalized.split(/\s+/).filter(Boolean);
+  const head = tokens[0];
+  if (!head) return { type: "none" };
+
+  if (head === "🦌") {
+    return { type: "deer", targetUserId: getAtUserId(message) };
+  }
+
+  if (head === "补🦌") {
+    const arg = tokens[1];
+    if (!arg) return { type: "invalid_past" };
+    const day = Number(arg);
+    if (!Number.isInteger(day)) return { type: "invalid_past" };
+    return { type: "past", day };
+  }
+
+  if (head === "🦌历") {
+    return { type: "calendar", targetUserId: getAtUserId(message) };
+  }
+
+  if (head === "🦌榜") {
+    return { type: "rank" };
+  }
+
+  if (head === "帮🦌") {
+    const flag = (tokens[1] || "").toLowerCase();
+    if (flag !== "on" && flag !== "off") return { type: "none" };
+    return {
+      type: "set_can_be_helped",
+      allowed: flag === "on",
+      targetUserId: getAtUserId(message),
+    };
+  }
+
+  if (head === "禁🦌") {
+    const targetUserId = getAtUserId(message);
+    if (!targetUserId) return { type: "none" };
+    const durationText = tokens.slice(1).join("").trim();
+    return {
+      type: "set_no_deer",
+      targetUserId,
+      durationText: durationText || undefined,
+    };
+  }
+
+  return { type: "none" };
+}
+
+export async function handleDeerCommand(
+  cmd: DeerCommand,
+  cmdCtx: CommandContext,
+): Promise<void> {
+  switch (cmd.type) {
+    case "deer":
+      return handleDeer(cmdCtx, cmd.targetUserId);
+    case "past":
+      return handlePast(cmdCtx, cmd.day);
+    case "calendar":
+      return handleCalendar(cmdCtx, cmd.targetUserId);
+    case "rank":
+      return handleRank(cmdCtx);
+    case "set_can_be_helped":
+      return handleSetCanBeHelped(cmdCtx, cmd.allowed, cmd.targetUserId);
+    case "set_no_deer":
+      return handleSetNoDeer(cmdCtx, cmd.targetUserId, cmd.durationText);
+    case "invalid_past":
+      await cmdCtx.event.reply("不是合法的补🦌日期捏", true);
+      return;
+    case "none":
+      return;
+  }
+}
+
+async function handleDeer(
+  cmdCtx: CommandContext,
+  targetUserId?: number,
+): Promise<void> {
+  const { ctx, db, screenshot, event } = cmdCtx;
+  const scene = resolveScene(event);
+  const now = new Date();
+
+  // 帮🦌 only makes sense in groups
+  if (targetUserId && !scene.isGroup) {
+    return;
+  }
+
+  const userId =
+    targetUserId != null ? targetUserId : Number(event.user_id);
+  const user = db.getOrCreateUser(scene.key, userId);
+
+  if (targetUserId && !user.canBeHelped) {
+    await event.reply("该用户不准别人帮🦌捏", true);
+    return;
+  }
+
+  if (
+    scene.isGroup &&
+    user.noDeerUntil != null &&
+    user.noDeerUntil > now.getTime()
+  ) {
+    await event.reply(
+      `该用户已被禁🦌至 ${formatDateTime(user.noDeerUntil)}`,
+      true,
+    );
+    return;
+  }
+
+  const result = await db.checkIn(
+    scene.key,
+    userId,
+    now.getFullYear(),
+    now.getMonth() + 1,
+    now.getDate(),
+    false,
+  );
+
+  const name = await resolveUserName(ctx, event, userId);
+  const imagePath = await generateCalendarImage(screenshot, {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    todayDay: now.getDate(),
+    records: result.records,
+    name,
+    userId,
+  });
+
+  const prefix = targetUserId
+    ? [{ type: "text", data: { text: "成功帮 " } }, ctx.segment.at(targetUserId), { type: "text", data: { text: " 🦌了\n" } }]
+    : [{ type: "text", data: { text: "成功🦌了\n" } }];
+
+  await replyImage(event, ctx.segment, imagePath, prefix);
+}
+
+async function handlePast(
+  cmdCtx: CommandContext,
+  day: number,
+): Promise<void> {
+  const { ctx, db, screenshot, event } = cmdCtx;
+  const scene = resolveScene(event);
+  const now = new Date();
+
+  if (day < 1 || day >= now.getDate()) {
+    await event.reply("不是合法的补🦌日期捏", true);
+    return;
+  }
+
+  const userId = Number(event.user_id);
+  db.getOrCreateUser(scene.key, userId);
+
+  const result = await db.checkIn(
+    scene.key,
+    userId,
+    now.getFullYear(),
+    now.getMonth() + 1,
+    day,
+    true,
+  );
+
+  const name = await resolveUserName(ctx, event, userId);
+  const imagePath = await generateCalendarImage(screenshot, {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    todayDay: now.getDate(),
+    records: result.records,
+    name,
+    userId,
+  });
+
+  const text = result.ok ? "成功补🦌\n" : "不能补🦌已经🦌过的日子捏\n";
+  await replyImage(
+    event,
+    ctx.segment,
+    imagePath,
+    [{ type: "text", data: { text } }],
+  );
+}
+
+async function handleCalendar(
+  cmdCtx: CommandContext,
+  targetUserId?: number,
+): Promise<void> {
+  const { ctx, db, screenshot, event } = cmdCtx;
+  const scene = resolveScene(event);
+  if (targetUserId && !scene.isGroup) return;
+
+  const now = new Date();
+  const userId = targetUserId ?? Number(event.user_id);
+  db.getOrCreateUser(scene.key, userId);
+  const records = db.getRecords(
+    scene.key,
+    userId,
+    now.getFullYear(),
+    now.getMonth() + 1,
+  );
+
+  const name = await resolveUserName(ctx, event, userId);
+  const imagePath = await generateCalendarImage(screenshot, {
+    year: now.getFullYear(),
+    month: now.getMonth() + 1,
+    todayDay: now.getDate(),
+    records,
+    name,
+    userId,
+  });
+
+  await replyImage(event, ctx.segment, imagePath);
+}
+
+async function handleRank(cmdCtx: CommandContext): Promise<void> {
+  const { ctx, db, screenshot, event } = cmdCtx;
+  const scene = resolveScene(event);
+  if (!scene.isGroup) return;
+
+  const now = new Date();
+  const top = db.getRank(
+    scene.key,
+    now.getFullYear(),
+    now.getMonth() + 1,
+    5,
+  );
+
+  const rows = await Promise.all(
+    top.map(async (entry, idx) => ({
+      rank: idx + 1,
+      userId: entry.userId,
+      name: await resolveUserName(ctx, event, entry.userId),
+      count: entry.count,
+    })),
+  );
+
+  const imagePath = await generateRankImage(
+    screenshot,
+    rows,
+    now.getFullYear(),
+    now.getMonth() + 1,
+  );
+
+  await replyImage(event, ctx.segment, imagePath);
+}
+
+async function handleSetCanBeHelped(
+  cmdCtx: CommandContext,
+  allowed: boolean,
+  targetUserId?: number,
+): Promise<void> {
+  const { ctx, db, event } = cmdCtx;
+  const scene = resolveScene(event);
+  if (!scene.isGroup) return;
+
+  if (targetUserId && !isGroupAdmin(event)) {
+    await event.reply("权限不足", true);
+    return;
+  }
+
+  const userId = targetUserId ?? Number(event.user_id);
+  const user = db.getOrCreateUser(scene.key, userId);
+  user.canBeHelped = allowed;
+  await db.updateUser(user);
+
+  if (targetUserId) {
+    await event.reply(
+      [
+        { type: "text", data: { text: `已${allowed ? "允许" : "禁止"}帮 ` } },
+        ctx.segment.at(targetUserId),
+        { type: "text", data: { text: " 🦌" } },
+      ],
+      true,
+    );
+  } else {
+    await event.reply(`已${allowed ? "允许" : "禁止"}别人帮🦌`, true);
+  }
+}
+
+async function handleSetNoDeer(
+  cmdCtx: CommandContext,
+  targetUserId: number,
+  durationText?: string,
+): Promise<void> {
+  const { ctx, db, event } = cmdCtx;
+  const scene = resolveScene(event);
+  if (!scene.isGroup) return;
+
+  if (!isGroupAdmin(event)) {
+    await event.reply("权限不足", true);
+    return;
+  }
+
+  let durationS: number | null = null;
+  if (durationText) {
+    durationS = parseDuration(durationText);
+    if (durationS == null) {
+      await event.reply("时间段表达式解析错误", true);
+      return;
+    }
+    if (durationS > MAX_NO_DEER_DURATION_S) {
+      await event.reply(
+        `时间段过长：最大允许时间为 ${MAX_NO_DEER_DURATION_S / 86400} 天`,
+        true,
+      );
+      return;
+    }
+  }
+
+  const user = db.getOrCreateUser(scene.key, targetUserId);
+  user.noDeerUntil =
+    durationS == null ? null : Date.now() + durationS * 1000;
+  await db.updateUser(user);
+
+  if (user.noDeerUntil == null) {
+    await event.reply(
+      [
+        { type: "text", data: { text: "已解禁 " } },
+        ctx.segment.at(targetUserId),
+        { type: "text", data: { text: " 的🦌权" } },
+      ],
+      true,
+    );
+  } else {
+    await event.reply(
+      [
+        { type: "text", data: { text: "已禁止 " } },
+        ctx.segment.at(targetUserId),
+        {
+          type: "text",
+          data: {
+            text: ` 的🦌权至 ${formatDateTime(user.noDeerUntil)}`,
+          },
+        },
+      ],
+      true,
+    );
+  }
+}

package/db.ts

@@ -0,0 +1,196 @@
+import { createDB } from "mioki";
+import { ensureDataDir } from "mioku";
+import * as path from "path";
+import type {
+  DeerCheckInResult,
+  DeerRankEntry,
+  DeerUser,
+} from "./types";
+
+interface UserRecord {
+  canBeHelped: boolean;
+  noDeerUntil: number | null;
+}
+
+/**
+ * users:   key = "<scene>:<userId>"
+ * records: scene -> "yyyy-mm" -> userId -> day -> count
+ */
+interface DeerStore {
+  users: Record<string, UserRecord>;
+  records: Record<
+    string,
+    Record<string, Record<string, Record<string, number>>>
+  >;
+}
+
+const DEFAULT_STORE: DeerStore = {
+  users: {},
+  records: {},
+};
+
+export interface DeerDatabase {
+  getOrCreateUser(scene: string, userId: number): DeerUser;
+  updateUser(user: DeerUser): Promise<void>;
+  getRecords(
+    scene: string,
+    userId: number,
+    year: number,
+    month: number,
+  ): Map<number, number>;
+  checkIn(
+    scene: string,
+    userId: number,
+    year: number,
+    month: number,
+    day: number,
+    isPast: boolean,
+  ): Promise<DeerCheckInResult>;
+  getRank(
+    scene: string,
+    year: number,
+    month: number,
+    limit: number,
+  ): DeerRankEntry[];
+  cleanupOtherMonths(year: number, month: number): Promise<void>;
+}
+
+function userKey(scene: string, userId: number): string {
+  return `${scene}:${userId}`;
+}
+
+function monthKey(year: number, month: number): string {
+  return `${year}-${String(month).padStart(2, "0")}`;
+}
+
+export async function initDeerDatabase(): Promise<DeerDatabase> {
+  const dir = ensureDataDir("deerpipe");
+  const file = path.join(dir, "deerpipe.json");
+  const db = await createDB<DeerStore>(file, {
+    defaultData: structuredClone(DEFAULT_STORE),
+  });
+
+  // Defensive: createDB merges with defaultData but keys may have been
+  // dropped from a hand-edited file.
+  if (!db.data.users) db.data.users = {};
+  if (!db.data.records) db.data.records = {};
+
+  function readUserRecord(scene: string, userId: number): UserRecord {
+    const key = userKey(scene, userId);
+    let row = db.data.users[key];
+    if (!row) {
+      row = { canBeHelped: true, noDeerUntil: null };
+      db.data.users[key] = row;
+    }
+    return row;
+  }
+
+  function readMonthRecords(
+    scene: string,
+    userId: number,
+    year: number,
+    month: number,
+  ): Record<string, number> {
+    const sceneRecords = db.data.records[scene];
+    if (!sceneRecords) return {};
+    const monthRecords = sceneRecords[monthKey(year, month)];
+    if (!monthRecords) return {};
+    return monthRecords[String(userId)] ?? {};
+  }
+
+  function loadRecords(
+    scene: string,
+    userId: number,
+    year: number,
+    month: number,
+  ): Map<number, number> {
+    const raw = readMonthRecords(scene, userId, year, month);
+    const map = new Map<number, number>();
+    for (const [k, v] of Object.entries(raw)) {
+      map.set(Number(k), Number(v));
+    }
+    return map;
+  }
+
+  return {
+    getOrCreateUser(scene, userId) {
+      const row = readUserRecord(scene, userId);
+      return {
+        scene,
+        userId,
+        canBeHelped: row.canBeHelped,
+        noDeerUntil: row.noDeerUntil,
+      };
+    },
+
+    async updateUser(user) {
+      const row = readUserRecord(user.scene, user.userId);
+      row.canBeHelped = user.canBeHelped;
+      row.noDeerUntil = user.noDeerUntil;
+      await db.write();
+    },
+
+    getRecords(scene, userId, year, month) {
+      return loadRecords(scene, userId, year, month);
+    },
+
+    async checkIn(scene, userId, year, month, day, isPast) {
+      readUserRecord(scene, userId);
+      const sceneRecords = (db.data.records[scene] ??= {});
+      const monthRecords = (sceneRecords[monthKey(year, month)] ??= {});
+      const userRecords = (monthRecords[String(userId)] ??= {});
+
+      const dayKey = String(day);
+      if (userRecords[dayKey] != null) {
+        if (isPast) {
+          return {
+            ok: false,
+            records: loadRecords(scene, userId, year, month),
+          };
+        }
+        userRecords[dayKey] = Number(userRecords[dayKey]) + 1;
+      } else {
+        userRecords[dayKey] = 1;
+      }
+
+      await db.write();
+      return {
+        ok: true,
+        records: loadRecords(scene, userId, year, month),
+      };
+    },
+
+    getRank(scene, year, month, limit) {
+      const monthRecords = db.data.records[scene]?.[monthKey(year, month)];
+      if (!monthRecords) return [];
+      const totals: DeerRankEntry[] = [];
+      for (const [uid, days] of Object.entries(monthRecords)) {
+        let total = 0;
+        for (const v of Object.values(days)) total += Number(v);
+        if (total > 0) {
+          totals.push({ userId: Number(uid), count: total });
+        }
+      }
+      totals.sort((a, b) => b.count - a.count);
+      return totals.slice(0, limit);
+    },
+
+    async cleanupOtherMonths(year, month) {
+      const keepKey = monthKey(year, month);
+      let dirty = false;
+      for (const [scene, sceneRecords] of Object.entries(db.data.records)) {
+        for (const k of Object.keys(sceneRecords)) {
+          if (k !== keepKey) {
+            delete sceneRecords[k];
+            dirty = true;
+          }
+        }
+        if (Object.keys(sceneRecords).length === 0) {
+          delete db.data.records[scene];
+          dirty = true;
+        }
+      }
+      if (dirty) await db.write();
+    },
+  };
+}