Spaces:
Running
Running
| ; | |
| var __defProp = Object.defineProperty; | |
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | |
| var __getOwnPropNames = Object.getOwnPropertyNames; | |
| var __hasOwnProp = Object.prototype.hasOwnProperty; | |
| var __export = (target, all) => { | |
| for (var name in all) | |
| __defProp(target, name, { get: all[name], enumerable: true }); | |
| }; | |
| var __copyProps = (to, from, except, desc) => { | |
| if (from && typeof from === "object" || typeof from === "function") { | |
| for (let key of __getOwnPropNames(from)) | |
| if (!__hasOwnProp.call(to, key) && key !== except) | |
| __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | |
| } | |
| return to; | |
| }; | |
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | |
| var chatlog_exports = {}; | |
| __export(chatlog_exports, { | |
| DatabaseLogSearcher: () => DatabaseLogSearcher, | |
| FSLogSearcher: () => FSLogSearcher, | |
| LogReader: () => LogReader, | |
| LogReaderRoom: () => LogReaderRoom, | |
| LogSearcher: () => LogSearcher, | |
| LogViewer: () => LogViewer, | |
| RipgrepLogSearcher: () => RipgrepLogSearcher, | |
| Searcher: () => Searcher, | |
| commands: () => commands, | |
| pages: () => pages | |
| }); | |
| module.exports = __toCommonJS(chatlog_exports); | |
| var import_lib = require("../../lib"); | |
| var import_database = require("../../lib/database"); | |
| var import_roomlogs = require("../roomlogs"); | |
| /** | |
| * Pokemon Showdown log viewer | |
| * | |
| * by Zarel | |
| * @license MIT | |
| */ | |
| const DAY = 24 * 60 * 60 * 1e3; | |
| const MAX_MEMORY = 67108864; | |
| const MAX_TOPUSERS = 100; | |
| const UPPER_STAFF_ROOMS = ["upperstaff", "adminlog", "slowlog"]; | |
| class LogReaderRoom { | |
| constructor(roomid) { | |
| this.roomid = roomid; | |
| } | |
| async listMonths() { | |
| if (import_roomlogs.roomlogTable) { | |
| const dates = await import_roomlogs.roomlogTable.query()`SELECT DISTINCT month FROM roomlog_dates WHERE roomid = ${this.roomid}`; | |
| return dates.map((x) => x.month); | |
| } | |
| try { | |
| const listing = await Monitor.logPath(`chat/${this.roomid}`).readdir(); | |
| return listing.filter((file) => /^[0-9][0-9][0-9][0-9]-[0-9][0-9]$/.test(file)); | |
| } catch { | |
| return []; | |
| } | |
| } | |
| async listDays(month) { | |
| if (import_roomlogs.roomlogTable) { | |
| const dates = await import_roomlogs.roomlogTable.query()`SELECT DISTINCT date FROM roomlog_dates WHERE roomid = ${this.roomid} AND month = ${month}`; | |
| return dates.map((x) => x.date); | |
| } | |
| try { | |
| const listing = await Monitor.logPath(`chat/${this.roomid}/${month}`).readdir(); | |
| return listing.filter((file) => file.endsWith(".txt")).map((file) => file.slice(0, -4)); | |
| } catch { | |
| return []; | |
| } | |
| } | |
| async getLog(day) { | |
| if (import_roomlogs.roomlogTable) { | |
| const [dayStart, dayEnd] = LogReader.dayToRange(day); | |
| const logs = await import_roomlogs.roomlogTable.selectAll( | |
| ["log", "time"] | |
| )`WHERE roomid = ${this.roomid} AND time BETWEEN ${dayStart}::int::timestamp AND ${dayEnd}::int::timestamp`; | |
| return new import_lib.Streams.ObjectReadStream({ | |
| read() { | |
| for (const { log: log2, time } of logs) { | |
| this.buf.push(`${Chat.toTimestamp(time).split(" ")[1]} ${log2}`); | |
| } | |
| this.pushEnd(); | |
| } | |
| }); | |
| } | |
| const month = LogReader.getMonth(day); | |
| const log = Monitor.logPath(`chat/${this.roomid}/${month}/${day}.txt`); | |
| if (!await log.exists()) | |
| return null; | |
| return log.createReadStream().byLine(); | |
| } | |
| } | |
| const LogReader = new class { | |
| async get(roomid) { | |
| if (import_roomlogs.roomlogTable) { | |
| if (!await import_roomlogs.roomlogTable.selectOne()`WHERE roomid = ${roomid}`) | |
| return null; | |
| } else { | |
| if (!await Monitor.logPath(`chat/${roomid}`).exists()) | |
| return null; | |
| } | |
| return new LogReaderRoom(roomid); | |
| } | |
| async list() { | |
| if (import_roomlogs.roomlogTable) { | |
| const roomids = await import_roomlogs.roomlogTable.query()`SELECT DISTINCT roomid FROM roomlogs`; | |
| return roomids.map((x) => x.roomid); | |
| } | |
| const listing = await Monitor.logPath(`chat`).readdir(); | |
| return listing.filter((file) => /^[a-z0-9-]+$/.test(file)); | |
| } | |
| async listCategorized(user, opts) { | |
| const list = await this.list(); | |
| const isUpperStaff = user.can("rangeban"); | |
| const isStaff = user.can("lock"); | |
| const official = []; | |
| const normal = []; | |
| const hidden = []; | |
| const secret = []; | |
| const deleted = []; | |
| const personal = []; | |
| const deletedPersonal = []; | |
| let atLeastOne = false; | |
| for (const roomid of list) { | |
| const room = Rooms.get(roomid); | |
| const forceShow = room && (room.auth.has(user.id) && user.can("mute", null, room) || isStaff && user.inRooms.has(room.roomid)); | |
| if (!isUpperStaff && !forceShow) { | |
| if (!isStaff) | |
| continue; | |
| if (!room) | |
| continue; | |
| if (!room.checkModjoin(user)) | |
| continue; | |
| if (room.settings.isPrivate === true) | |
| continue; | |
| } | |
| atLeastOne = true; | |
| if (roomid.includes("-")) { | |
| const matchesOpts = opts && roomid.startsWith(`${opts}-`); | |
| if (matchesOpts || opts === "all" || forceShow) { | |
| (room ? personal : deletedPersonal).push(roomid); | |
| } | |
| } else if (!room) { | |
| if (opts === "all" || opts === "deleted") | |
| deleted.push(roomid); | |
| } else if (room.settings.section === "official") { | |
| official.push(roomid); | |
| } else if (!room.settings.isPrivate) { | |
| normal.push(roomid); | |
| } else if (room.settings.isPrivate === "hidden") { | |
| hidden.push(roomid); | |
| } else { | |
| secret.push(roomid); | |
| } | |
| } | |
| if (!atLeastOne) | |
| return null; | |
| return { official, normal, hidden, secret, deleted, personal, deletedPersonal }; | |
| } | |
| /** @returns [dayStart, dayEnd] as seconds (NOT milliseconds) since Unix epoch */ | |
| dayToRange(day) { | |
| const nextDay = LogReader.nextDay(day); | |
| return [ | |
| Math.trunc(new Date(day).getTime() / 1e3), | |
| Math.trunc(new Date(nextDay).getTime() / 1e3) | |
| ]; | |
| } | |
| /** @returns [monthStart, monthEnd] as seconds (NOT milliseconds) since Unix epoch */ | |
| monthToRange(month) { | |
| const nextMonth = LogReader.nextMonth(month); | |
| return [ | |
| Math.trunc(new Date(`${month}-01`).getTime() / 1e3), | |
| Math.trunc(new Date(`${nextMonth}-01`).getTime() / 1e3) | |
| ]; | |
| } | |
| getMonth(day) { | |
| if (!day) | |
| day = Chat.toTimestamp(new Date()).split(" ")[0]; | |
| return day.slice(0, 7); | |
| } | |
| nextDay(day) { | |
| const nextDay = new Date(new Date(day).getTime() + DAY); | |
| return nextDay.toISOString().slice(0, 10); | |
| } | |
| prevDay(day) { | |
| const prevDay = new Date(new Date(day).getTime() - DAY); | |
| return prevDay.toISOString().slice(0, 10); | |
| } | |
| nextMonth(month) { | |
| const nextMonth = new Date(new Date(`${month}-15`).getTime() + 30 * DAY); | |
| return nextMonth.toISOString().slice(0, 7); | |
| } | |
| prevMonth(month) { | |
| const prevMonth = new Date(new Date(`${month}-15`).getTime() - 30 * DAY); | |
| return prevMonth.toISOString().slice(0, 7); | |
| } | |
| today() { | |
| return Chat.toTimestamp(new Date()).slice(0, 10); | |
| } | |
| isMonth(text) { | |
| return /^[0-9]{4}-(?:0[0-9]|1[0-2])$/.test(text); | |
| } | |
| isDay(text) { | |
| return /^[0-9]{4}-(?:0[0-9]|1[0-2])-(?:[0-2][0-9]|3[0-1])$/.test(text); | |
| } | |
| }(); | |
| const LogViewer = new class { | |
| async day(roomid, day, opts) { | |
| const month = LogReader.getMonth(day); | |
| let buf = `<div class="pad"><p><a roomid="view-chatlog">\u25C2 All logs</a> / <a roomid="view-chatlog-${roomid}">${roomid}</a> / <a roomid="view-chatlog-${roomid}--${month}">${month}</a> / <strong>${day}</strong></p><small>${opts ? `Options in use: ${opts}` : ""}</small> <hr />`; | |
| const roomLog = await LogReader.get(roomid); | |
| if (!roomLog) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't exist</p></div>`; | |
| return this.linkify(buf); | |
| } | |
| const prevDay = LogReader.prevDay(day); | |
| const prevRoomid = `view-chatlog-${roomid}--${prevDay}${opts ? `--${opts}` : ""}`; | |
| buf += `<p><a roomid="${prevRoomid}" class="blocklink" style="text-align:center">\u25B2<br />${prevDay}</a></p><div class="message-log" style="overflow-wrap: break-word">`; | |
| const stream = await roomLog.getLog(day); | |
| if (!stream) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't have logs for ${day}</p>`; | |
| } else { | |
| for await (const line of stream) { | |
| for (const part of line.split("\n")) { | |
| buf += this.renderLine(part, opts, { roomid, date: day }); | |
| } | |
| } | |
| } | |
| buf += `</div>`; | |
| if (day !== LogReader.today()) { | |
| const nextDay = LogReader.nextDay(day); | |
| const nextRoomid = `view-chatlog-${roomid}--${nextDay}${opts ? `--${opts}` : ""}`; | |
| buf += `<p><a roomid="${nextRoomid}" class="blocklink" style="text-align:center">${nextDay}<br />\u25BC</a></p>`; | |
| } | |
| buf += `</div>`; | |
| return this.linkify(buf); | |
| } | |
| parseChatLine(line, day) { | |
| const [timestamp, type, ...rest] = line.split("|"); | |
| if (type === "c:") { | |
| const [time, username, ...message] = rest; | |
| return { time: new Date(time), username, message: message.join("|") }; | |
| } | |
| return { time: new Date(timestamp + day), username: rest[0], message: rest.join("|") }; | |
| } | |
| renderLine(fullLine, opts, data) { | |
| if (!fullLine) | |
| return ``; | |
| let timestamp = fullLine.slice(0, 8); | |
| let line; | |
| if (/^[0-9:]+$/.test(timestamp)) { | |
| line = fullLine.charAt(9) === "|" ? fullLine.slice(10) : "|" + fullLine.slice(9); | |
| } else { | |
| timestamp = ""; | |
| line = "!NT|"; | |
| } | |
| if (opts !== "all" && (line.startsWith(`userstats|`) || line.startsWith("J|") || line.startsWith("L|") || line.startsWith("N|"))) | |
| return ``; | |
| const getClass = (name) => { | |
| const stampNums = toID(timestamp); | |
| if (toID(opts) === stampNums) | |
| name += ` highlighted`; | |
| return `class="${name}" data-server="${stampNums}"`; | |
| }; | |
| if (opts === "txt") | |
| return import_lib.Utils.html`<div ${getClass("chat")}>${fullLine}</div>`; | |
| const cmd = line.slice(0, line.indexOf("|")); | |
| if (opts?.includes("onlychat")) { | |
| if (cmd !== "c") | |
| return ""; | |
| if (opts.includes("txt")) | |
| return `<div ${getClass("chat")}>${import_lib.Utils.escapeHTML(fullLine)}</div>`; | |
| } | |
| const timeLink = data ? `<a class="subtle" href="/view-chatlog-${data.roomid}--${data.date}--time-${timestamp}">${timestamp}</a>` : timestamp; | |
| switch (cmd) { | |
| case "c": { | |
| const [, name, message] = import_lib.Utils.splitFirst(line, "|", 2); | |
| if (name.length <= 1) { | |
| return `<div ${getClass("chat")}><small>[${timeLink}] </small><q>${Chat.formatText(message)}</q></div>`; | |
| } | |
| if (message.startsWith(`/log `)) { | |
| return `<div ${getClass("chat")}><small>[${timeLink}] </small><q>${Chat.formatText(message.slice(5))}</q></div>`; | |
| } | |
| if (message.startsWith(`/raw `)) { | |
| return `<div ${getClass("notice")}>${message.slice(5)}</div>`; | |
| } | |
| if (message.startsWith(`/uhtml `) || message.startsWith(`/uhtmlchange `)) { | |
| if (message.startsWith(`/uhtmlchange `)) | |
| return ``; | |
| if (opts !== "all") | |
| return `<div ${getClass("notice")}>[uhtml box hidden]</div>`; | |
| return `<div ${getClass("notice")}>${message.slice(message.indexOf(",") + 1)}</div>`; | |
| } | |
| const group = !name.startsWith(" ") ? name.charAt(0) : ``; | |
| return `<div ${getClass("chat")}><small>[${timeLink}]` + import_lib.Utils.html` ${group}</small><username>${name.slice(1)}:</username> ` + `<q>${Chat.formatText(message)}</q></div>`; | |
| } | |
| case "html": | |
| case "raw": { | |
| const [, html] = import_lib.Utils.splitFirst(line, "|", 1); | |
| return `<div ${getClass("notice")}>${html}</div>`; | |
| } | |
| case "uhtml": | |
| case "uhtmlchange": { | |
| if (cmd !== "uhtml") | |
| return ``; | |
| const [, , html] = import_lib.Utils.splitFirst(line, "|", 2); | |
| return `<div ${getClass("notice")}>${html}</div>`; | |
| } | |
| case "!NT": | |
| return `<div ${getClass("chat")}>${import_lib.Utils.escapeHTML(fullLine)}</div>`; | |
| case "": | |
| return `<div ${getClass("chat")}><small>[${timeLink}] </small>${import_lib.Utils.escapeHTML(line.slice(1))}</div>`; | |
| default: | |
| return `<div ${getClass("chat")}><small>[${timeLink}] </small><code>${"|" + import_lib.Utils.escapeHTML(line)}</code></div>`; | |
| } | |
| } | |
| async month(roomid, month) { | |
| let buf = `<div class="pad"><p><a roomid="view-chatlog">\u25C2 All logs</a> / <a roomid="view-chatlog-${roomid}">${roomid}</a> / <strong>${month}</strong></p><hr />`; | |
| const roomLog = await LogReader.get(roomid); | |
| if (!roomLog) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't exist</p></div>`; | |
| return this.linkify(buf); | |
| } | |
| const prevMonth = LogReader.prevMonth(month); | |
| buf += `<p><a roomid="view-chatlog-${roomid}--${prevMonth}" class="blocklink" style="text-align:center">\u25B2<br />${prevMonth}</a></p><div>`; | |
| const days = await roomLog.listDays(month); | |
| if (!days.length) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't have logs in ${month}</p></div>`; | |
| return this.linkify(buf); | |
| } else { | |
| for (const day of days) { | |
| buf += `<p>- <a roomid="view-chatlog-${roomid}--${day}">${day}</a> <small>`; | |
| for (const opt of ["txt", "onlychat", "all", "txt-onlychat"]) { | |
| buf += ` (<a roomid="view-chatlog-${roomid}--${day}--${opt}">${opt}</a>) `; | |
| } | |
| buf += `</small></p>`; | |
| } | |
| } | |
| if (!LogReader.today().startsWith(month)) { | |
| const nextMonth = LogReader.nextMonth(month); | |
| buf += `<p><a roomid="view-chatlog-${roomid}--${nextMonth}" class="blocklink" style="text-align:center">${nextMonth}<br />\u25BC</a></p>`; | |
| } | |
| buf += `</div>`; | |
| return this.linkify(buf); | |
| } | |
| async room(roomid) { | |
| let buf = `<div class="pad"><p><a roomid="view-chatlog">\u25C2 All logs</a> / <strong>${roomid}</strong></p><hr />`; | |
| const roomLog = await LogReader.get(roomid); | |
| if (!roomLog) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't exist</p></div>`; | |
| return this.linkify(buf); | |
| } | |
| const months = await roomLog.listMonths(); | |
| if (!months.length) { | |
| buf += `<p class="message-error">Room "${roomid}" doesn't have logs</p></div>`; | |
| return this.linkify(buf); | |
| } | |
| for (const month of months) { | |
| buf += `<p>- <a roomid="view-chatlog-${roomid}--${month}">${month}</a></p>`; | |
| } | |
| buf += `</div>`; | |
| return this.linkify(buf); | |
| } | |
| async list(user, opts) { | |
| let buf = `<div class="pad"><p><strong>All logs</strong></p><hr />`; | |
| const categories = { | |
| "official": "Official", | |
| "normal": "Public", | |
| "hidden": "Hidden", | |
| "secret": "Secret", | |
| "deleted": "Deleted", | |
| "personal": "Personal", | |
| "deletedPersonal": "Deleted Personal" | |
| }; | |
| const list = await LogReader.listCategorized(user, opts); | |
| if (!list) { | |
| buf += `<p class="message-error">You must be a staff member of a room to view its logs</p></div>`; | |
| return buf; | |
| } | |
| const showPersonalLink = opts !== "all" && user.can("rangeban"); | |
| for (const k in categories) { | |
| if (!list[k].length && !(["personal", "deleted"].includes(k) && showPersonalLink)) { | |
| continue; | |
| } | |
| buf += `<p>${categories[k]}</p>`; | |
| if (k === "personal" && showPersonalLink) { | |
| if (opts !== "help") | |
| buf += `<p>- <a roomid="view-chatlog--help">(show all help)</a></p>`; | |
| if (opts !== "groupchat") | |
| buf += `<p>- <a roomid="view-chatlog--groupchat">(show all groupchat)</a></p>`; | |
| } | |
| if (k === "deleted" && showPersonalLink) { | |
| if (opts !== "deleted") | |
| buf += `<p>- <a roomid="view-chatlog--deleted">(show deleted)</a></p>`; | |
| } | |
| for (const roomid of list[k]) { | |
| buf += `<p>- <a roomid="view-chatlog-${roomid}">${roomid}</a></p>`; | |
| } | |
| } | |
| buf += `</div>`; | |
| return this.linkify(buf); | |
| } | |
| error(message) { | |
| return `<div class="pad"><p class="message-error">${message}</p></div>`; | |
| } | |
| linkify(buf) { | |
| return buf.replace(/<a roomid="/g, `<a target="replace" href="/`); | |
| } | |
| }(); | |
| class Searcher { | |
| constructor() { | |
| this.roomstatsCache = /* @__PURE__ */ new Map(); | |
| } | |
| static checkEnabled() { | |
| if (global.Config.disableripgrep) { | |
| throw new Chat.ErrorMessage("Log searching functionality is currently disabled."); | |
| } | |
| } | |
| constructUserRegex(user) { | |
| const id = toID(user); | |
| return `.${[...id].join("[^a-zA-Z0-9]*")}[^a-zA-Z0-9]*`; | |
| } | |
| renderLinecountResults(results, roomid, month, user) { | |
| let buf = import_lib.Utils.html`<div class="pad"><h2>Linecounts on `; | |
| buf += `${roomid}${user ? ` for the user ${user}` : ` (top ${MAX_TOPUSERS})`}</h2>`; | |
| buf += `<strong>Total lines: {total}</strong><br />`; | |
| buf += `<strong>Month: ${month}</strong><br />`; | |
| const nextMonth = LogReader.nextMonth(month); | |
| const prevMonth = LogReader.prevMonth(month); | |
| if (Monitor.logPath(`chat/${roomid}/${prevMonth}`).existsSync()) { | |
| buf += `<small><a roomid="view-roomstats-${roomid}--${prevMonth}${user ? `--${user}` : ""}">Previous month</a></small>`; | |
| } | |
| if (Monitor.logPath(`chat/${roomid}/${nextMonth}`).existsSync()) { | |
| buf += ` <small><a roomid="view-roomstats-${roomid}--${nextMonth}${user ? `--${user}` : ""}">Next month</a></small>`; | |
| } | |
| if (!results) { | |
| buf += "<hr />"; | |
| buf += LogViewer.error(`Logs for month '${month}' do not exist on room ${roomid}.`); | |
| return buf; | |
| } else if (user) { | |
| buf += "<hr /><ol>"; | |
| const sortedDays = import_lib.Utils.sortBy(Object.keys(results)); | |
| let total = 0; | |
| for (const day of sortedDays) { | |
| const dayResults = results[day][user]; | |
| if (isNaN(dayResults)) | |
| continue; | |
| total += dayResults; | |
| buf += `<li>[<a roomid="view-chatlog-${roomid}--${day}">${day}</a>]: `; | |
| buf += `${Chat.count(dayResults, "lines")}</li>`; | |
| } | |
| buf = buf.replace("{total}", `${total}`); | |
| } else { | |
| buf += "<hr /><ol>"; | |
| const totalResults = {}; | |
| for (const date of import_lib.Utils.sortBy(Object.keys(results))) { | |
| for (const userid in results[date]) { | |
| if (!totalResults[userid]) | |
| totalResults[userid] = 0; | |
| totalResults[userid] += results[date][userid]; | |
| } | |
| } | |
| const resultKeys = Object.keys(totalResults); | |
| const sortedResults = import_lib.Utils.sortBy(resultKeys, (userid) => -totalResults[userid]).slice(0, MAX_TOPUSERS); | |
| let total = 0; | |
| for (const userid of sortedResults) { | |
| total += totalResults[userid]; | |
| buf += `<li><span class="username"><username>${userid}</username></span>: `; | |
| buf += `${Chat.count(totalResults[userid], "lines")}</li>`; | |
| } | |
| buf = buf.replace("{total}", `${total}`); | |
| } | |
| buf += `</div>`; | |
| return LogViewer.linkify(buf); | |
| } | |
| async runLinecountSearch(context, roomid, month, user) { | |
| context.setHTML( | |
| `<div class="pad"><h2>Searching linecounts on room ${roomid}${user ? ` for the user ${user}` : ""}.</h2></div>` | |
| ); | |
| context.setHTML(await LogSearcher.searchLinecounts(roomid, month, user)); | |
| } | |
| runSearch() { | |
| throw new Chat.ErrorMessage(`This functionality is currently disabled.`); | |
| } | |
| // this would normally be abstract, but it's very difficult with ripgrep | |
| // so it's easier to just do it the same way for both. | |
| async roomStats(room, month) { | |
| if (!Monitor.logPath(`chat/${room}`).existsSync()) { | |
| return LogViewer.error(import_lib.Utils.html`Room ${room} not found.`); | |
| } | |
| if (!Monitor.logPath(`chat/${room}/${month}`).existsSync()) { | |
| return LogViewer.error(import_lib.Utils.html`Room ${room} does not have logs for the month ${month}.`); | |
| } | |
| const stats = await LogSearcher.activityStats(room, month); | |
| let buf = `<div class="pad"><h2>Room stats for ${room} [${month}]</h2><hr />`; | |
| buf += `<strong>Total days with logs: ${stats.average.days}</strong><br />`; | |
| buf += this.visualizeStats(stats.average); | |
| buf += `<hr />`; | |
| buf += `<details class="readmore"><summary><strong>Stats by day</strong></summary>`; | |
| for (const day of stats.days) { | |
| buf += `<div class="infobox"><strong><a roomid="view-chatlog-${room}--${day.day}">${day.day}</a></strong><br />`; | |
| buf += this.visualizeStats(day); | |
| buf += `</div>`; | |
| } | |
| buf += "</details>"; | |
| return LogViewer.linkify(buf); | |
| } | |
| visualizeStats(stats) { | |
| const titles = { | |
| deadTime: "Average time between lines", | |
| deadPercent: "Average % of the day spent more than 5 minutes inactive", | |
| linesPerUser: "Average lines per user", | |
| averagePresent: "Average users present", | |
| totalLines: "Average lines per day" | |
| }; | |
| let buf = `<div class="ladder pad"><table><tr><th>`; | |
| buf += Object.values(titles).join("</th><th>"); | |
| buf += `</th></tr><tr>`; | |
| for (const k in titles) { | |
| buf += `<td>`; | |
| switch (k) { | |
| case "deadTime": | |
| buf += Chat.toDurationString(stats.deadTime, { precision: 2 }); | |
| break; | |
| case "linesPerUser": | |
| case "totalLines": | |
| case "averagePresent": | |
| case "deadPercent": | |
| buf += (stats[k] || 0).toFixed(2); | |
| break; | |
| } | |
| buf += `</td>`; | |
| } | |
| buf += `</tr></table></div>`; | |
| return buf; | |
| } | |
| } | |
| class FSLogSearcher extends Searcher { | |
| constructor() { | |
| super(); | |
| this.results = 0; | |
| } | |
| async searchLinecounts(roomid, month, user) { | |
| const directory = Monitor.logPath(`chat/${roomid}/${month}`); | |
| if (!directory.existsSync()) { | |
| return this.renderLinecountResults(null, roomid, month, user); | |
| } | |
| const files = await directory.readdir(); | |
| const results = {}; | |
| for (const file of files) { | |
| const day = file.slice(0, -4); | |
| const stream = Monitor.logPath(`chat/${roomid}/${month}/${file}`).createReadStream(); | |
| for await (const line of stream.byLine()) { | |
| const parts = line.split("|").map(toID); | |
| const id = parts[2]; | |
| if (!id) | |
| continue; | |
| if (parts[1] === "c") { | |
| if (user && id !== user) | |
| continue; | |
| if (!results[day]) | |
| results[day] = {}; | |
| if (!results[day][id]) | |
| results[day][id] = 0; | |
| results[day][id]++; | |
| } | |
| } | |
| } | |
| return this.renderLinecountResults(results, roomid, month, user); | |
| } | |
| async dayStats(room, day) { | |
| const cached = this.roomstatsCache.get(room + "-" + day); | |
| if (cached) | |
| return cached; | |
| const results = { | |
| deadTime: 0, | |
| deadPercent: 0, | |
| lines: {}, | |
| users: {}, | |
| days: 1, | |
| // irrelevant | |
| linesPerUser: 0, | |
| totalLines: 0, | |
| averagePresent: 0, | |
| day | |
| }; | |
| const path = Monitor.logPath(`chat/${room}/${LogReader.getMonth(day)}/${day}.txt`); | |
| if (!path.existsSync()) | |
| return false; | |
| const stream = path.createReadStream(); | |
| let lastTime = new Date(day).getTime(); | |
| let userstatCount = 0; | |
| const waitIncrements = []; | |
| for await (const line of stream.byLine()) { | |
| const [, type, ...rest] = line.split("|"); | |
| switch (type) { | |
| case "J": | |
| case "j": { | |
| if (rest[0]?.startsWith("*")) | |
| continue; | |
| const userid = toID(rest[0]); | |
| if (!results.users[userid]) { | |
| results.users[userid] = 0; | |
| } | |
| results.users[userid]++; | |
| break; | |
| } | |
| case "c:": | |
| case "c": { | |
| const { time, username } = LogViewer.parseChatLine(line, day); | |
| const curTime = time.getTime(); | |
| if (curTime - lastTime > 5 * 60 * 1e3) { | |
| waitIncrements.push(curTime - lastTime); | |
| lastTime = curTime; | |
| } | |
| const userid = toID(username); | |
| if (!results.lines[userid]) | |
| results.lines[userid] = 0; | |
| results.lines[userid]++; | |
| results.totalLines++; | |
| break; | |
| } | |
| case "userstats": { | |
| const [rawTotal] = rest; | |
| const total = parseInt(rawTotal.split(":")[1]); | |
| results.averagePresent += total; | |
| userstatCount++; | |
| break; | |
| } | |
| } | |
| } | |
| results.deadTime = waitIncrements.length ? this.calculateDead(waitIncrements) : 0; | |
| results.deadPercent = !results.totalLines ? 100 : waitIncrements.length / results.totalLines * 100; | |
| results.linesPerUser = results.totalLines / Object.keys(results.users).length || 0; | |
| results.averagePresent /= userstatCount; | |
| if (day !== LogReader.today()) { | |
| this.roomstatsCache.set(room + "-" + day, results); | |
| } | |
| return results; | |
| } | |
| calculateDead(waitIncrements) { | |
| let num = 0; | |
| for (const k of waitIncrements) { | |
| num += k; | |
| } | |
| return num / waitIncrements.length; | |
| } | |
| async activityStats(room, month) { | |
| const days = (await Monitor.logPath(`chat/${room}/${month}`).readdir()).map((f) => f.slice(0, -4)); | |
| const stats = []; | |
| const today = Chat.toTimestamp(new Date()).split(" ")[0]; | |
| for (const day of days) { | |
| if (day === today) { | |
| continue; | |
| } | |
| const curStats = await this.dayStats(room, day); | |
| if (!curStats) | |
| continue; | |
| stats.push(curStats); | |
| } | |
| const collected = { | |
| deadTime: 0, | |
| deadPercent: 0, | |
| lines: {}, | |
| users: {}, | |
| days: days.length, | |
| linesPerUser: 0, | |
| totalLines: 0, | |
| averagePresent: 0 | |
| }; | |
| for (const entry of stats) { | |
| for (const k of ["deadTime", "deadPercent", "linesPerUser", "totalLines", "averagePresent"]) { | |
| collected[k] += entry[k]; | |
| } | |
| for (const type of ["lines"]) { | |
| for (const k in entry[type]) { | |
| if (!collected[type][k]) | |
| collected[type][k] = 0; | |
| collected[type][k] += entry[type][k]; | |
| } | |
| } | |
| } | |
| for (const k of ["deadTime", "deadPercent", "linesPerUser", "totalLines", "averagePresent"]) { | |
| collected[k] /= stats.length; | |
| } | |
| return { average: collected, days: stats }; | |
| } | |
| } | |
| class RipgrepLogSearcher extends FSLogSearcher { | |
| async ripgrepSearchMonth(opts) { | |
| const { search, room: roomid, date: month, args } = opts; | |
| let results; | |
| let lineCount = 0; | |
| if (Config.disableripgrep) { | |
| return { lineCount: 0, results: [] }; | |
| } | |
| const resultSep = args?.includes("-m") ? "--" : "\n"; | |
| try { | |
| const options = [ | |
| "-e", | |
| search, | |
| Monitor.logPath(`chat/${roomid}/${month}`).path, | |
| "-i" | |
| ]; | |
| if (args) { | |
| options.push(...args); | |
| } | |
| const { stdout } = await import_lib.ProcessManager.exec(["rg", ...options], { | |
| maxBuffer: MAX_MEMORY, | |
| cwd: import_lib.FS.ROOT_PATH | |
| }); | |
| results = stdout.split(resultSep); | |
| } catch (e) { | |
| if (e.code !== 1 && !e.message.includes("stdout maxBuffer") && !e.message.includes("No such file or directory")) { | |
| throw e; | |
| } | |
| if (e.stdout) { | |
| results = e.stdout.split(resultSep); | |
| } else { | |
| results = []; | |
| } | |
| } | |
| lineCount += results.length; | |
| return { results, lineCount }; | |
| } | |
| async searchLinecounts(room, month, user) { | |
| const regexString = (user ? `\\|c\\|${this.constructUserRegex(user)}\\|` : `\\|c\\|([^|]+)\\|`) + `(?!\\/uhtml(change)?)`; | |
| const args = user ? ["--count"] : []; | |
| args.push(`--pcre2`); | |
| const { results: rawResults } = await this.ripgrepSearchMonth({ | |
| search: regexString, | |
| raw: true, | |
| date: month, | |
| room, | |
| args | |
| }); | |
| const results = {}; | |
| for (const fullLine of rawResults) { | |
| const [data, line] = fullLine.split(".txt:"); | |
| const date = data.split("/").pop(); | |
| if (!results[date]) | |
| results[date] = {}; | |
| if (!toID(date)) | |
| continue; | |
| if (user) { | |
| if (!results[date][user]) | |
| results[date][user] = 0; | |
| const parsed = parseInt(line); | |
| results[date][user] += isNaN(parsed) ? 0 : parsed; | |
| } else { | |
| const parts = line?.split("|").map(toID); | |
| if (!parts || parts[1] !== "c") | |
| continue; | |
| const id = parts[2]; | |
| if (!id) | |
| continue; | |
| if (!results[date][id]) | |
| results[date][id] = 0; | |
| results[date][id]++; | |
| } | |
| } | |
| return this.renderLinecountResults(results, room, month, user); | |
| } | |
| } | |
| class DatabaseLogSearcher extends Searcher { | |
| async searchLinecounts(roomid, month, user) { | |
| user = toID(user); | |
| if (!Rooms.Roomlogs.table) | |
| throw new Error(`Database search made while database is disabled.`); | |
| const results = {}; | |
| const [monthStart, monthEnd] = LogReader.monthToRange(month); | |
| const rows = await Rooms.Roomlogs.table.selectAll()` | |
| WHERE ${user ? import_database.SQL`userid = ${user} AND ` : import_database.SQL``}roomid = ${roomid} AND | |
| time BETWEEN ${monthStart}::int::timestamp AND ${monthEnd}::int::timestamp AND | |
| type = ${"c"} | |
| `; | |
| for (const row of rows) { | |
| if (!row.userid) | |
| continue; | |
| const day = Chat.toTimestamp(row.time).split(" ")[0]; | |
| if (!results[day]) | |
| results[day] = {}; | |
| if (!results[day][row.userid]) | |
| results[day][row.userid] = 0; | |
| results[day][row.userid]++; | |
| } | |
| return this.renderLinecountResults(results, roomid, month, user); | |
| } | |
| activityStats(room, month) { | |
| throw new Chat.ErrorMessage("This is not yet implemented for the new logs database."); | |
| } | |
| } | |
| const LogSearcher = new (Rooms.Roomlogs.table ? DatabaseLogSearcher : ( | |
| // no db, determine fs reader type. | |
| Config.chatlogreader === "ripgrep" ? RipgrepLogSearcher : FSLogSearcher | |
| ))(); | |
| const accessLog = Monitor.logPath(`chatlog-access.txt`).createAppendStream(); | |
| const pages = { | |
| async chatlog(args, user, connection) { | |
| if (!user.named) | |
| return Rooms.RETRY_AFTER_LOGIN; | |
| let [roomid, date, opts] = import_lib.Utils.splitFirst(args.join("-"), "--", 2); | |
| if (!roomid || roomid.startsWith("-")) { | |
| this.title = "[Logs]"; | |
| return LogViewer.list(user, roomid?.slice(1)); | |
| } | |
| this.title = "[Logs] " + roomid; | |
| const room = Rooms.get(roomid); | |
| if (!user.trusted) { | |
| if (room) { | |
| this.checkCan("declare", null, room); | |
| } else { | |
| return this.errorReply(`Access denied.`); | |
| } | |
| } | |
| if (!user.can("rangeban")) { | |
| if (roomid.startsWith("spl") && roomid !== "splatoon") { | |
| return this.errorReply("SPL team discussions are super secret."); | |
| } | |
| if (roomid.startsWith("wcop")) { | |
| return this.errorReply("WCOP team discussions are super secret."); | |
| } | |
| if (UPPER_STAFF_ROOMS.includes(roomid) && !user.inRooms.has(roomid)) { | |
| return this.errorReply("Upper staff rooms are super secret."); | |
| } | |
| } | |
| if (room) { | |
| if (!user.can("lock") || room.settings.isPrivate === "hidden" && !room.checkModjoin(user)) { | |
| if (!room.persist) | |
| return this.errorReply(`Access denied.`); | |
| this.checkCan("mute", null, room); | |
| } | |
| } else { | |
| this.checkCan("lock"); | |
| } | |
| void accessLog.writeLine(`${user.id}: <${roomid}> ${date}`); | |
| if (!date) { | |
| return LogViewer.room(roomid); | |
| } | |
| date = date.trim(); | |
| let search; | |
| const parsedDate = new Date(date); | |
| const validDateStrings = ["all", "alltime"]; | |
| const validNonDateTerm = search ? validDateStrings.includes(date) : date === "today"; | |
| if (isNaN(parsedDate.getTime()) && !validNonDateTerm) { | |
| return this.errorReply(`Invalid date.`); | |
| } | |
| const isTime = opts?.startsWith("time-"); | |
| if (isTime && opts) | |
| opts = toID(opts.slice(5)); | |
| if (search) { | |
| Searcher.checkEnabled(); | |
| this.checkCan("bypassall"); | |
| return LogSearcher.runSearch(); | |
| } else { | |
| if (date === "today") { | |
| this.setHTML(await LogViewer.day(roomid, LogReader.today(), opts)); | |
| if (isTime) | |
| this.send(`|scroll|div[data-server="${opts}"]`); | |
| } else if (date.split("-").length === 3) { | |
| this.setHTML(await LogViewer.day(roomid, parsedDate.toISOString().slice(0, 10), opts)); | |
| if (isTime) | |
| this.send(`|scroll|div[data-server="${opts}"]`); | |
| } else { | |
| return LogViewer.month(roomid, parsedDate.toISOString().slice(0, 7)); | |
| } | |
| } | |
| }, | |
| roomstats(args, user) { | |
| Searcher.checkEnabled(); | |
| const room = this.extractRoom(); | |
| if (room) { | |
| this.checkCan("mute", null, room); | |
| } else { | |
| if (!user.can("bypassall")) { | |
| return this.errorReply(`You cannot view logs for rooms that no longer exist.`); | |
| } | |
| } | |
| const [, date, target] = import_lib.Utils.splitFirst(args.join("-"), "--", 3).map((item) => item.trim()); | |
| if (isNaN(new Date(date).getTime())) { | |
| return this.errorReply(`Invalid date.`); | |
| } | |
| if (!LogReader.isMonth(date)) { | |
| return this.errorReply(`You must specify an exact month - both a year and a month.`); | |
| } | |
| this.title = `[Log Stats] ${date}`; | |
| return LogSearcher.runLinecountSearch(this, room ? room.roomid : args[2], date, toID(target)); | |
| }, | |
| async logsaccess(query) { | |
| this.checkCan("rangeban"); | |
| const type = toID(query.shift()); | |
| if (type && !["chat", "battle", "all", "battles"].includes(type)) { | |
| return this.errorReply(`Invalid log type.`); | |
| } | |
| let title = ""; | |
| switch (type) { | |
| case "battle": | |
| case "battles": | |
| title = "Battlelog access log"; | |
| break; | |
| case "chat": | |
| title = "Chatlog access log"; | |
| break; | |
| default: | |
| title = "Logs access log"; | |
| break; | |
| } | |
| const userid = toID(query.shift()); | |
| let buf = `<div class="pad"><h2>${title}`; | |
| if (userid) | |
| buf += ` for ${userid}`; | |
| buf += `</h2><hr /><ol>`; | |
| const accessStream = Monitor.logPath(`chatlog-access.txt`).createReadStream(); | |
| for await (const line of accessStream.byLine()) { | |
| const [id, rest] = import_lib.Utils.splitFirst(line, ": "); | |
| if (userid && id !== userid) | |
| continue; | |
| if (type === "battle" && !line.includes("battle-")) | |
| continue; | |
| if (userid) { | |
| buf += `<li>${rest}</li>`; | |
| } else { | |
| buf += `<li><username>${id}</username>: ${rest}</li>`; | |
| } | |
| } | |
| buf += `</ol>`; | |
| return buf; | |
| }, | |
| roominfo(query, user) { | |
| this.checkCan("rangeban"); | |
| const args = import_lib.Utils.splitFirst(query.join("-"), "--", 2); | |
| const roomid = toID(args.shift()); | |
| if (!roomid) { | |
| return this.errorReply(`Specify a room.`); | |
| } | |
| const date = args.shift() || LogReader.getMonth(); | |
| this.title = `[${roomid}] Activity Stats (${date})`; | |
| this.setHTML(`<div class="pad">Collecting stats for ${roomid} in ${date}...</div>`); | |
| return LogSearcher.roomStats(roomid, date); | |
| } | |
| }; | |
| const commands = { | |
| chatlogs: "chatlog", | |
| cl: "chatlog", | |
| roomlog: "chatlog", | |
| rl: "chatlog", | |
| roomlogs: "chatlog", | |
| chatlog(target, room, user) { | |
| const [tarRoom, ...opts] = target.split(","); | |
| const targetRoom = tarRoom ? Rooms.search(tarRoom) : room; | |
| const roomid = targetRoom ? targetRoom.roomid : target; | |
| return this.parse(`/join view-chatlog-${roomid}--today${opts ? `--${opts.map(toID).join("--")}` : ""}`); | |
| }, | |
| chatloghelp() { | |
| const strings = [ | |
| `/chatlog [optional room], [opts] - View chatlogs from the given room. `, | |
| `If none is specified, shows logs from the room you're in. Requires: % @ * # ~`, | |
| `Supported options:`, | |
| `<code>txt</code> - Do not render logs.`, | |
| `<code>txt-onlychat</code> - Show only chat lines, untransformed.`, | |
| `<code>onlychat</code> - Show only chat lines.`, | |
| `<code>all</code> - Show all lines, including userstats and join/leave messages.` | |
| ]; | |
| this.runBroadcast(); | |
| return this.sendReplyBox(strings.join("<br />")); | |
| }, | |
| sl: "searchlogs", | |
| logsearch: "searchlogs", | |
| searchlog: "searchlogs", | |
| searchlogs(target, room) { | |
| target = target.trim(); | |
| const args = target.split(",").map((item) => item.trim()); | |
| if (!target) | |
| return this.parse("/help searchlogs"); | |
| let date = "all"; | |
| const searches = []; | |
| let limit = "500"; | |
| let targetRoom = room?.roomid; | |
| for (const arg of args) { | |
| if (arg.startsWith("room=")) { | |
| targetRoom = arg.slice(5).trim().toLowerCase(); | |
| } else if (arg.startsWith("limit=")) { | |
| limit = arg.slice(6); | |
| } else if (arg.startsWith("date=")) { | |
| date = arg.slice(5); | |
| } else if (arg.startsWith("user=")) { | |
| args.push(`user-${toID(arg.slice(5))}`); | |
| } else { | |
| searches.push(arg); | |
| } | |
| } | |
| if (!targetRoom) { | |
| return this.parse(`/help searchlogs`); | |
| } | |
| return this.parse( | |
| `/join view-chatlog-${targetRoom}--${date}--search-${import_lib.Dashycode.encode(searches.join("+"))}--limit-${limit}` | |
| ); | |
| }, | |
| searchlogshelp() { | |
| const buffer = `<details class="readmore"><summary><code>/searchlogs [arguments]</code>: searches logs in the current room using the <code>[arguments]</code>.</summary>A room can be specified using the argument <code>room=[roomid]</code>. Defaults to the room it is used in.<br />A limit can be specified using the argument <code>limit=[number less than or equal to 3000]</code>. Defaults to 500.<br />A date can be specified in ISO (YYYY-MM-DD) format using the argument <code>date=[month]</code> (for example, <code>date: 2020-05</code>). Defaults to searching all logs.<br />If you provide a user argument in the form <code>user=username</code>, it will search for messages (that match the other arguments) only from that user.<br />All other arguments will be considered part of the search (if more than one argument is specified, it searches for lines containing all terms).<br />Requires: ~</div>`; | |
| return this.sendReplyBox(buffer); | |
| }, | |
| topusers: "linecount", | |
| roomstats: "linecount", | |
| linecount(target, room, user) { | |
| const params = target.split(",").map((f) => f.trim()); | |
| const search = {}; | |
| for (const [i, param] of params.entries()) { | |
| let [key, val] = param.split("="); | |
| if (!val) { | |
| switch (i) { | |
| case 0: | |
| val = key; | |
| key = "room"; | |
| break; | |
| case 1: | |
| val = key; | |
| key = "date"; | |
| break; | |
| case 2: | |
| val = key; | |
| key = "user"; | |
| break; | |
| default: | |
| return this.parse(`/help linecount`); | |
| } | |
| } | |
| if (!toID(val)) | |
| continue; | |
| key = key.toLowerCase().replace(/ /g, ""); | |
| switch (key) { | |
| case "room": | |
| case "roomid": | |
| const tarRoom = Rooms.search(val); | |
| if (!tarRoom) { | |
| return this.errorReply(`Room '${val}' not found.`); | |
| } | |
| search.roomid = tarRoom.roomid; | |
| break; | |
| case "user": | |
| case "id": | |
| case "userid": | |
| search.user = toID(val); | |
| break; | |
| case "date": | |
| case "month": | |
| case "time": | |
| if (!LogReader.isMonth(val)) { | |
| return this.errorReply(`Invalid date.`); | |
| } | |
| search.date = val; | |
| } | |
| } | |
| if (!search.roomid) { | |
| if (!room) { | |
| return this.errorReply(`If you're not specifying a room, you must use this command in a room.`); | |
| } | |
| search.roomid = room.roomid; | |
| } | |
| if (!search.date) { | |
| search.date = LogReader.getMonth(); | |
| } | |
| return this.parse(`/join view-roomstats-${search.roomid}--${search.date}${search.user ? `--${search.user}` : ""}`); | |
| }, | |
| linecounthelp() { | |
| return this.sendReplyBox( | |
| `<code>/linecount OR /roomstats OR /topusers</code> [<code>key=value</code> formatted parameters] - Searches linecounts with the given parameters.<br /><details class="readmore"><summary><strong>Parameters:</strong></summary>- <code>room</code> (aliases: <code>roomid</code>) - Select a room to search. If no room is given, defaults to current room.<br />- <code>date</code> (aliases: <code>month</code>, <code>time</code>) - Select a month to search linecounts on (requires YYYY-MM format). Defaults to current month.<br />- <code>user</code> (aliases: <code>id</code>, <code>userid</code>) - Searches for linecounts only from a given user. If this is not provided, /linecount instead shows line counts for all users from that month.</details>Parameters may also be specified without a [key]. When using this, arguments are provided in the format <code>/linecount [room], [month], [user].</code>. This does not use any defaults.<br />` | |
| ); | |
| }, | |
| battlelog(target, room, user) { | |
| this.checkCan("lock"); | |
| target = target.trim(); | |
| if (!target) | |
| return this.errorReply(`Specify a battle.`); | |
| if (target.startsWith("http://")) | |
| target = target.slice(7); | |
| if (target.startsWith("https://")) | |
| target = target.slice(8); | |
| if (target.startsWith(`${Config.routes.client}/`)) | |
| target = target.slice(Config.routes.client.length + 1); | |
| if (target.startsWith(`${Config.routes.replays}/`)) | |
| target = `battle-${target.slice(Config.routes.replays.length + 1)}`; | |
| if (target.startsWith("psim.us/")) | |
| target = target.slice(8); | |
| return this.parse(`/join view-battlelog-${target}`); | |
| }, | |
| battleloghelp: [ | |
| `/battlelog [battle link] - View the log of the given [battle link], even if the replay was not saved.`, | |
| `Requires: % @ ~` | |
| ], | |
| gbc: "getbattlechat", | |
| async getbattlechat(target, room, user) { | |
| this.checkCan("lock"); | |
| let [roomName, userName] = import_lib.Utils.splitFirst(target, ",").map((f) => f.trim()); | |
| if (!roomName) { | |
| if (!room) { | |
| return this.errorReply(`If you are not specifying a room, use this command in a room.`); | |
| } | |
| roomName = room.roomid; | |
| } | |
| if (roomName.startsWith("http://")) | |
| roomName = roomName.slice(7); | |
| if (roomName.startsWith("https://")) | |
| roomName = roomName.slice(8); | |
| if (roomName.startsWith(`${Config.routes.client}/`)) { | |
| roomName = roomName.slice(Config.routes.client.length + 1); | |
| } | |
| if (roomName.startsWith(`${Config.routes.replays}/`)) { | |
| roomName = `battle-${roomName.slice(Config.routes.replays.length + 1)}`; | |
| } | |
| if (roomName.startsWith("psim.us/")) | |
| roomName = roomName.slice(8); | |
| const queryStringStart = roomName.indexOf("?"); | |
| if (queryStringStart > -1) { | |
| roomName = roomName.slice(0, queryStringStart); | |
| } | |
| const roomid = roomName.toLowerCase().replace(/[^a-z0-9-]+/g, ""); | |
| if (!roomid) | |
| return this.parse("/help getbattlechat"); | |
| const userid = toID(userName); | |
| if (userName && !userid) | |
| return this.errorReply(`Invalid username.`); | |
| if (!roomid.startsWith("battle-")) | |
| return this.errorReply(`You must specify a battle.`); | |
| const tarRoom = Rooms.get(roomid); | |
| let log; | |
| if (tarRoom) { | |
| log = tarRoom.log.log; | |
| } else if (Rooms.Replays.db) { | |
| let battleId = roomid.replace("battle-", ""); | |
| if (battleId.endsWith("pw")) { | |
| battleId = battleId.slice(0, battleId.lastIndexOf("-", battleId.length - 2)); | |
| } | |
| const replayData = await Rooms.Replays.get(battleId); | |
| if (!replayData) { | |
| return this.errorReply(`No room or replay found for that battle.`); | |
| } | |
| log = replayData.log.split("\n"); | |
| } else { | |
| try { | |
| const raw = await (0, import_lib.Net)(`https://${Config.routes.replays}/${roomid.slice("battle-".length)}.json`).get(); | |
| const data = JSON.parse(raw); | |
| log = data.log ? data.log.split("\n") : []; | |
| } catch { | |
| return this.errorReply(`No room or replay found for that battle.`); | |
| } | |
| } | |
| log = log.filter((l) => l.startsWith("|c|")); | |
| let buf = ""; | |
| let atLeastOne = false; | |
| let i = 0; | |
| for (const line of log) { | |
| const [, , username, message] = import_lib.Utils.splitFirst(line, "|", 3); | |
| if (userid && toID(username) !== userid) | |
| continue; | |
| i++; | |
| buf += import_lib.Utils.html`<div class="chat"><span class="username"><username>${username}:</username></span> ${message}</div>`; | |
| atLeastOne = true; | |
| } | |
| if (i > 20) | |
| buf = `<details class="readmore">${buf}</details>`; | |
| if (!atLeastOne) | |
| buf = `<br />None found.`; | |
| this.runBroadcast(); | |
| return this.sendReplyBox( | |
| import_lib.Utils.html`<strong>Chat messages in the battle '${roomid}'` + (userid ? `from the user '${userid}'` : "") + `</strong>` + buf | |
| ); | |
| }, | |
| getbattlechathelp: [ | |
| `/getbattlechat [battle link][, username] - Gets all battle chat logs from the given [battle link].`, | |
| `If a [username] is given, searches only chat messages from the given username.`, | |
| `Requires: % @ ~` | |
| ], | |
| logsaccess(target, room, user) { | |
| this.checkCan("rangeban"); | |
| const [type, userid] = target.split(",").map(toID); | |
| return this.parse(`/j view-logsaccess-${type || "all"}${userid ? `-${userid}` : ""}`); | |
| }, | |
| logsaccesshelp: [ | |
| `/logsaccess [type], [user] - View chatlog access logs for the given [type] and [user].`, | |
| `If no arguments are given, shows the entire access log.`, | |
| `Requires: ~` | |
| ], | |
| gcsearch: "groupchatsearch", | |
| async groupchatsearch(target, room, user) { | |
| this.checkCan("lock"); | |
| target = target.toLowerCase().replace(/[^a-z0-9-]+/g, ""); | |
| if (!target) | |
| return this.parse(`/help groupchatsearch`); | |
| if (target.length < 3) { | |
| return this.errorReply(`Too short of a search term.`); | |
| } | |
| const files = await Monitor.logPath(`chat`).readdir(); | |
| const buffer = []; | |
| for (const roomid of files) { | |
| if (roomid.startsWith("groupchat-") && roomid.includes(target)) { | |
| buffer.push(roomid); | |
| } | |
| } | |
| import_lib.Utils.sortBy(buffer, (roomid) => !!Rooms.get(roomid)); | |
| return this.sendReplyBox( | |
| `Groupchats with a roomid matching '${target}': ` + (buffer.length ? buffer.map((id) => `<a href="/view-chatlog-${id}">${id}</a>`).join("; ") : "None found.") | |
| ); | |
| }, | |
| groupchatsearchhelp: [ | |
| `/groupchatsearch [target] - Searches for logs of groupchats with names containing the [target]. Requires: % @ ~` | |
| ], | |
| roomact: "roomactivity", | |
| roomactivity(target, room, user) { | |
| this.checkCan("bypassall"); | |
| const [id, date] = target.split(",").map((i) => i.trim()); | |
| if (id) | |
| room = Rooms.search(toID(id)); | |
| if (!room) | |
| return this.errorReply(`Either use this command in the target room or specify a room.`); | |
| return this.parse(`/join view-roominfo-${room}${date ? `--${date}` : ""}`); | |
| }, | |
| roomactivityhelp: [ | |
| `/roomactivity [room][, date] - View room activity logs for the given room.`, | |
| `If a date is provided, it searches for logs from that date. Otherwise, it searches the current month.`, | |
| `Requires: ~` | |
| ] | |
| }; | |
| //# sourceMappingURL=chatlog.js.map | |