@hieuzest/koishi-plugin-mahjongpub 0.2.0 → 0.2.2

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { Context, Dict, Schema, Service } from 'koishi';
 import { ContestAdmin, TeamAdmin } from './api';
+import { ContestManager } from './manager';
 declare module 'koishi' {
     interface Context {
         mahjongpub: MahjongPub;
@@ -39,6 +40,7 @@ export declare namespace MahjongPub {
         endpoint: string;
         batchInterval: number;
         batchCount: number;
+        manager: ContestManager.Config;
     }
     const Config: Schema<Config>;
 }

package/lib/index.js

@@ -28,13 +28,13 @@ var require_zh_CN = __commonJS({
 });
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  MahjongPub: () => MahjongPub,
-  default: () => src_default
+var index_exports = {};
+__export(index_exports, {
+  MahjongPub: () => MahjongPub2,
+  default: () => index_default
 });
-module.exports = __toCommonJS(src_exports);
-var import_koishi = require("koishi");
+module.exports = __toCommonJS(index_exports);
+var import_koishi3 = require("koishi");
 
 // src/api.ts
 var TeamAdmin = class {
@@ -79,7 +79,7 @@ var TeamAdmin = class {
       posttype: "update",
       t_pw: this.pw,
       t_ps: this.description,
-      cid: this.cid,
+      cid: String(this.cid),
       linkurl: this.img,
       team_type: this.ready ? "1" : "0",
       postdata: this.players.join("\n")
@@ -103,13 +103,14 @@ var ContestAdmin = class {
   }
   name;
   teams;
+  round;
   http;
   raw;
   async read(force = false) {
     if (this.teams && !force) return;
     const payload = {
       posttype: "login",
-      cid: this.cid,
+      cid: String(this.cid),
       c_pw: this.pw
     };
     const form = new FormData();
@@ -120,6 +121,7 @@ var ContestAdmin = class {
     if (!data?.c_admin?.cid) throw new Error("failed to read contest info");
     this.raw = data;
     this.name = data.c_admin.c_name;
+    this.round = data.c_admin.c_round;
     this.teams = Object.fromEntries(data.c_team.map((team) => [team.tid, {
       tid: team.tid,
       cid: this.cid,
@@ -129,10 +131,58 @@ var ContestAdmin = class {
       pw: team.t_pw
     }]));
   }
+  async getRounds() {
+    const data = await this.http.get("/api/data.php", {
+      params: {
+        t: "class",
+        cid: this.cid
+      }
+    });
+    const res = {};
+    data.forEach((round) => {
+      (res[round.round] ??= {})[round.t_class] = {
+        rid: round.rid,
+        round: round.round,
+        cls: round.t_class,
+        code: round.code,
+        tids: [round.tid1, round.tid2, round.tid3, round.tid4].filter(Boolean)
+      };
+    });
+    return res;
+  }
+  async getRecords(round) {
+    const data = await this.http.get("/api/data.php", {
+      params: {
+        t: "c_data",
+        cid: this.cid,
+        r: round
+      }
+    });
+    const res = {};
+    Object.entries(data).forEach(([rid, rs]) => {
+      if (!rs.length) return;
+      res[rid] = rs.map((x) => ({
+        inx: x.inx,
+        cid: x.cid,
+        rowi: x.rowi,
+        players: [
+          { name: x.name1, num: x.num1, point: x.pint1 },
+          { name: x.name2, num: x.num2, point: x.pint2 },
+          { name: x.name3, num: x.num3, point: x.pint3 },
+          { name: x.name4, num: x.num4, point: x.pint4 }
+        ],
+        url: x.url,
+        rid: x.rid,
+        round: x.round,
+        time: x.i_time
+      }));
+    });
+    return res;
+  }
   async getRoundRecord(round, cls) {
     const payload = {
       type: "login",
-      cid: this.cid,
+      cid: String(this.cid),
       cls: String(cls),
       rnd: String(round)
     };
@@ -166,7 +216,7 @@ var ContestAdmin = class {
   async updateRoundRecord(record) {
     const payload = {
       type: "update",
-      cid: this.cid,
+      cid: String(this.cid),
       cls: String(record.cls),
       rnd: String(record.rnd),
       pw: this.pw
@@ -189,6 +239,229 @@ var ContestAdmin = class {
   }
 };
 
+// src/manager.ts
+var import_koishi2 = require("koishi");
+var import_lobby = require("@hieuzest/koishi-plugin-riichi-city/lobby");
+
+// src/mahjongpub.ts
+var import_koishi = require("koishi");
+var import_cachetools = require("@hieuzest/cachetools");
+var MahjongPub = class _MahjongPub {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.http = ctx.http.extend({});
+  }
+  static {
+    __name(this, "MahjongPub");
+  }
+  serverUri = "https://cdn.r-mj.com";
+  http;
+  async getContest(cid) {
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "admin",
+        cid
+      }
+    });
+  }
+  async getTeams(cid) {
+    return this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "team",
+        cid
+      }
+    }).then((teams) => (0, import_koishi.mapValues)(teams, (team) => ({
+      ...team,
+      players: [...team.t_player?.split(/\s+/) ?? [], ...team.t_sub?.split(/\s+/) ?? []]
+    })));
+  }
+  async getRounds(cid) {
+    return Object.fromEntries(await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "class",
+        cid
+      }
+    }).then((rounds) => rounds.map((round) => [round.rid, {
+      ...round,
+      tids: [round.tid1, round.tid2, round.tid3, round.tid4]
+    }])));
+  }
+  async getMatches(cid, round) {
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "c_data",
+        cid,
+        r: round
+      }
+    });
+  }
+  async getAllMatches(cid) {
+    const contest = await this.getContest(cid);
+    return await this.http.get(`${this.serverUri}/api/data.php`, {
+      params: {
+        t: "multi_log",
+        cid,
+        r: [...Array(contest.c_round).keys()].map((x) => x + 1).map((x) => x.toString()).join(",")
+      }
+    });
+  }
+  static cacheOptions = {
+    "getContest": {
+      maxAge: 120
+    },
+    "getRounds": {
+      maxAge: 60
+    },
+    "getTeams": {
+      maxAge: 30
+    },
+    "getMatches": {
+      maxAge: 120
+    },
+    "getAllMatches": {
+      maxAge: 300
+    }
+  };
+  static new(ctx) {
+    return (0, import_cachetools.ttlcachedClass)(new _MahjongPub(ctx), _MahjongPub.cacheOptions);
+  }
+};
+
+// src/manager.ts
+var ContestExtra = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.stopCls = /* @__PURE__ */ new Set();
+  }
+  static {
+    __name(this, "ContestExtra");
+  }
+  subscribers;
+  stopCls;
+  async broadcast(msg) {
+    this.subscribers.forEach((channel) => this.ctx.sendMessage(channel, msg).catch(import_koishi2.noop));
+  }
+};
+var ContestManager = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.mahjongpub = MahjongPub.new(ctx);
+    ctx.command("contest.manager", { authority: 3 }).action(import_koishi2.noop);
+    ctx.command("contest.manager.init").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").action(async ({ session, options }) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      this.extra[cid].subscribers.add(session.cid);
+      if (options.clear) this.extra[cid].stopCls.clear();
+      return "Finished.";
+    });
+    ctx.command("contest.manager.deinit").channelFields(["mahjongpub/bind-contest"]).option("clear", "-c").action(async ({ session, options }) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      this.extra[cid].subscribers.delete(session.cid);
+      return "Finished.";
+    });
+    ctx.command("contest.manager.start [cls:number]").channelFields(["mahjongpub/bind-contest"]).action(async ({ session }, cls) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized.";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      this.extra[cid].subscribers.add(session.cid);
+      if (cls) {
+        this.extra[cid].stopCls.delete(cls);
+        await this.startMatch(cid, cls);
+      } else {
+        this.extra[cid].stopCls.clear();
+        const contest = await this.mahjongpub.getContest(cid);
+        const rounds = await this.mahjongpub.getRounds(cid);
+        for (const r of Object.values(rounds)) {
+          if (r.round !== contest.c_round) continue;
+          await this.startMatch(cid, r.t_class);
+          await (0, import_koishi2.sleep)(1e3);
+        }
+      }
+    });
+    ctx.command("contest.manager.stop [cls:number]").channelFields(["mahjongpub/bind-contest"]).action(async ({ session }, cls) => {
+      const cid = +(session.channel["mahjongpub/bind-contest"] || 0);
+      if (!cid) return "Unauthorized/";
+      this.extra[cid] ??= new ContestExtra(ctx);
+      if (cls) {
+        this.extra[cid].stopCls.add(cls);
+      } else {
+        const contest = await this.mahjongpub.getContest(cid);
+        const rounds = await this.mahjongpub.getRounds(cid);
+        for (const r of Object.values(rounds)) {
+          if (r.round !== contest.c_round) continue;
+          this.extra[cid].stopCls.add(r.t_class);
+        }
+      }
+      return "Finished.";
+    });
+    ctx.server.post("/contest-manager/finished", async (kCtx) => {
+      if (config.token && kCtx.request.headers.authorization !== `Bearer ${config.token}`) {
+        kCtx.status = 403;
+        return true;
+      }
+      this.onMatchFinished(kCtx.request.body);
+      kCtx.status = 200;
+      return true;
+    });
+  }
+  static {
+    __name(this, "ContestManager");
+  }
+  static inject = ["server", "mahjong", "mahjong.database", "mahjongpub", "sendMessage"];
+  mahjongpub;
+  extra = /* @__PURE__ */ Object.create(null);
+  async startMatch(cid, cls, timeout, tag) {
+    tag ||= `${cls}组`;
+    if (this.extra[cid]?.stopCls.has(cls)) {
+      this.ctx.logger.info(`try starting match ${cid}-${cls}, but stopped`);
+      return;
+    }
+    this.ctx.logger.info(`try starting match ${cid}-${cls}, timeout ${timeout}`);
+    const contest = await this.mahjongpub.getContest(cid);
+    const rounds = await this.mahjongpub.getRounds(cid);
+    const teams = await this.mahjongpub.getTeams(cid);
+    const [lastRecord] = await this.ctx.mahjong.database.db("scoreboard").collection("matches").find({
+      cid: `${cid}`,
+      round: +contest.c_round,
+      cls
+    }).sort({ rowi: -1 }).limit(1).toArray();
+    if (lastRecord && !lastRecord._finished) {
+      this.extra[cid]?.broadcast(`[${tag}] 发现进行中的比赛，已忽略`);
+      return;
+    }
+    const rowi = lastRecord ? lastRecord.rowi + 1 : 0;
+    const round = Object.values(rounds).find((x) => x.round === contest.c_round && x.t_class === cls);
+    const players = round.tids.map((tid) => teams[tid].players[rowi]);
+    try {
+      await this.ctx["zx-dhs"].startMatch(+round.code, players.map((x, i) => import_lobby.Player.fromPattern(x, lastRecord ? lastRecord.results?.[i].num : 1e5)));
+      this.extra[cid]?.broadcast(`[${tag}] 成功：` + players.join("，"));
+    } catch (e) {
+      if (e instanceof import_lobby.PlayerNotFoundError) {
+        this.extra[cid]?.broadcast(`[${tag}] ` + e.message + ` <timeout=${timeout}>`);
+        if (timeout < 600) this.ctx.setTimeout(() => this.startMatch(cid, cls, timeout + 30), 30 * 1e3);
+      } else {
+        throw e;
+      }
+    }
+  }
+  async onMatchFinished(record) {
+    this.extra[record.cid]?.broadcast(`对局完成：
+` + record.results.map((x) => `${x.name} ${x.num}`).join("\n"));
+    await (0, import_koishi2.sleep)(2e3);
+    return this.startMatch(+record.cid, record.cls);
+  }
+};
+((ContestManager2) => {
+  ContestManager2.Config = import_koishi2.Schema.object({
+    token: import_koishi2.Schema.string()
+  });
+})(ContestManager || (ContestManager = {}));
+
 // src/index.ts
 function parsePlatform(target) {
   const index = target.startsWith("sandbox:") ? target.lastIndexOf(":") : target.indexOf(":");
@@ -197,10 +470,12 @@ function parsePlatform(target) {
   return [platform, id];
 }
 __name(parsePlatform, "parsePlatform");
-var MahjongPub = class {
+var MahjongPub2 = class extends import_koishi3.Service {
   constructor(ctx, config) {
+    super(ctx, "mahjongpub", true);
     this.ctx = ctx;
     this.config = config;
+    ctx.plugin(ContestManager, config.manager);
     ctx.i18n.define("zh-CN", require_zh_CN());
     ctx.model.extend("user", {
       "mahjongpub/bind-team": "string",
@@ -277,7 +552,7 @@ var MahjongPub = class {
       const team = await this.getTeam(pw);
       try {
         await team.read();
-        if (!img) return import_koishi.h.image(team.img);
+        if (!img) return import_koishi3.h.image(team.img);
         const url = await ctx.assets.upload("https://koishi.chat/logo.png", `${session.id}-${session.timestamp}.png`);
         team.img = url;
         return await team.write();
@@ -376,7 +651,17 @@ var MahjongPub = class {
         return session.text(".failed");
       }
     });
-    ctx.command("mahjongpub.contest.bind <cid:string> <cpw:string>", { authority: 4 }).option("channel", "-c <channel:channel>").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, cid, cpw) => {
+    ctx.command("mahjongpub.contest.bind <cid:string> [cpw:string]", { authority: 4 }).option("channel", "-c <channel:channel>").option("only", "-o").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, cid, cpw) => {
+      if (options.only) {
+        if (options.channel) {
+          ctx.database.setChannel(...parsePlatform(options.channel), {
+            "mahjongpub/bind-contest": cid
+          });
+        } else {
+          session.channel["mahjongpub/bind-contest"] = cid;
+        }
+        return "Finished.";
+      }
       const contest = await this.getContest(cid, cpw);
       try {
         await contest.read();
@@ -400,12 +685,27 @@ var MahjongPub = class {
       if (cid) return session.text(".success", [cid, cpw]);
       else return session.text(".failed");
     });
+    ctx.command("mahjongpub.contest.round [round:natural]", { authority: 3 }).channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session }, round) => {
+      const [cid, cpw] = [session.channel["mahjongpub/bind-contest"], session.channel["mahjongpub/bind-contestpw"]];
+      const contest = await this.getContest(cid, cpw);
+      try {
+        const rounds = await contest.getRounds();
+        const clss = rounds[round || contest.round];
+        return Object.entries(clss).map(([i, r]) => [
+          `[${i}]`,
+          r.tids.map((tid) => `${contest.teams[tid].name}`).join(" / ")
+        ].join(" ")).join("\n");
+      } catch (e) {
+        ctx.logger.warn(e);
+        return session.text(".failed");
+      }
+    });
     ctx.command("mahjongpub.contest.record.get <round:natural> <cls:natural>", { authority: 3 }).option("rowi", "-i <rowi:integer>").channelFields(["mahjongpub/bind-contest", "mahjongpub/bind-contestpw"]).action(async ({ session, options }, round, cls) => {
       const [cid, cpw] = [session.channel["mahjongpub/bind-contest"], session.channel["mahjongpub/bind-contestpw"]];
       const contest = await this.getContest(cid, cpw);
       try {
         const record = await contest.getRoundRecord(round, cls);
-        if ((0, import_koishi.isNullable)(options.rowi)) {
+        if ((0, import_koishi3.isNullable)(options.rowi)) {
           return record.matches.map((match, i) => `[${i}] ` + match.players.map((x) => `${x.name} ${x.point}`).join(" / ")).join("\n");
         } else if (record.matches.at(options.rowi ?? -1)) {
           return [
@@ -528,29 +828,30 @@ var MahjongPub = class {
     if (this.ctx.get("cache")) {
       let res2 = await this.ctx.cache.get("contests", cid);
       if (res2) return res2;
-      res2 = new ContestAdmin(this.ctx, cid, pw, this.config);
+      res2 = new ContestAdmin(this.ctx, +cid, pw, this.config);
       await res2.read();
       await this.ctx.cache.set("contests", cid, res2, 1e3 * 600);
       return res2;
     }
-    const res = new ContestAdmin(this.ctx, cid, pw, this.config);
+    const res = new ContestAdmin(this.ctx, +cid, pw, this.config);
     await res.read();
     return res;
   }
 };
-((MahjongPub2) => {
-  MahjongPub2.inject = {
+((MahjongPub3) => {
+  MahjongPub3.inject = {
     required: ["database"],
     optional: ["assets", "cache", "mahjong", "mahjong.database"]
   };
-  MahjongPub2.Config = import_koishi.Schema.object({
-    informNotbind: import_koishi.Schema.boolean().default(false),
-    endpoint: import_koishi.Schema.string().default("https://cdn.r-mj.com/"),
-    batchInterval: import_koishi.Schema.natural().default(300),
-    batchCount: import_koishi.Schema.natural().default(10)
+  MahjongPub3.Config = import_koishi3.Schema.object({
+    informNotbind: import_koishi3.Schema.boolean().default(false),
+    endpoint: import_koishi3.Schema.string().default("https://cdn.r-mj.com/"),
+    batchInterval: import_koishi3.Schema.natural().default(300),
+    batchCount: import_koishi3.Schema.natural().default(10),
+    manager: ContestManager.Config
   });
-})(MahjongPub || (MahjongPub = {}));
-var src_default = MahjongPub;
+})(MahjongPub2 || (MahjongPub2 = {}));
+var index_default = MahjongPub2;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MahjongPub

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hieuzest/koishi-plugin-mahjongpub",
   "description": "Mahjong.pub API",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -15,6 +15,10 @@
     "plugin"
   ],
   "peerDependencies": {
-    "koishi": "^4.17.1"
+    "koishi": "^4.17.1",
+    "@hieuzest/koishi-plugin-riichi-city": "^0.5.2"
+  },
+  "dependencies": {
+    "@hieuzest/cachetools": "^0.1.5"
   }
 }