Spaces:
Running
Running
| ; | |
| var __create = Object.create; | |
| var __defProp = Object.defineProperty; | |
| var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | |
| var __getOwnPropNames = Object.getOwnPropertyNames; | |
| var __getProtoOf = Object.getPrototypeOf; | |
| 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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | |
| // If the importer is in node compatibility mode or this is not an ESM | |
| // file that has been converted to a CommonJS file using a Babel- | |
| // compatible transform (i.e. "__esModule" has not been set), then set | |
| // "default" to the CommonJS "module.exports" for node compatibility. | |
| isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | |
| mod | |
| )); | |
| var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | |
| var converter_exports = {}; | |
| __export(converter_exports, { | |
| ModlogConverter: () => ModlogConverter, | |
| ModlogConverterSQLite: () => ModlogConverterSQLite, | |
| ModlogConverterTest: () => ModlogConverterTest, | |
| ModlogConverterTxt: () => ModlogConverterTxt, | |
| modernizeLog: () => modernizeLog, | |
| parseBrackets: () => parseBrackets, | |
| parseModlog: () => parseModlog, | |
| rawifyLog: () => rawifyLog | |
| }); | |
| module.exports = __toCommonJS(converter_exports); | |
| var import_lib = require("../../lib"); | |
| var import_ip_tools = require("../../server/ip-tools"); | |
| if (!global.Config) { | |
| let hasSQLite = true; | |
| try { | |
| require.resolve("better-sqlite3"); | |
| } catch { | |
| console.warn(`Warning: the modlog conversion script is running without a SQLite library.`); | |
| hasSQLite = false; | |
| } | |
| global.Config = { | |
| nofswriting: false, | |
| usesqlitemodlog: hasSQLite, | |
| usesqlite: hasSQLite | |
| }; | |
| } | |
| const Database = Config.usesqlite ? require("better-sqlite3") : null; | |
| const { Modlog } = require("../../server/modlog"); | |
| const ENTRIES_TO_BUFFER = 7500; | |
| const ALTS_REGEX = /\(.*?'s (lock|mut|bann|blacklist)ed alts: (.*)\)/; | |
| const AUTOCONFIRMED_REGEX = /\(.*?'s ac account: (.*)\)/; | |
| const IP_ONLY_ACTIONS = /* @__PURE__ */ new Set([ | |
| "SHAREDIP", | |
| "UNSHAREDIP", | |
| "UNLOCKIP", | |
| "UNLOCKRANGE", | |
| "RANGEBAN", | |
| "RANGELOCK" | |
| ]); | |
| function parseBrackets(line, openingBracket, greedy) { | |
| const brackets = { | |
| "(": ")", | |
| "[": "]" | |
| }; | |
| const bracketOpenIndex = line.indexOf(openingBracket); | |
| const bracketCloseIndex = greedy ? line.lastIndexOf(brackets[openingBracket]) : line.indexOf(brackets[openingBracket]); | |
| if (bracketCloseIndex < 0 || bracketOpenIndex < 0) | |
| return ""; | |
| return line.slice(bracketOpenIndex + 1, bracketCloseIndex); | |
| } | |
| function toID(text) { | |
| return (text && typeof text === "string" ? text : "").toLowerCase().replace(/[^a-z0-9]+/g, ""); | |
| } | |
| function modernizeLog(line, nextLine) { | |
| const prefix = line.match(/\[.+?\] \(.+?\) /i)?.[0]; | |
| if (!prefix) | |
| return; | |
| if (ALTS_REGEX.test(line) || AUTOCONFIRMED_REGEX.test(line)) | |
| return; | |
| line = line.replace(prefix, ""); | |
| if (line.startsWith("(")) | |
| line = line.replace(/\([a-z0-9-]*\) /, ""); | |
| if (line.startsWith("(") && line.endsWith(")")) { | |
| line = line.slice(1, -1); | |
| } | |
| const getAlts = () => { | |
| let alts = ""; | |
| nextLine?.replace(ALTS_REGEX, (_a, _b, rawAlts) => { | |
| if (rawAlts) | |
| alts = `alts: [${rawAlts.split(",").map(toID).join("], [")}] `; | |
| return ""; | |
| }); | |
| return alts; | |
| }; | |
| const getAutoconfirmed = () => { | |
| let autoconfirmed = ""; | |
| nextLine?.replace(AUTOCONFIRMED_REGEX, (_a, rawAutoconfirmed) => { | |
| if (rawAutoconfirmed) | |
| autoconfirmed = `ac: [${toID(rawAutoconfirmed)}] `; | |
| return ""; | |
| }); | |
| return autoconfirmed; | |
| }; | |
| if (line.startsWith("SCAV ")) { | |
| line = line.replace(/: (\[room: .*?\]) by (.*)/, (match, roominfo, rest) => `: by ${rest} ${roominfo}`); | |
| } | |
| line = line.replace( | |
| /(GIVEAWAY WIN|GTS FINISHED): ([A-Za-z0-9].*?)(won|has finished)/, | |
| (match, action, user) => `${action}: [${toID(user)}]:` | |
| ); | |
| if (line.includes(":")) { | |
| const possibleModernAction = line.slice(0, line.indexOf(":")).trim(); | |
| if (possibleModernAction === possibleModernAction.toUpperCase()) { | |
| if (possibleModernAction.includes("[")) { | |
| const [drop, ...keep] = line.split("["); | |
| process.stderr.write(`Ignoring malformed line: ${drop} | |
| `); | |
| return modernizeLog(keep.join("")); | |
| } | |
| if (/\(.+\) by [a-z0-9]{1,19}$/.test(line) && !["OLD MODLOG", "NOTE"].includes(possibleModernAction)) { | |
| const reason = parseBrackets(line, "(", true); | |
| return `${prefix}${line.replace(` (${reason})`, "")}: ${reason}`; | |
| } | |
| return `${prefix}${line}`; | |
| } | |
| } | |
| if (/\[(the|a)poll\] was (started|ended) by/.test(line)) { | |
| const actionTaker = toID(line.slice(line.indexOf(" by ") + " by ".length)); | |
| const isEnding = line.includes("was ended by"); | |
| return `${prefix}POLL${isEnding ? " END" : ""}: by ${actionTaker}`; | |
| } | |
| if (/User (.*?) won the game of (.*?) mode trivia/.test(line)) { | |
| return `${prefix}TRIVIAGAME: by unknown: ${line}`; | |
| } | |
| const modernizerTransformations = { | |
| "notes: ": (log) => { | |
| const [actionTaker, ...rest] = line.split(" notes: "); | |
| return `NOTE: by ${toID(actionTaker)}: ${rest.join("")}`; | |
| }, | |
| " declared": (log) => { | |
| let newAction = "DECLARE"; | |
| let oldAction = " declared"; | |
| if (log.includes(" globally declared")) { | |
| oldAction = " globally declared"; | |
| newAction = "GLOBALDECLARE"; | |
| } | |
| if (log.includes("(chat level)")) { | |
| oldAction += " (chat level)"; | |
| newAction = `CHATDECLARE`; | |
| } | |
| const actionTakerName = toID(log.slice(0, log.lastIndexOf(oldAction))); | |
| log = log.slice(actionTakerName.length); | |
| log = log.slice(oldAction.length); | |
| log = log.replace(/^\s?:/, "").trim(); | |
| return `${newAction}: by ${actionTakerName}: ${log}`; | |
| }, | |
| "changed the roomdesc to: ": (log) => { | |
| const actionTaker = parseBrackets(log, "["); | |
| log = log.slice(actionTaker.length + 3); | |
| log = log.slice("changed the roomdesc to: ".length + 1, -2); | |
| return `ROOMDESC: by ${actionTaker}: to "${log}"`; | |
| }, | |
| 'roomevent titled "': (log) => { | |
| let action; | |
| if (log.includes(' added a roomevent titled "')) { | |
| action = "added a"; | |
| } else if (log.includes(' removed a roomevent titled "')) { | |
| action = "removed a"; | |
| } else { | |
| action = "edited the"; | |
| } | |
| const actionTakerName = log.slice(0, log.lastIndexOf(` ${action} roomevent titled "`)); | |
| log = log.slice(actionTakerName.length + 1); | |
| const eventName = log.slice(` ${action} roomevent titled `.length, -2); | |
| return `ROOMEVENT: by ${toID(actionTakerName)}: ${action.split(" ")[0]} "${eventName}"`; | |
| }, | |
| "set modchat to ": (log) => { | |
| const actionTaker = parseBrackets(log, "["); | |
| log = log.slice(actionTaker.length + 3); | |
| log = log.slice("set modchat to ".length); | |
| return `MODCHAT: by ${actionTaker}: to ${log}`; | |
| }, | |
| "set modjoin to ": (log) => { | |
| const actionTakerName = log.slice(0, log.lastIndexOf(" set")); | |
| log = log.slice(actionTakerName.length + 1); | |
| log = log.slice("set modjoin to ".length); | |
| const rank = log.startsWith("sync") ? "sync" : log.replace(".", ""); | |
| return `MODJOIN${rank === "sync" ? " SYNC" : ""}: by ${toID(actionTakerName)}${rank !== "sync" ? `: ${rank}` : ``}`; | |
| }, | |
| "turned off modjoin": (log) => { | |
| const actionTakerName = log.slice(0, log.lastIndexOf(" turned off modjoin")); | |
| return `MODJOIN: by ${toID(actionTakerName)}: OFF`; | |
| }, | |
| "changed the roomintro": (log) => { | |
| const isDeletion = /deleted the (staff|room)intro/.test(log); | |
| const isRoomintro = log.includes("roomintro"); | |
| const actionTaker = toID(log.slice(0, log.indexOf(isDeletion ? "deleted" : "changed"))); | |
| return `${isDeletion ? "DELETE" : ""}${isRoomintro ? "ROOM" : "STAFF"}INTRO: by ${actionTaker}`; | |
| }, | |
| "deleted the roomintro": (log) => modernizerTransformations["changed the roomintro"](log), | |
| "changed the staffintro": (log) => modernizerTransformations["changed the roomintro"](log), | |
| "deleted the staffintro": (log) => modernizerTransformations["changed the roomintro"](log), | |
| "created a tournament in": (log) => { | |
| const actionTaker = parseBrackets(log, "["); | |
| log = log.slice(actionTaker.length + 3); | |
| log = log.slice(24, -8); | |
| return `TOUR CREATE: by ${actionTaker}: ${log}`; | |
| }, | |
| "was disqualified from the tournament by": (log) => { | |
| const disqualified = parseBrackets(log, "["); | |
| log = log.slice(disqualified.length + 3); | |
| log = log.slice("was disqualified from the tournament by".length); | |
| return `TOUR DQ: [${toID(disqualified)}] by ${toID(log)}`; | |
| }, | |
| "The tournament auto disqualify timeout was set to": (log) => { | |
| const byIndex = log.indexOf(" by "); | |
| const actionTaker = log.slice(byIndex + " by ".length); | |
| const length = log.slice("The tournament auto disqualify timeout was set to".length, byIndex); | |
| return `TOUR AUTODQ: by ${toID(actionTaker)}: ${length.trim()}`; | |
| }, | |
| " was blacklisted from ": (log) => { | |
| const isName = log.includes(" was nameblacklisted from "); | |
| const banned = toID(log.slice(0, log.indexOf(` was ${isName ? "name" : ""}blacklisted from `))); | |
| log = log.slice(log.indexOf(" by ") + " by ".length); | |
| let reason, ip; | |
| if (/\(.*\)/.test(log)) { | |
| reason = parseBrackets(log, "("); | |
| if (/\[.*\]/.test(log)) | |
| ip = parseBrackets(log, "["); | |
| log = log.slice(0, log.indexOf("(")); | |
| } | |
| const actionTaker = toID(log); | |
| return `${isName ? "NAME" : ""}BLACKLIST: [${banned}] ${getAutoconfirmed()}${getAlts()}${ip ? `[${ip}] ` : ``}by ${actionTaker}${reason ? `: ${reason}` : ``}`; | |
| }, | |
| " was nameblacklisted from ": (log) => modernizerTransformations[" was blacklisted from "](log), | |
| " was banned from room ": (log) => { | |
| const banned = toID(log.slice(0, log.indexOf(" was banned from room "))); | |
| log = log.slice(log.indexOf(" by ") + " by ".length); | |
| let reason, ip; | |
| if (/\(.*\)/.test(log)) { | |
| reason = parseBrackets(log, "("); | |
| if (/\[.*\]/.test(log)) | |
| ip = parseBrackets(log, "["); | |
| log = log.slice(0, log.indexOf("(")); | |
| } | |
| const actionTaker = toID(log); | |
| return `ROOMBAN: [${banned}] ${getAutoconfirmed()}${getAlts()}${ip ? `[${ip}] ` : ``}by ${actionTaker}${reason ? `: ${reason}` : ``}`; | |
| }, | |
| " was muted by ": (log) => { | |
| let muted = ""; | |
| let isHour = false; | |
| [muted, log] = log.split(" was muted by "); | |
| muted = toID(muted); | |
| let reason, ip; | |
| if (/\(.*\)/.test(log)) { | |
| reason = parseBrackets(log, "("); | |
| if (/\[.*\]/.test(log)) | |
| ip = parseBrackets(log, "["); | |
| log = log.slice(0, log.indexOf("(")); | |
| } | |
| let actionTaker = toID(log); | |
| if (actionTaker.endsWith("for1hour")) { | |
| isHour = true; | |
| actionTaker = actionTaker.replace(/^(.*)(for1hour)$/, (match, staff) => staff); | |
| } | |
| return `${isHour ? "HOUR" : ""}MUTE: [${muted}] ${getAutoconfirmed()}${getAlts()}${ip ? `[${ip}] ` : ``}by ${actionTaker}${reason ? `: ${reason}` : ``}`; | |
| }, | |
| " was locked from talking ": (log) => { | |
| const isWeek = log.includes(" was locked from talking for a week "); | |
| const locked = toID(log.slice(0, log.indexOf(" was locked from talking "))); | |
| log = log.slice(log.indexOf(" by ") + " by ".length); | |
| let reason, ip; | |
| if (/\(.*\)/.test(log)) { | |
| reason = parseBrackets(log, "("); | |
| if (/\[.*\]/.test(log)) | |
| ip = parseBrackets(log, "["); | |
| log = log.slice(0, log.indexOf("(")); | |
| } | |
| const actionTaker = toID(log); | |
| return `${isWeek ? "WEEK" : ""}LOCK: [${locked}] ${getAutoconfirmed()}${getAlts()}${ip ? `[${ip}] ` : ``}by ${actionTaker}${reason ? `: ${reason}` : ``}`; | |
| }, | |
| " was banned ": (log) => { | |
| if (log.includes(" was banned from room ")) | |
| return modernizerTransformations[" was banned from room "](log); | |
| const banned = toID(log.slice(0, log.indexOf(" was banned "))); | |
| log = log.slice(log.indexOf(" by ") + " by ".length); | |
| let reason, ip; | |
| if (/\(.*\)/.test(log)) { | |
| reason = parseBrackets(log, "("); | |
| if (/\[.*\]/.test(log)) | |
| ip = parseBrackets(log, "["); | |
| log = log.slice(0, log.indexOf("(")); | |
| } | |
| const actionTaker = toID(log); | |
| return `BAN: [${banned}] ${getAutoconfirmed()}${getAlts()}${ip ? `[${ip}] ` : ``}by ${actionTaker}${reason ? `: ${reason}` : ``}`; | |
| }, | |
| "was promoted to ": (log) => { | |
| const isDemotion = log.includes("was demoted to "); | |
| const userid = toID(log.split(" was ")[0]); | |
| if (!userid) { | |
| throw new Error(`Ignoring malformed line: ${prefix}${log}`); | |
| } | |
| log = log.slice(userid.length + 3); | |
| log = log.slice(`was ${isDemotion ? "demoted" : "promoted"} to `.length); | |
| let rank = log.slice(0, log.indexOf(" by")).replace(/ /, "").toUpperCase(); | |
| log = log.slice(`${rank} by `.length); | |
| if (!rank.startsWith("ROOM")) | |
| rank = `GLOBAL ${rank}`; | |
| const actionTaker = parseBrackets(log, "["); | |
| return `${rank}: [${userid}] by ${actionTaker}${isDemotion ? ": (demote)" : ""}`; | |
| }, | |
| "was demoted to ": (log) => modernizerTransformations["was promoted to "](log), | |
| "was appointed Room Owner by ": (log) => { | |
| const userid = parseBrackets(log, "["); | |
| log = log.slice(userid.length + 3); | |
| log = log.slice("was appointed Room Owner by ".length); | |
| const actionTaker = parseBrackets(log, "["); | |
| return `ROOMOWNER: [${userid}] by ${actionTaker}`; | |
| }, | |
| " claimed this ticket": (log) => { | |
| const actions = { | |
| " claimed this ticket": "TICKETCLAIM", | |
| " closed this ticket": "TICKETCLOSE", | |
| " deleted this ticket": "TICKETDELETE" | |
| }; | |
| for (const oldAction in actions) { | |
| if (log.includes(oldAction)) { | |
| const actionTaker = toID(log.slice(0, log.indexOf(oldAction))); | |
| return `${actions[oldAction]}: by ${actionTaker}`; | |
| } | |
| } | |
| return log; | |
| }, | |
| "This ticket is now claimed by ": (log) => { | |
| const claimer = toID(log.slice(log.indexOf(" by ") + " by ".length)); | |
| return `TICKETCLAIM: by ${claimer}`; | |
| }, | |
| " is no longer interested in this ticket": (log) => { | |
| const abandoner = toID(log.slice(0, log.indexOf(" is no longer interested in this ticket"))); | |
| return `TICKETABANDON: by ${abandoner}`; | |
| }, | |
| " opened a new ticket": (log) => { | |
| const opener = toID(log.slice(0, log.indexOf(" opened a new ticket"))); | |
| const problem = log.slice(log.indexOf(" Issue: ") + " Issue: ".length).trim(); | |
| return `TICKETOPEN: by ${opener}: ${problem}`; | |
| }, | |
| " closed this ticket": (log) => modernizerTransformations[" claimed this ticket"](log), | |
| " deleted this ticket": (log) => modernizerTransformations[" claimed this ticket"](log), | |
| "This ticket is no longer claimed": () => "TICKETUNCLAIM", | |
| " has been caught attempting a hunt with ": (log) => { | |
| const index = log.indexOf(" has been caught attempting a hunt with "); | |
| const user = toID(log.slice(0, index)); | |
| log = log.slice(index + " has been caught attempting a hunt with ".length); | |
| log = log.replace(". The user has also", "; has also").replace(".", ""); | |
| return `SCAV CHEATER: [${user}]: caught attempting a hunt with ${log}`; | |
| }, | |
| "made this room hidden": (log) => { | |
| const user = toID(log.slice(0, log.indexOf(" made this room hidden"))); | |
| return `HIDDENROOM: by ${user}`; | |
| }, | |
| "The tournament auto start timer was set to ": (log) => { | |
| log = log.slice("The tournament auto start timer was set to".length); | |
| const [length, setter] = log.split(" by ").map(toID); | |
| return `TOUR AUTOSTART: by ${setter}: ${length}`; | |
| }, | |
| "The tournament auto disqualify timer was set to ": (log) => { | |
| log = log.slice("The tournament auto disqualify timer was set to".length); | |
| const [length, setter] = log.split(" by ").map(toID); | |
| return `TOUR AUTODQ: by ${setter}: ${length}`; | |
| }, | |
| " set the tournament's banlist to ": (log) => { | |
| const [setter, banlist] = log.split(` set the tournament's banlist to `); | |
| return `TOUR BANLIST: by ${toID(setter)}: ${banlist.slice(0, -1)}`; | |
| }, | |
| " set the tournament's custom rules to": (log) => { | |
| const [setter, rules] = log.split(` set the tournament's custom rules to `); | |
| return `TOUR RULES: by ${toID(setter)}: ${rules.slice(0, -1)}`; | |
| }, | |
| "[agameofhangman] was started by ": (log) => `HANGMAN: by ${toID(log.slice("[agameofhangman] was started by ".length))}`, | |
| "[agameofunowas] created by ": (log) => `UNO CREATE: by ${toID(log.slice("[agameofunowas] created by ".length))}`, | |
| "[thetournament] was set to autostart": (log) => { | |
| const [, user] = log.split(" by "); | |
| return `TOUR AUTOSTART: by ${toID(user)}: when playercap is reached`; | |
| }, | |
| "[thetournament] was set to allow scouting": (log) => { | |
| const [, user] = log.split(" by "); | |
| return `TOUR SCOUT: by ${toID(user)}: allow`; | |
| }, | |
| "[thetournament] was set to disallow scouting": (log) => { | |
| const [, user] = log.split(" by "); | |
| return `TOUR SCOUT: by ${toID(user)}: disallow`; | |
| } | |
| }; | |
| for (const oldAction in modernizerTransformations) { | |
| if (line.includes(oldAction)) { | |
| try { | |
| return prefix + modernizerTransformations[oldAction](line); | |
| } catch (err) { | |
| if (Config.nofswriting) | |
| throw err; | |
| process.stderr.write(`${err.message} | |
| `); | |
| } | |
| } | |
| } | |
| return `${prefix}${line}`; | |
| } | |
| function parseModlog(raw, nextLine, isGlobal = false) { | |
| let line = modernizeLog(raw); | |
| if (!line) | |
| return; | |
| const timestamp = parseBrackets(line, "["); | |
| line = line.slice(timestamp.length + 3); | |
| const [roomID, ...bonus] = parseBrackets(line, "(").split(" "); | |
| const log = { | |
| action: "NULL", | |
| roomID, | |
| visualRoomID: "", | |
| userid: null, | |
| autoconfirmedID: null, | |
| alts: [], | |
| ip: null, | |
| isGlobal, | |
| loggedBy: null, | |
| note: "", | |
| time: Math.floor(new Date(timestamp).getTime()) || 0 | |
| }; | |
| if (bonus.length) | |
| log.visualRoomID = `${log.roomID} ${bonus.join(" ")}`; | |
| line = line.slice((log.visualRoomID || log.roomID).length + 3); | |
| const actionColonIndex = line.indexOf(":"); | |
| const action = line.slice(0, actionColonIndex); | |
| if (action !== action.toUpperCase()) { | |
| log.action = "OLD MODLOG"; | |
| log.loggedBy = "unknown"; | |
| log.note = line.trim(); | |
| return log; | |
| } else { | |
| log.action = action; | |
| if (log.action === "OLD MODLOG") { | |
| log.loggedBy = "unknown"; | |
| log.note = line.slice(line.indexOf("by unknown: ") + "by unknown :".length).trim(); | |
| return log; | |
| } | |
| line = line.slice(actionColonIndex + 2); | |
| } | |
| if (line[0] === "[") { | |
| if (!IP_ONLY_ACTIONS.has(log.action)) { | |
| const userid = toID(parseBrackets(line, "[")); | |
| log.userid = userid; | |
| line = line.slice(userid.length + 3).trim(); | |
| if (line.startsWith("ac:")) { | |
| line = line.slice(3).trim(); | |
| const ac = parseBrackets(line, "["); | |
| log.autoconfirmedID = toID(ac); | |
| line = line.slice(ac.length + 3).trim(); | |
| } | |
| if (line.startsWith("alts:")) { | |
| line = line.slice(5).trim(); | |
| const alts = /* @__PURE__ */ new Set(); | |
| let alt = parseBrackets(line, "["); | |
| do { | |
| if (alt.includes(", ")) { | |
| for (const trueAlt of alt.split(", ")) { | |
| alts.add(toID(trueAlt)); | |
| } | |
| line = line.slice(line.indexOf(`[${alt}],`) + `[${alt}],`.length).trim(); | |
| if (!line.startsWith("[")) | |
| line = `[${line}`; | |
| } else { | |
| if (import_ip_tools.IPTools.ipRegex.test(alt)) | |
| break; | |
| alts.add(toID(alt)); | |
| line = line.slice(line.indexOf(`[${alt}],`) + `[${alt}],`.length).trim(); | |
| if (alt.includes("[") && !line.startsWith("[")) | |
| line = `[${line}`; | |
| } | |
| alt = parseBrackets(line, "["); | |
| } while (alt); | |
| log.alts = [...alts]; | |
| } | |
| } | |
| if (line[0] === "[") { | |
| log.ip = parseBrackets(line, "["); | |
| line = line.slice(log.ip.length + 3).trim(); | |
| } | |
| } | |
| let regex = /\bby .*:/; | |
| let actionTakerIndex = regex.exec(line)?.index; | |
| if (actionTakerIndex === void 0) { | |
| actionTakerIndex = line.indexOf("by "); | |
| regex = /\bby .*/; | |
| } | |
| if (actionTakerIndex !== -1) { | |
| const colonIndex = line.indexOf(": "); | |
| const actionTaker = line.slice(actionTakerIndex + 3, colonIndex > actionTakerIndex ? colonIndex : void 0); | |
| if (toID(actionTaker).length < 19) { | |
| log.loggedBy = toID(actionTaker) || null; | |
| if (colonIndex > actionTakerIndex) | |
| line = line.slice(colonIndex); | |
| line = line.replace(regex, " "); | |
| } | |
| } | |
| if (line) | |
| log.note = line.replace(/^\s?:\s?/, "").trim(); | |
| return log; | |
| } | |
| function rawifyLog(log) { | |
| let result = `[${new Date(log.time || Date.now()).toJSON()}] (${(log.visualRoomID || log.roomID || "global").replace(/^global-/, "")}) ${log.action}`; | |
| if (log.userid) | |
| result += `: [${log.userid}]`; | |
| if (log.autoconfirmedID) | |
| result += ` ac: [${log.autoconfirmedID}]`; | |
| if (log.alts.length) | |
| result += ` alts: [${log.alts.join("], [")}]`; | |
| if (log.ip) { | |
| if (!log.userid) | |
| result += `:`; | |
| result += ` [${log.ip}]`; | |
| } | |
| if (log.loggedBy) | |
| result += `${result.endsWith("]") ? "" : ":"} by ${log.loggedBy}`; | |
| if (log.note) | |
| result += `: ${log.note}`; | |
| return result + ` | |
| `; | |
| } | |
| class ModlogConverterSQLite { | |
| constructor(databaseFile, textLogDir, isTesting, newestAllowedTimestamp) { | |
| this.isTesting = null; | |
| this.databaseFile = databaseFile; | |
| this.textLogDir = textLogDir; | |
| if (isTesting || Config.nofswriting) { | |
| this.isTesting = { files: /* @__PURE__ */ new Map(), db: isTesting || new Database(":memory:") }; | |
| } | |
| this.newestAllowedTimestamp = newestAllowedTimestamp; | |
| } | |
| async toTxt() { | |
| const database = this.isTesting?.db || new Database(this.databaseFile, { fileMustExist: true }); | |
| const roomids = database.prepare("SELECT DISTINCT roomid FROM modlog").all(); | |
| const globalEntries = []; | |
| for (const { roomid } of roomids) { | |
| if (!Config.nofswriting) | |
| console.log(`Reading ${roomid}...`); | |
| const results = database.prepare( | |
| `SELECT *, (SELECT group_concat(userid, ',') FROM alts WHERE alts.modlog_id = modlog.modlog_id) as alts FROM modlog WHERE roomid = ? ORDER BY timestamp ASC` | |
| ).all(roomid); | |
| const trueRoomID = roomid.replace(/^global-/, ""); | |
| let entriesLogged = 0; | |
| let entries = []; | |
| const insertEntries = async () => { | |
| if (roomid === "global") | |
| return; | |
| entriesLogged += entries.length; | |
| if (!Config.nofswriting && (entriesLogged % ENTRIES_TO_BUFFER === 0 || entriesLogged < ENTRIES_TO_BUFFER)) { | |
| process.stdout.clearLine(0); | |
| process.stdout.cursorTo(0); | |
| process.stdout.write(`Wrote ${entriesLogged} entries from '${trueRoomID}'`); | |
| } | |
| await this.writeFile(`${this.textLogDir}/modlog_${trueRoomID}.txt`, entries.join("")); | |
| entries = []; | |
| }; | |
| for (const result of results) { | |
| if (this.newestAllowedTimestamp && result.timestamp > this.newestAllowedTimestamp) | |
| break; | |
| const entry = { | |
| action: result.action, | |
| roomID: result.roomid?.replace(/^global-/, ""), | |
| visualRoomID: result.visual_roomid, | |
| userid: result.userid, | |
| autoconfirmedID: result.autoconfirmed_userid, | |
| alts: result.alts?.split(","), | |
| ip: result.ip, | |
| isGlobal: result.roomid?.startsWith("global-") || result.roomid === "global" || result.is_global, | |
| loggedBy: result.action_taker_userid, | |
| note: result.note, | |
| time: result.timestamp | |
| }; | |
| const rawLog = rawifyLog(entry); | |
| entries.push(rawLog); | |
| if (entry.isGlobal) { | |
| globalEntries.push(rawLog); | |
| } | |
| if (entries.length === ENTRIES_TO_BUFFER) | |
| await insertEntries(); | |
| } | |
| await insertEntries(); | |
| if (entriesLogged) | |
| process.stdout.write("\n"); | |
| } | |
| if (!Config.nofswriting) | |
| console.log(`Writing the global modlog...`); | |
| await this.writeFile(`${this.textLogDir}/modlog_global.txt`, globalEntries.join("")); | |
| } | |
| async writeFile(path, text) { | |
| if (this.isTesting) { | |
| const old = this.isTesting.files.get(path); | |
| return this.isTesting.files.set(path, `${old || ""}${text}`); | |
| } | |
| return (0, import_lib.FS)(path).append(text); | |
| } | |
| } | |
| class ModlogConverterTxt { | |
| constructor(databaseFile, textLogDir, isTesting, newestAllowedTimestamp) { | |
| this.isTesting = null; | |
| this.databaseFile = databaseFile; | |
| this.textLogDir = textLogDir; | |
| if (isTesting || Config.nofswriting) { | |
| this.isTesting = { | |
| files: isTesting || /* @__PURE__ */ new Map() | |
| }; | |
| } | |
| this.modlog = new Modlog( | |
| this.isTesting ? ":memory:" : this.databaseFile, | |
| // wait 15 seconds for DB to no longer be busy - this is important since I'm trying to do | |
| // a no-downtime transfer of text -> SQLite | |
| { sqliteOptions: { timeout: 15e3 } } | |
| ); | |
| this.newestAllowedTimestamp = newestAllowedTimestamp; | |
| } | |
| async toSQLite() { | |
| await this.modlog.readyPromise; | |
| const files = this.isTesting ? [...this.isTesting.files.keys()] : await (0, import_lib.FS)(this.textLogDir).readdir(); | |
| if (files.includes("modlog_global.txt")) { | |
| files.splice(files.indexOf("modlog_global.txt"), 1); | |
| files.unshift("modlog_global.txt"); | |
| } | |
| const globalEntries = {}; | |
| for (const file of files) { | |
| if (file === "README.md") | |
| continue; | |
| const roomid = file.slice(7, -4); | |
| const lines = this.isTesting ? this.isTesting.files.get(file)?.split("\n") || [] : (0, import_lib.FS)(`${this.textLogDir}/${file}`).createReadStream().byLine(); | |
| let entriesLogged = 0; | |
| let lastLine = void 0; | |
| let entries = []; | |
| const insertEntries = async () => { | |
| await this.modlog.writeSQL(entries); | |
| entriesLogged += entries.length; | |
| if (!Config.nofswriting) { | |
| process.stdout.clearLine(0); | |
| process.stdout.cursorTo(0); | |
| process.stdout.write(`Inserted ${entriesLogged} entries from '${roomid}'`); | |
| } | |
| entries = []; | |
| }; | |
| for await (const line of lines) { | |
| const entry = parseModlog(line, lastLine, roomid === "global"); | |
| lastLine = line; | |
| if (!entry) | |
| continue; | |
| if (this.newestAllowedTimestamp && entry.time > this.newestAllowedTimestamp) | |
| break; | |
| if (roomid !== "global" && globalEntries[entry.roomID]?.includes(line)) { | |
| continue; | |
| } | |
| if (entry.isGlobal) { | |
| if (!globalEntries[entry.roomID]) | |
| globalEntries[entry.roomID] = []; | |
| globalEntries[entry.roomID].push(line); | |
| } | |
| entries.push(entry); | |
| if (entries.length === ENTRIES_TO_BUFFER) | |
| await insertEntries(); | |
| } | |
| delete globalEntries[roomid]; | |
| await insertEntries(); | |
| if (entriesLogged) | |
| process.stdout.write("\n"); | |
| } | |
| return this.modlog.database; | |
| } | |
| } | |
| class ModlogConverterTest { | |
| constructor(inputDir, outputDir) { | |
| this.inputDir = inputDir; | |
| this.outputDir = outputDir; | |
| } | |
| async toTxt() { | |
| const files = await (0, import_lib.FS)(this.inputDir).readdir(); | |
| if (files.includes("modlog_global.txt")) { | |
| files.splice(files.indexOf("modlog_global.txt"), 1); | |
| files.push("modlog_global.txt"); | |
| } | |
| const globalEntries = []; | |
| for (const file of files) { | |
| if (file === "README.md") | |
| continue; | |
| const roomid = file.slice(7, -4); | |
| let entriesLogged = 0; | |
| let lastLine = void 0; | |
| let entries = []; | |
| const insertEntries = async () => { | |
| if (roomid === "global") | |
| return; | |
| entriesLogged += entries.length; | |
| if (!Config.nofswriting && (entriesLogged % ENTRIES_TO_BUFFER === 0 || entriesLogged < ENTRIES_TO_BUFFER)) { | |
| process.stdout.clearLine(0); | |
| process.stdout.cursorTo(0); | |
| process.stdout.write(`Wrote ${entriesLogged} entries from '${roomid}'`); | |
| } | |
| await (0, import_lib.FS)(`${this.outputDir}/modlog_${roomid}.txt`).append(entries.join("")); | |
| entries = []; | |
| }; | |
| const readStream = (0, import_lib.FS)(`${this.inputDir}/${file}`).createReadStream(); | |
| for await (const line of readStream.byLine()) { | |
| const entry = parseModlog(line, lastLine, roomid === "global"); | |
| lastLine = line; | |
| if (!entry) | |
| continue; | |
| const rawLog = rawifyLog(entry); | |
| if (roomid !== "global") | |
| entries.push(rawLog); | |
| if (entry.isGlobal) { | |
| globalEntries.push(rawLog); | |
| } | |
| if (entries.length === ENTRIES_TO_BUFFER) | |
| await insertEntries(); | |
| } | |
| await insertEntries(); | |
| if (entriesLogged) | |
| process.stdout.write("\n"); | |
| } | |
| if (!Config.nofswriting) | |
| console.log(`Writing the global modlog...`); | |
| await (0, import_lib.FS)(`${this.outputDir}/modlog_global.txt`).append(globalEntries.join("")); | |
| } | |
| } | |
| const ModlogConverter = { | |
| async convert(from, to, databasePath, textLogDirectoryPath, outputLogPath, newestAllowedTimestamp) { | |
| if (from === "txt" && to === "txt" && outputLogPath) { | |
| const converter = new ModlogConverterTest(textLogDirectoryPath, outputLogPath); | |
| await converter.toTxt(); | |
| console.log("\nDone!"); | |
| process.exit(); | |
| } else if (from === "sqlite" && to === "txt") { | |
| const converter = new ModlogConverterSQLite(databasePath, textLogDirectoryPath, void 0, newestAllowedTimestamp); | |
| await converter.toTxt(); | |
| console.log("\nDone!"); | |
| process.exit(); | |
| } else if (from === "txt" && to === "sqlite") { | |
| const converter = new ModlogConverterTxt(databasePath, textLogDirectoryPath, void 0, newestAllowedTimestamp); | |
| await converter.toSQLite(); | |
| console.log("\nDone!"); | |
| process.exit(); | |
| } | |
| } | |
| }; | |
| //# sourceMappingURL=converter.js.map | |