mirror of
https://github.com/nx-bat/discordbot-ng.git
synced 2026-11-11 07:13:37 -05:00
446 lines
16 KiB
TypeScript
446 lines
16 KiB
TypeScript
import { readFileSync } from 'fs';
|
|
import path from 'path';
|
|
import { open, Database as SqliteDatabase } from 'sqlite';
|
|
import sqlite3 from 'sqlite3';
|
|
import { AppealMessage, Ban, GithubUserMapping, GuildArraySetting, GuildSettings, KnowledgebaseItem, LoggedMessage, Note, PrivateHelpTicket, RoleButton, TicketMessage, TicketPhrase } from '../types';
|
|
import { deserializeMessage, Message, serializeMessage, wait } from '../utils';
|
|
import { Encrypter } from './Encrypter';
|
|
|
|
export const enum PrivateHelpTicketStatus {
|
|
OPEN = 0,
|
|
CLOSED = 1
|
|
}
|
|
|
|
export class Database {
|
|
private static db: SqliteDatabase;
|
|
private static settings: Map<string, GuildSettings> = new Map();
|
|
|
|
static async open(file: string): Promise<void> {
|
|
if (Database.db) return;
|
|
|
|
console.log('Opening SQLite database');
|
|
|
|
Database.db = await open({
|
|
filename: file,
|
|
driver: sqlite3.Database
|
|
});
|
|
|
|
console.log('SQLite database opened');
|
|
|
|
await Database.ensure();
|
|
await Database.migrate();
|
|
}
|
|
|
|
private static async ensure() {
|
|
const schema = readFileSync(path.join(__dirname, '..', '..', 'sql', 'structure.sql'), { encoding: 'utf-8' });
|
|
await Database.db.exec(schema);
|
|
console.log('SQLite database ensured');
|
|
}
|
|
|
|
private static async migrate() {
|
|
console.log('Starting database migrations');
|
|
|
|
await Database.db.migrate({
|
|
migrationsPath: path.join(__dirname, '..', '..', 'sql', 'migrations')
|
|
});
|
|
|
|
console.log('Database migrations ran');
|
|
}
|
|
|
|
//#region WHOIS
|
|
|
|
static async getE621Ids(discordId: string): Promise<number[]> {
|
|
const ids = await Database.db.all<{ user_id: number }[]>('SELECT DISTINCT user_id FROM discord_names WHERE discord_id_hash = ?', Encrypter.hash(discordId));
|
|
|
|
return ids.map(r => r.user_id);
|
|
}
|
|
|
|
static async getDiscordIds(e621Id: string | number): Promise<string[]> {
|
|
// Perhaps this would be better and then we can return all the data: SELECT * FROM (SELECT * FROM discord_names WHERE user_id = ? ORDER BY id DESC) GROUP BY discord_id;
|
|
const ids = await Database.db.all<{ discord_id: string }[]>('SELECT discord_id FROM discord_names WHERE user_id = ? GROUP BY discord_id_hash', e621Id);
|
|
|
|
return ids.map(r => Encrypter.decrypt(r.discord_id));
|
|
}
|
|
|
|
static async putUser(id: number, user: { id: string, username: string }) {
|
|
await Database.db.run('INSERT INTO discord_names(user_id, discord_id, discord_id_hash, discord_username, discord_username_hash) VALUES (?, ?, ?, ?, ?)', id, Encrypter.encrypt(user.id), Encrypter.hash(user.id), Encrypter.encrypt(user.username), Encrypter.hash(user.username));
|
|
}
|
|
|
|
static async removeUser(id: number, discordId: string) {
|
|
await Database.db.run('DELETE from discord_names WHERE user_id = ? AND discord_id_hash = ?', id, Encrypter.hash(discordId));
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Guild Settings
|
|
|
|
static async getOrCreateSettings(guildId: string): Promise<GuildSettings> {
|
|
const localStore = this.settings.get(guildId);
|
|
if (localStore) return localStore;
|
|
|
|
await Database.db.run('INSERT OR IGNORE INTO settings (guild_id) VALUES (?)', guildId);
|
|
const store = await Database.db.get<GuildSettings>('SELECT * FROM settings WHERE guild_id = ?', guildId) as GuildSettings;
|
|
|
|
this.settings.set(guildId, store);
|
|
return store;
|
|
}
|
|
|
|
static async updateSettings(guildId: string, key: Exclude<keyof GuildSettings, 'guild_id'>, value: string) {
|
|
await Database.db.run(`UPDATE settings SET ${key} = ? WHERE guild_id = ?`, value, guildId);
|
|
this.settings.delete(guildId);
|
|
}
|
|
|
|
static async getGuildArraySetting(setting: GuildArraySetting, guildId: string): Promise<string[]> {
|
|
const settings = await Database.getOrCreateSettings(guildId);
|
|
|
|
if (!settings[setting]) return [];
|
|
return settings[setting].split(',');
|
|
}
|
|
|
|
static async putGuildArraySetting(setting: GuildArraySetting, guildId: string, value: string) {
|
|
const values = await Database.getGuildArraySetting(setting, guildId);
|
|
if (!values.includes(value)) values.push(value);
|
|
|
|
await Database.updateSettings(guildId, setting, values.join(','));
|
|
}
|
|
|
|
static async removeGuildArraySetting(setting: GuildArraySetting, guildId: string, value: string): Promise<boolean> {
|
|
const values = await Database.getGuildArraySetting(setting, guildId);
|
|
|
|
const index = values.indexOf(value);
|
|
if (index === -1) return false;
|
|
|
|
values.splice(index, 1);
|
|
|
|
await Database.updateSettings(guildId, setting, values.join(','));
|
|
return true;
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Message Logs
|
|
|
|
static async putMessage(message: Message): Promise<boolean> {
|
|
try {
|
|
const serializedMessage = serializeMessage(message);
|
|
|
|
await Database.db.run(`
|
|
INSERT INTO messages (id, id_hash, author_id, author_id_hash, author_name, channel_id, attachments, stickers, content) VALUES
|
|
(:id, :id_hash, :author_id, :author_id_hash, :author_name, :channel_id, :attachments, :stickers, :content)
|
|
`, ...serializedMessage);
|
|
|
|
return true;
|
|
} catch (e) {
|
|
console.error(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static async getMessage(id: string): Promise<LoggedMessage | null> {
|
|
const data = await Database.db.get<LoggedMessage>('SELECT * FROM messages WHERE id_hash = ?', Encrypter.hash(id));
|
|
|
|
if (!data) return null;
|
|
|
|
return deserializeMessage(data);
|
|
}
|
|
|
|
static async getMessageWithRetry(id: string, retries = 5, delay = 500): Promise<LoggedMessage | null> {
|
|
let tried = 0;
|
|
while (tried < retries) {
|
|
tried++;
|
|
const message = await Database.getMessage(id);
|
|
|
|
if (message) return message;
|
|
|
|
await wait(delay);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
static async removeMessge(id: string) {
|
|
await Database.db.run('DELETE from messages WHERE id_hash = ?', Encrypter.hash(id));
|
|
}
|
|
|
|
static async pruneOldMessages() {
|
|
await Database.db.run('DELETE from messages WHERE datetime(timestamp) < datetime("now", "-28 days")');
|
|
}
|
|
|
|
static async purgeMessagesFrom(id: string) {
|
|
await Database.db.run('DELETE from messages WHERE author_id_hash = ?', Encrypter.hash(id));
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Tickets
|
|
|
|
static async putTicket(ticketId: number, messageId: string) {
|
|
await Database.db.run('INSERT INTO tickets(id, message_id) VALUES (?, ?)', ticketId, messageId);
|
|
}
|
|
|
|
static async updateTicketMessageId(ticketId: number, messageId: string) {
|
|
await Database.db.run('UPDATE tickets SET message_id = ? WHERE id = ?', messageId, ticketId);
|
|
}
|
|
|
|
static async putTicketOrUpdate(ticketId: number, messageId: string) {
|
|
if (await Database.getTicketMessageId(ticketId)) {
|
|
await Database.updateTicketMessageId(ticketId, messageId);
|
|
} else {
|
|
await Database.putTicket(ticketId, messageId);
|
|
}
|
|
}
|
|
|
|
static async removeTicket(ticketId: number) {
|
|
await Database.db.run('DELETE from tickets WHERE id = ?', ticketId);
|
|
}
|
|
|
|
static async getTicketMessageId(ticketId: number): Promise<string | undefined> {
|
|
const ticket = await Database.db.get<Pick<TicketMessage, 'message_id'>>('SELECT message_id FROM tickets WHERE id = ?', ticketId);
|
|
return ticket?.message_id;
|
|
}
|
|
|
|
static async putTicketPhrase(userId: string, phrase: string) {
|
|
await Database.db.run('INSERT INTO ticket_phrases(user_id, user_id_hash, phrase) VALUES (?, ?, ?)', Encrypter.encrypt(userId), Encrypter.hash(userId), phrase);
|
|
}
|
|
|
|
static async getTicketPhrase(id: number): Promise<TicketPhrase | undefined> {
|
|
const data: TicketPhrase | undefined = await Database.db.get<TicketPhrase>('SELECT * FROM ticket_phrases WHERE id = ?', id);
|
|
return data ? {
|
|
...data,
|
|
user_id: Encrypter.decrypt(data.user_id)
|
|
} : undefined;
|
|
}
|
|
|
|
static async removeTicketPhrase(id: number) {
|
|
await Database.db.run('DELETE from ticket_phrases WHERE id = ?', id);
|
|
}
|
|
|
|
static async removeAllTicketPhrasesFor(id: string): Promise<number> {
|
|
return (await Database.db.run('DELETE from ticket_phrases WHERE user_id_hash = ?', Encrypter.hash(id))).changes!;
|
|
}
|
|
|
|
static async getTicketPhrasesFor(id: string): Promise<TicketPhrase[]> {
|
|
const data: TicketPhrase[] = await Database.db.all<TicketPhrase[]>('SELECT * from ticket_phrases WHERE user_id_hash = ?', Encrypter.hash(id));
|
|
return data.map((ticketPhrase) => {
|
|
return {
|
|
...ticketPhrase,
|
|
user_id: Encrypter.decrypt(ticketPhrase.user_id)
|
|
};
|
|
});
|
|
}
|
|
|
|
static async getAllTicketPhrases(cb: (ticketPhrase: TicketPhrase) => void) {
|
|
await Database.db.each<TicketPhrase>('SELECT * from ticket_phrases', (err: any, ticketPhrase: TicketPhrase) => {
|
|
if (err) return console.error(err);
|
|
|
|
cb({
|
|
...ticketPhrase,
|
|
user_id: Encrypter.decrypt(ticketPhrase.user_id)
|
|
});
|
|
});
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Appeals
|
|
|
|
static async putAppeal(appealId: number, messageId: string) {
|
|
await Database.db.run('INSERT INTO appeals(id, message_id) VALUES (?, ?)', appealId, messageId);
|
|
}
|
|
|
|
static async updateAppealMessageId(appealId: number, messageId: string) {
|
|
await Database.db.run('UPDATE appeals SET message_id = ? WHERE id = ?', messageId, appealId);
|
|
}
|
|
|
|
static async putAppealOrUpdate(ticketId: number, messageId: string) {
|
|
if (await Database.getAppealMessageId(ticketId)) {
|
|
await Database.updateAppealMessageId(ticketId, messageId);
|
|
} else {
|
|
await Database.putAppeal(ticketId, messageId);
|
|
}
|
|
}
|
|
|
|
static async removeAppeal(appealId: number) {
|
|
await Database.db.run('DELETE from appeals WHERE id = ?', appealId);
|
|
}
|
|
|
|
static async getAppealMessageId(appealId: number): Promise<string | undefined> {
|
|
const appeal = await Database.db.get<Pick<AppealMessage, 'message_id'>>('SELECT message_id FROM appeals WHERE id = ?', appealId);
|
|
return appeal?.message_id;
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Notes
|
|
|
|
static async putNote(userId: string, reason: string, modId: string) {
|
|
await Database.db.run('INSERT INTO notes(user_id, user_id_hash, reason, mod_id) VALUES (?, ?, ?, ?)', Encrypter.encrypt(userId), Encrypter.hash(userId), reason, Encrypter.encrypt(modId));
|
|
}
|
|
|
|
static async editNote(id: number, oldReason: string, newReason: string, modId: string) {
|
|
await Database.db.run('UPDATE notes SET reason = ?, mod_id = ? WHERE id = ?', newReason, Encrypter.encrypt(modId), id);
|
|
await Database.db.run('INSERT INTO note_edits(note_id, mod_id, previous_reason) VALUES (?, ?, ?)', id, Encrypter.encrypt(modId), oldReason);
|
|
}
|
|
|
|
static async removeNote(id: number): Promise<boolean> {
|
|
const res = await Database.db.run('DELETE from notes WHERE id = ?', id);
|
|
|
|
return (res.changes ?? 0) > 0;
|
|
}
|
|
|
|
static async getNotes(userId: string): Promise<Note[]> {
|
|
const data: Note[] = await Database.db.all<Note[]>('SELECT * from notes WHERE user_id_hash = ?', Encrypter.hash(userId));
|
|
return data.map((note) => {
|
|
return {
|
|
...note,
|
|
user_id: Encrypter.decrypt(note.user_id),
|
|
mod_id: Encrypter.decrypt(note.mod_id)
|
|
};
|
|
});
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Bans
|
|
|
|
static async putBan(userId: string, expiresAt: Date | null, fullBan = false) {
|
|
await Database.db.run('INSERT INTO bans(user_id, user_id_hash, expires, expires_at, full_ban) VALUES (?, ?, ?, ?, ?)', Encrypter.encrypt(userId), Encrypter.hash(userId), expiresAt != null ? 1 : 0, expiresAt, fullBan);
|
|
}
|
|
|
|
static async getBan(userId: string): Promise<Ban | undefined> {
|
|
const data: Ban | undefined = await Database.db.get('SELECT * from bans WHERE user_id_hash = ? ORDER BY id DESC', Encrypter.hash(userId));
|
|
return data ? {
|
|
...data,
|
|
user_id: Encrypter.decrypt(data.user_id)
|
|
} : undefined;
|
|
}
|
|
|
|
static async getExpiredBans(date: Date): Promise<Ban[]> {
|
|
const data: Ban[] = await Database.db.all<Ban[]>('SELECT * from bans WHERE expires = 1 AND expires_at <= ?', date);
|
|
return data.map((ban) => {
|
|
return {
|
|
...ban,
|
|
user_id: Encrypter.decrypt(ban.user_id)
|
|
};
|
|
});
|
|
}
|
|
|
|
static async pruneExpiredBans(date: Date) {
|
|
await Database.db.all<Ban[]>('DELETE from bans WHERE expires = 1 AND expires_at <= ?', date);
|
|
}
|
|
|
|
static async removeBan(userId: string) {
|
|
await Database.db.run('DELETE from bans WHERE user_id_hash = ?', Encrypter.hash(userId));
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//# GitHub User Mapping
|
|
|
|
// github_user_mapping
|
|
static async putGithubUserMapping(discordId: string, githubUsername: string) {
|
|
await Database.db.run('INSERT INTO github_user_mapping(discord_id, discord_id_hash, github_username) VALUES (?, ?, ?)', Encrypter.encrypt(discordId), Encrypter.hash(discordId), githubUsername);
|
|
}
|
|
|
|
static async getDiscordIdFromGithub(githubUsername: string): Promise<string | null> {
|
|
const mapping = await Database.db.get<Pick<GithubUserMapping, 'discord_id'>>('SELECT discord_id FROM github_user_mapping WHERE github_username = ?', githubUsername);
|
|
|
|
return mapping?.discord_id ? Encrypter.decrypt(mapping.discord_id) : null;
|
|
}
|
|
|
|
static async getGithubFromDiscordId(discordId: string): Promise<string | null> {
|
|
const mapping = await Database.db.get<Pick<GithubUserMapping, 'github_username'>>('SELECT github_username FROM github_user_mapping WHERE discord_id_hash = ?', Encrypter.hash(discordId));
|
|
|
|
return mapping?.github_username ?? null;
|
|
}
|
|
|
|
static async getAllGithubUserMappings(): Promise<GithubUserMapping[]> {
|
|
const mappings: GithubUserMapping[] = await Database.db.all<GithubUserMapping[]>('SELECT * from github_user_mapping');
|
|
return mappings.map((mapping) => {
|
|
return {
|
|
...mapping,
|
|
discord_id: Encrypter.decrypt(mapping.discord_id)
|
|
};
|
|
});
|
|
}
|
|
|
|
static async removeGithubUserMapping(discordId: string) {
|
|
await Database.db.run('DELETE from github_user_mapping WHERE discord_id_hash = ?', Encrypter.encrypt(discordId));
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//# Knowledgebase
|
|
|
|
static async addToKnowledgebase(guildId: string, name: string, content: string) {
|
|
if (content.length > 2000) return;
|
|
|
|
await Database.db.run('INSERT INTO knowledgebase(guild_id, name, content) VALUES (?, ?, ?)', guildId, name, content);
|
|
}
|
|
|
|
static async removeFromKnowledgebase(id: number) {
|
|
await Database.db.run('DELETE from knowledgebase WHERE id = ?', id);
|
|
}
|
|
|
|
static async editKnowledgebaseItem(id: number, content: string) {
|
|
if (content.length > 2000) return;
|
|
|
|
await Database.db.run('UPDATE knowledgebase SET content = ? WHERE id = ?', content, id);
|
|
}
|
|
|
|
static async getFromKnowledgebaseByName(guildId: string, name: string): Promise<KnowledgebaseItem | undefined> {
|
|
return await Database.db.get<KnowledgebaseItem>('SELECT * from knowledgebase WHERE guild_id = ? AND name = ?', guildId, name);
|
|
}
|
|
|
|
static async getFromKnowledgebase(id: number): Promise<KnowledgebaseItem | undefined> {
|
|
return await Database.db.get<KnowledgebaseItem>('SELECT * from knowledgebase WHERE id = ?', id);
|
|
}
|
|
|
|
static async getAllKnowledgebaseItems(guildId: string): Promise<KnowledgebaseItem[]> {
|
|
return await Database.db.all<KnowledgebaseItem[]>('SELECT * from knowledgebase WHERE guild_id = ?', guildId);
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Private Help Tickets
|
|
|
|
static async createPrivateHelpTicket(userId: string, threadId: string) {
|
|
await Database.db.run('INSERT INTO private_help_tickets(user_id, user_id_hash, thread_id, status) VALUES (?, ?, ?, ?)', Encrypter.encrypt(userId), Encrypter.hash(userId), threadId, PrivateHelpTicketStatus.OPEN);
|
|
}
|
|
|
|
static async closePrivateHelpTicket(threadId: string) {
|
|
await Database.db.run('UPDATE private_help_tickets SET status = ? WHERE thread_id = ?', PrivateHelpTicketStatus.CLOSED, threadId);
|
|
}
|
|
|
|
static async getLatestPrivateHelpTicketBy(userId: string): Promise<PrivateHelpTicket | undefined> {
|
|
return await Database.db.get<PrivateHelpTicket>('SELECT * from private_help_tickets WHERE user_id_hash = ? ORDER BY timestamp DESC LIMIT 1', Encrypter.hash(userId));
|
|
}
|
|
|
|
static async getAllOpenPrivateHelpTickets(): Promise<PrivateHelpTicket[]> {
|
|
const tickets: PrivateHelpTicket[] = await Database.db.all<PrivateHelpTicket[]>('SELECT * from private_help_tickets WHERE status = ?', PrivateHelpTicketStatus.OPEN);
|
|
return tickets.map((ticket) => {
|
|
return {
|
|
...ticket,
|
|
user_id: Encrypter.decrypt(ticket.user_id)
|
|
};
|
|
});
|
|
}
|
|
|
|
//#endregion
|
|
|
|
//#region Role Buttons
|
|
|
|
static async putRoleButton(messageId: string, roleId: string) {
|
|
await Database.db.run('INSERT INTO role_buttons(message_id, role_id) VALUES (?, ?)', messageId, roleId);
|
|
}
|
|
|
|
static async getRoleFromButton(messageId: string): Promise<string | null> {
|
|
const data = await Database.db.get<Pick<RoleButton, 'role_id'>>('SELECT role_id from role_buttons WHERE message_id = ?', messageId);
|
|
|
|
return data?.role_id ?? null;
|
|
}
|
|
|
|
|
|
//#endregion
|
|
}
|