koishi-plugin-cocoyyy-console 1.0.8 → 1.0.9-beta.1

package/lib/index.js

@@ -322,10 +322,7 @@ function getMenuList(command = null, functionConfig) {
     case "rbq":
       if (!functionConfig.rbq_flag)
         return "*人功能已关闭";
-      return `[所有命令都需要@bot]
-*人功能菜单:
-联系管理人员配置群内指定用户，在群内@指定用户，会触发*人功能
-如果遇到问题请联系开发人员。`;
+      return getRbqFuncMenu(command);
     default:
       return `[所有命令都需要@bot]
 当前可用功能列表:
@@ -383,6 +380,35 @@ function getTagFuncMenu(command = null) {
 输入对应指令使用标签功能，如果遇到问题请联系开发人员。`;
 }
 __name(getTagFuncMenu, "getTagFuncMenu");
+var rbqFuncMenuList = [
+  {
+    name: "rbqlist",
+    description: "查看rbq列表",
+    command: "rbqlist"
+  },
+  {
+    name: "rbqadd",
+    description: "添加rbq (3个上限)",
+    command: "rbqadd [QQ号]"
+  },
+  {
+    name: "rbqinstead",
+    description: "替换已存在rbq",
+    command: "rbqinstead [已存在QQ号] [替换QQ号]"
+  },
+  {
+    name: "rbqadd_txt",
+    description: "添加自定义文本",
+    command: "rbqadd_txt [文本] [目标QQ号(可选)]"
+  }
+];
+function getRbqFuncMenu(command = null) {
+  return `[所有命令都需要@bot]
+*人功能菜单:
+	${rbqFuncMenuList.map((item) => item.command + ": " + item.description).join("\n	")}
+输入对应指令使用*人功能，如果遇到问题请联系开发人员。`;
+}
+__name(getRbqFuncMenu, "getRbqFuncMenu");
 function registerMenuCommands(ctx, connected, functionConfig) {
   ctx.command("help <参数>", "帮助菜单").action(async ({ session }, ...args) => {
     if (!dev_mode) {
@@ -866,32 +892,414 @@ function registerRepeatMiddleware(ctx, config) {
 }
 __name(registerRepeatMiddleware, "registerRepeatMiddleware");
 
-// src/services/rbq_func/rbq_service.ts
+// src/services/rbq_func/rbq_command.ts
 var import_koishi8 = require("koishi");
-function registerRbqMiddleware(ctx, config) {
-  if (!config?.configList || config.configList.length === 0) return;
-  ctx.middleware((session, next) => {
+
+// src/models/rbq_persons.ts
+var import_sequelize5 = require("sequelize");
+var RbqPersonModel = class extends import_sequelize5.Model {
+  static {
+    __name(this, "RbqPersonModel");
+  }
+  id;
+  guild_id;
+  uid_list;
+  createtime;
+};
+var inited3 = false;
+function getRbqPersonModel() {
+  const sequelize2 = getSequelize();
+  if (!inited3) {
+    RbqPersonModel.init(
+      {
+        id: {
+          type: import_sequelize5.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false,
+          autoIncrement: true,
+          primaryKey: true
+        },
+        guild_id: {
+          type: import_sequelize5.DataTypes.STRING(128),
+          allowNull: false
+        },
+        uid_list: {
+          type: import_sequelize5.DataTypes.STRING(128),
+          allowNull: false
+        },
+        createtime: {
+          type: import_sequelize5.DataTypes.DATE,
+          allowNull: false,
+          defaultValue: import_sequelize5.DataTypes.NOW,
+          field: "createtime",
+          set(value) {
+            if (typeof value === "number") {
+              const ts = value > 1e12 ? value : value * 1e3;
+              this.setDataValue("createtime", new Date(ts));
+            } else {
+              this.setDataValue("createtime", value);
+            }
+          }
+        }
+      },
+      {
+        sequelize: sequelize2,
+        tableName: "rbq_persons",
+        modelName: "RbqPerson",
+        timestamps: false,
+        underscored: false
+      }
+    );
+    inited3 = true;
+  }
+  return RbqPersonModel;
+}
+__name(getRbqPersonModel, "getRbqPersonModel");
+
+// src/services/rbq_func/rbq_service.ts
+var import_sequelize7 = require("sequelize");
+
+// src/models/rbq_content.ts
+var import_sequelize6 = require("sequelize");
+var RbqContentModel = class extends import_sequelize6.Model {
+  static {
+    __name(this, "RbqContentModel");
+  }
+  id;
+  guild_id;
+  content;
+  tag_uid;
+  createtime;
+};
+var inited4 = false;
+function getRbqContentModel() {
+  const sequelize2 = getSequelize();
+  if (!inited4) {
+    RbqContentModel.init(
+      {
+        id: {
+          type: import_sequelize6.DataTypes.INTEGER.UNSIGNED,
+          allowNull: false,
+          autoIncrement: true,
+          primaryKey: true
+        },
+        guild_id: {
+          type: import_sequelize6.DataTypes.STRING(128),
+          allowNull: false
+        },
+        content: {
+          type: import_sequelize6.DataTypes.STRING(512),
+          allowNull: false
+        },
+        tag_uid: {
+          type: import_sequelize6.DataTypes.STRING(128),
+          allowNull: true
+        },
+        createtime: {
+          type: import_sequelize6.DataTypes.DATE,
+          allowNull: false,
+          defaultValue: import_sequelize6.DataTypes.NOW,
+          field: "createtime",
+          set(value) {
+            if (typeof value === "number") {
+              const ts = value > 1e12 ? value : value * 1e3;
+              this.setDataValue("createtime", new Date(ts));
+            } else {
+              this.setDataValue("createtime", value);
+            }
+          }
+        }
+      },
+      {
+        sequelize: sequelize2,
+        tableName: "rbq_content",
+        modelName: "RbqContent",
+        timestamps: false,
+        underscored: false
+      }
+    );
+    inited4 = true;
+  }
+  return RbqContentModel;
+}
+__name(getRbqContentModel, "getRbqContentModel");
+
+// src/services/rbq_func/rbq_service.ts
+var personMap = /* @__PURE__ */ new Map();
+async function check_in_group(ctx, session, uid) {
+  const bot = ctx.bots[session.uid] || Object.values(ctx.bots)[0];
+  if (!bot) return { result: false, error: "未找到可用的机器人实例" };
+  if (bot.platform !== "onebot") return { result: false, error: "当前平台不支持该操作" };
+  try {
+    const guildId = session.guildId;
+    const memberList = await bot.getGuildMemberList(guildId);
+    const members = memberList.data;
+    if (!members?.length) {
+      return { result: false, error: `群 ${guildId} 未获取到成员` };
+    }
+    const result = members.find((t) => t.user?.id === uid);
+    if (!result) {
+      return { result: false, error: `群 ${guildId} 未找到成员 ${uid}` };
+    }
+    return { result: true, error: null };
+  } catch (err) {
+    console.error(err);
+    return { result: false, error: `检查群成员失败：${err.message}` };
+  }
+}
+__name(check_in_group, "check_in_group");
+function findPersonByUid(uid, guild_id) {
+  const Rbq = getRbqPersonModel();
+  return Rbq.findOne({
+    where: {
+      guild_id,
+      [import_sequelize7.Op.or]: [
+        { uid_list: { [import_sequelize7.Op.like]: `%${uid}%` } }
+      ]
+    }
+  });
+}
+__name(findPersonByUid, "findPersonByUid");
+function findGuildRecord(guild_id) {
+  const Rbq = getRbqPersonModel();
+  return Rbq.findOne({
+    where: {
+      guild_id
+    }
+  });
+}
+__name(findGuildRecord, "findGuildRecord");
+async function init_person() {
+  try {
+    const Rbq = getRbqPersonModel();
+    const existed = await Rbq.findAll();
+    if (!existed) return;
+    existed.forEach(async (item) => {
+      const guild_id = item.get("guild_id");
+      const uid_list = item.get("uid_list");
+      personMap.set(guild_id, uid_list.split(";"));
+    });
+    return true;
+  } catch (e) {
+    logger.error("[init_person Error]: " + e?.message || String(e));
+    return false;
+  }
+}
+__name(init_person, "init_person");
+async function create_person(guild_id, uid) {
+  try {
+    const Rbq = getRbqPersonModel();
+    let existed = await findPersonByUid(uid, guild_id);
+    if (existed) {
+      throw new Error("already existed!");
+    }
+    let guildRecord = await findGuildRecord(guild_id);
+    if (guildRecord) {
+      let uidList = guildRecord.get("uid_list");
+      if (uidList != null) {
+        const list = uidList.split(";");
+        if (list.length >= 3) {
+          return { result: false, error: "已满，需要替换已有rbq!" };
+        }
+        if (!list.includes(uid)) list.push(uid);
+        uidList = list.join(";");
+      } else {
+        uidList = uid;
+      }
+      guildRecord.set("uid_list", uidList);
+      await guildRecord.save();
+      personMap.set(guild_id, uidList.split(";"));
+      return { result: true, error: null };
+    } else {
+      const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+      guildRecord = await Rbq.create({
+        guild_id,
+        uid_list: uid,
+        createtime: now
+      });
+      personMap.set(guild_id, [uid]);
+    }
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[create_rbq Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(create_person, "create_person");
+async function get_person_list(guild_id) {
+  const Rbq = getRbqPersonModel();
+  try {
+    const existed = await findGuildRecord(guild_id);
+    if (!existed) {
+      throw new Error("not found record in " + guild_id);
+    }
+    return existed.get("uid_list").split(";");
+  } catch (e) {
+    logger.error("[get_rbq_list Error]: " + e?.message || String(e));
+    return [];
+  }
+}
+__name(get_person_list, "get_person_list");
+async function instead_person(guild_id, source_uid, target_uid) {
+  try {
+    const Rbq = getRbqPersonModel();
+    const existed = await findGuildRecord(guild_id);
+    if (!existed) {
+      throw new Error("not found record in " + guild_id);
+    }
+    let uidList = existed.get("uid_list");
+    if (uidList == null) {
+      throw new Error("not found source_uid in " + guild_id);
+    }
+    let list = uidList.split(";");
+    if (!list.includes(source_uid)) {
+      throw new Error("not found source_uid in " + guild_id);
+    }
+    uidList = uidList.replaceAll(source_uid, target_uid);
+    existed.set("uid_list", uidList);
+    await existed.save();
+    personMap.set(guild_id, uidList.split(";"));
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[instead_person Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(instead_person, "instead_person");
+function get_person_map() {
+  return personMap;
+}
+__name(get_person_map, "get_person_map");
+async function create_content(guild_id, content, tar_uid) {
+  try {
+    const RbqContent = getRbqContentModel();
+    const now = new Date(Date.now() + 8 * 60 * 60 * 1e3);
+    let contentRecord = await RbqContent.create({
+      guild_id,
+      content,
+      tag_uid: tar_uid,
+      createtime: now
+    });
+    return { result: true, error: null };
+  } catch (e) {
+    logger.error("[create_content Error]: " + e?.message || String(e));
+    return { result: false, error: e?.message || String(e) };
+  }
+}
+__name(create_content, "create_content");
+async function get_content_list(guild_id, tar_uid) {
+  try {
+    const RbqContent = getRbqContentModel();
+    const existed = await RbqContent.findAll({
+      where: {
+        guild_id,
+        tag_uid: null
+      }
+    });
+    let result_list = [];
+    result_list.push(...existed.map((item) => item.get("content")).filter(Boolean));
+    if (tar_uid) {
+      const tar_existed = await RbqContent.findAll({
+        where: {
+          guild_id,
+          tag_uid: tar_uid
+        }
+      });
+      result_list.push(...tar_existed.map((item) => item.get("content")).filter(Boolean));
+    }
+    return result_list;
+  } catch (e) {
+    logger.error("[get_content_list Error]: " + e?.message || String(e));
+    return [];
+  }
+}
+__name(get_content_list, "get_content_list");
+
+// src/services/rbq_func/rbq_command.ts
+function registerRbqCommands(ctx, connected) {
+  init_person();
+  ctx.command("rbqlist", "查看rbq列表").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    const list = await get_person_list(session.guildId);
+    return `当前群聊rbq列表：
+${list.join(",")}`;
+  });
+  ctx.command("rbqadd <参数>", "添加rbq").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    const uid = args?.[0];
+    if (!uid) return "请提供正确格式，如：@bot rbqadd [QQ号]";
+    let exec = await check_in_group(ctx, session, uid);
+    if (!exec.result)
+      return `${uid}不在当前群聊中`;
+    exec = await create_person(session.guildId, uid);
+    if (!exec.result)
+      return `添加rbq失败：${exec.error}`;
+    return `已添加rbq：${uid}`;
+  });
+  ctx.command("rbqinstead <参数>", "替换rbq").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    const source_uid = args?.[0];
+    const target_uid = args?.[1];
+    if (!source_uid || !target_uid) return "请提供正确格式，如：@bot rbqinstead [已存在QQ号] [替换QQ号]";
+    let exec = await check_in_group(ctx, session, target_uid);
+    if (!exec.result)
+      return `${target_uid}不在当前群聊中`;
+    exec = await instead_person(session.guildId, source_uid, target_uid);
+    if (!exec.result)
+      return `替换rbq失败：${exec.error}`;
+    return `已替换rbq：${source_uid} -> ${target_uid}`;
+  });
+  ctx.command("rbqadd_txt <参数>", "添加自定义文本").action(async ({ session }, ...args) => {
+    if (!dev_mode) {
+      if (!connected) return;
+      if (!is_at_bot(session)) return;
+    }
+    const content = args?.[0];
+    const target_uid = args?.[1] ?? null;
+    if (!content) return "请提供正确格式，如：@bot rbqadd_txt [文本] [目标QQ号(可选)]";
+    let exec = await check_in_group(ctx, session, target_uid);
+    if (!exec.result)
+      return `${target_uid}不在当前群聊中`;
+    exec = await create_content(session.guildId, content, target_uid);
+    if (!exec.result)
+      return `添加自定义文本失败：${exec.error}`;
+    return "已添加自定义文本";
+  });
+  ctx.middleware(async (session, next) => {
     const { guildId, elements } = session;
     if (ctx.bots[session.uid]) return next();
-    if (!config.configList.some((item) => item.guild_id === guildId)) return next();
+    const personMap2 = get_person_map();
+    const rbqList = personMap2.get(guildId);
+    if (!rbqList || rbqList.length === 0) return next();
     const atElements = elements?.filter((el) => el.type === "at") || [];
     if (atElements.length === 0) return next();
-    const matched = config.configList.find((item) => {
-      if (item.guild_id !== guildId) return false;
-      const targetUid = item.uid?.trim();
-      if (!targetUid) return false;
-      const isAtTarget = atElements.some((el) => el.attrs?.id === targetUid);
-      if (!isAtTarget) return false;
-      const probability = item.probability ?? 1;
-      return Math.random() <= probability;
-    });
-    if (!matched) return next();
-    const content = matched.content || "*你";
-    session.send((0, import_koishi8.h)("at", { id: matched.uid.trim() }) + " " + content);
-    return;
+    const matchedUid = atElements.find((el) => {
+      const targetUid = el.attrs?.id;
+      return targetUid && rbqList.includes(targetUid);
+    })?.attrs?.id;
+    if (!matchedUid) return next();
+    try {
+      const contents = await get_content_list(guildId, matchedUid);
+      if (contents && contents.length > 0) {
+        const random = new import_koishi8.Random(() => Math.random());
+        let result = contents[random.int(0, contents.length)];
+        session.send((0, import_koishi8.h)("at", { id: matchedUid }) + " " + result);
+      }
+      return;
+    } catch (error) {
+      logger.error("[rbq middleware] Error:", error);
+    }
   });
 }
-__name(registerRbqMiddleware, "registerRbqMiddleware");
+__name(registerRbqCommands, "registerRbqCommands");
 
 // src/services/test_command.ts
 function registerTestCommands(ctx) {
@@ -925,8 +1333,8 @@ var Config = import_koishi9.Schema.object({
   function_config: FunctionConfigSchema.description("功能开关配置"),
   mysql_config: MysqlConfigSchema.description("MySQL 数据库配置"),
   tag_config: SaveConfigSchema.description("tag图片保存配置"),
-  repeat_config: RepeatConfigSchema.description("复读配置"),
-  rbq_config: RbqConfigSchema.description("*人配置")
+  repeat_config: RepeatConfigSchema.description("复读配置")
+  // rbq_config:my_config.RbqConfigSchema.description('*人配置')
 });
 var logger = new import_koishi9.Logger(name);
 var savePath = null;
@@ -939,6 +1347,8 @@ async function apply(ctx, config) {
   if (connected) {
     await getTagsModel().sync();
     await getImgsModel().sync();
+    await getRbqPersonModel().sync();
+    await getRbqContentModel().sync();
   }
   savePath = resolveTagBaseDir(config?.tag_config);
   registerMenuCommands(ctx, connected, config.function_config);
@@ -947,7 +1357,7 @@ async function apply(ctx, config) {
   if (config.function_config.repeat_flag)
     registerRepeatMiddleware(ctx, config?.repeat_config);
   if (config.function_config.rbq_flag)
-    registerRbqMiddleware(ctx, config?.rbq_config);
+    registerRbqCommands(ctx, connected);
   if (dev_mode)
     registerTestCommands(ctx);
 }

package/lib/models/rbq_content.d.ts

@@ -0,0 +1,17 @@
+import { Model, Optional } from 'sequelize';
+export interface RbqContentAttributes {
+    id: number;
+    guild_id: string;
+    content: string;
+    tag_uid: string;
+    createtime: Date;
+}
+export type RbqContentCreationAttributes = Optional<RbqContentAttributes, 'id' | 'createtime'>;
+export declare class RbqContentModel extends Model<RbqContentAttributes, RbqContentCreationAttributes> implements RbqContentAttributes {
+    id: number;
+    guild_id: string;
+    content: string;
+    tag_uid: string;
+    createtime: Date;
+}
+export declare function getRbqContentModel(): typeof RbqContentModel;

package/lib/models/rbq_persons.d.ts

@@ -0,0 +1,15 @@
+import { Model, Optional } from 'sequelize';
+export interface RbqPersonAttributes {
+    id: number;
+    guild_id: string;
+    uid_list: string;
+    createtime: Date;
+}
+export type RbqPersonCreationAttributes = Optional<RbqPersonAttributes, 'id' | 'createtime'>;
+export declare class RbqPersonModel extends Model<RbqPersonAttributes, RbqPersonCreationAttributes> implements RbqPersonAttributes {
+    id: number;
+    guild_id: string;
+    uid_list: string;
+    createtime: Date;
+}
+export declare function getRbqPersonModel(): typeof RbqPersonModel;

package/lib/services/rbq_func/rbq_command.d.ts

@@ -0,0 +1,3 @@
+import { Context } from 'koishi';
+declare function registerRbqCommands(ctx: Context, connected: boolean): void;
+export { registerRbqCommands };

package/lib/services/rbq_func/rbq_service.d.ts

@@ -1,4 +1,22 @@
-import { Context } from 'koishi';
-import { RbqConfig } from '../../utils/config';
-declare function registerRbqMiddleware(ctx: Context, config?: RbqConfig): void;
-export { registerRbqMiddleware, };
+import { Context, Session } from 'koishi';
+declare function check_in_group(ctx: Context, session: Session, uid: string): Promise<{
+    result: boolean;
+    error: string;
+}>;
+declare function init_person(): Promise<boolean>;
+declare function create_person(guild_id: string, uid: string): Promise<{
+    result: boolean;
+    error: string;
+}>;
+declare function get_person_list(guild_id: string): Promise<string[]>;
+declare function instead_person(guild_id: string, source_uid: string, target_uid: string): Promise<{
+    result: boolean;
+    error: string;
+}>;
+declare function get_person_map(): Map<string, string[]>;
+declare function create_content(guild_id: string, content: string, tar_uid: string | null): Promise<{
+    result: boolean;
+    error: string;
+}>;
+declare function get_content_list(guild_id: string, tar_uid: string | null): Promise<string[]>;
+export { init_person, check_in_group, create_person, get_person_list, instead_person, get_person_map, create_content, get_content_list };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-cocoyyy-console",
   "description": "自用koishi插件，功能包含复读，记录黑历史，*人等",
-  "version": "1.0.8",
+  "version": "1.0.9-beta.1",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "contributors": [