trunk/src/App.js

const { Client, Intents } = require("discord.js");
const { config } = require("dotenv");
const CommandManager = require("./CommandManager");
const path = require("path");
const fs = require("fs");
const Config = require("./Config");
const Database = require("./Database");
const Logger = require("./Logger");
const SpamFilter = require("./SpamFilter");
const server = require("./server");
const AntiRaid = require("./AntiRaid");
const MessageFilter = require("./MessageFilter");
const { random } = require("../commands/pixabay");

class App {
    constructor(rootdir) {
        global.app = App.app = this;
        this.rootdir = rootdir;
        this.loadConfig();
        this.env = process.env;

        this.client = new Client({
            partials: ["CHANNEL"],
            intents: [
                Intents.FLAGS.GUILDS,
                Intents.FLAGS.GUILD_MESSAGES,
                Intents.FLAGS.DIRECT_MESSAGES, 
                Intents.FLAGS.DIRECT_MESSAGE_TYPING,
                Intents.FLAGS.GUILD_PRESENCES,
                Intents.FLAGS.GUILD_MEMBERS,
                Intents.FLAGS.GUILD_BANS
            ]
        });

        this.config = new Config();
        this.db = new Database(path.resolve(__dirname, '..', 'database.db'));
        this.commandManager = new CommandManager(path.resolve(__dirname, rootdir, "commands"));
        this.logger = new Logger();
        this.spamFilter = new SpamFilter();
        this.antiRaid = new AntiRaid();
        this.messageFilter = new MessageFilter();
        this.boot();
    }

    boot() {
        this.on('ready', () => {
            console.log("Logged in as " + this.client.user.tag);

            this.client.user.setStatus(random(['dnd', 'idle']));
            this.client.user.setActivity("over the server", { type: "WATCHING" });

            server();
        });

        this.on('messageCreate', async (message) => {
            if (message.author.bot || !message.guild || message.channel.type == 'dm') {
                return;
            }

            await (this.msg = message);
            
            await this.spamFilter.start(message);
            await this.messageFilter.start(message, this.commandManager);

            await this.commandManager.setMessage(message);

            const valid = await this.commandManager.valid();
            const has = await this.commandManager.has();
            const snippet = await this.commandManager.snippet();
            const allowed = await this.commandManager.verify();
            
            if (valid && has && allowed) {
                await this.exec();
            }
            else if (valid && snippet !== undefined) {
                await message.channel.send({
                    content: snippet.content
                });
            }
            else if (valid && !has) {
                await this.commandManager.notFound();
            }
            else if (valid && has && !allowed) {
                await this.commandManager.notAllowed();
            }
        });

        this.on("messageUpdate", async (oldMessage, newMessage) => {
            if (oldMessage.author.bot || oldMessage.content === newMessage.content)
                return;

            await this.logger.logEdit(oldMessage, newMessage);
        });


        this.on('guildBanAdd', async (ban) => {
            console.log('test');
            await this.logger.logBanned(ban);
        });

        this.on('guildBanRemove', async (ban) => {
            console.log('test');
            await this.logger.logUnbanned(ban);
        });

        this.on("messageDelete", async (message) => {
            if (message.author.bot)
                return;

            await this.logger.logDelete(message);
        });

        this.on("guildCreate", guild => {
            console.log("Joined a new guild: " + guild.name);

            this.config.props[guild.id] = {
                prefix: "-",
                debug: false,
            };

            this.config.write();
        })
        
        this.on("guildDelete", guild => {
            console.log("Left a guild: " + guild.name);
            delete this.config.props[guild.id];
            this.config.write();
        })

        this.on('guildMemberAdd', async (member) => {
            console.log('Joined');
            await this.antiRaid.start(member);
            await this.logger.logJoined(member);
        });

        this.on('guildMemberRemove', async (member) => {
            await this.logger.logLeft(member);
        });
    }

    loadConfig() {
        if (fs.existsSync(path.join(__dirname, this.rootdir, '.env'))) {
            console.log("Loading .env file");
            config();
        }
    }

    on(event, handler) {
        this.client.on(event, handler);
    }

    exec() {
        this.commandManager.exec();
    }

    run() {
        this.client.login(process.env.TOKEN);
    }

    tempFileCreate(name) {
        const fullname = path.join(__dirname, '..', 'tmp', name);
        const file = fs.createWriteStream(fullname);

        return {
            name: fullname,
            file
        };
    }
}

module.exports = App;
1	const { Client, Intents } = require("discord.js");
2	const { config } = require("dotenv");
3	const CommandManager = require("./CommandManager");
4	const path = require("path");
5	const fs = require("fs");
6	const Config = require("./Config");
7	const Database = require("./Database");
8	const Logger = require("./Logger");
9	const SpamFilter = require("./SpamFilter");
10	const server = require("./server");
11	const AntiRaid = require("./AntiRaid");
12	const MessageFilter = require("./MessageFilter");
13	const { random } = require("../commands/pixabay");
14
15	class App {
16	constructor(rootdir) {
17	global.app = App.app = this;
18	this.rootdir = rootdir;
19	this.loadConfig();
20	this.env = process.env;
21
22	this.client = new Client({
23	partials: ["CHANNEL"],
24	intents: [
25	Intents.FLAGS.GUILDS,
26	Intents.FLAGS.GUILD_MESSAGES,
27	Intents.FLAGS.DIRECT_MESSAGES,
28	Intents.FLAGS.DIRECT_MESSAGE_TYPING,
29	Intents.FLAGS.GUILD_PRESENCES,
30	Intents.FLAGS.GUILD_MEMBERS,
31	Intents.FLAGS.GUILD_BANS
32	]
33	});
34
35	this.config = new Config();
36	this.db = new Database(path.resolve(__dirname, '..', 'database.db'));
37	this.commandManager = new CommandManager(path.resolve(__dirname, rootdir, "commands"));
38	this.logger = new Logger();
39	this.spamFilter = new SpamFilter();
40	this.antiRaid = new AntiRaid();
41	this.messageFilter = new MessageFilter();
42	this.boot();
43	}
44
45	boot() {
46	this.on('ready', () => {
47	console.log("Logged in as " + this.client.user.tag);
48
49	this.client.user.setStatus(random(['dnd', 'idle']));
50	this.client.user.setActivity("over the server", { type: "WATCHING" });
51
52	server();
53	});
54
55	this.on('messageCreate', async (message) => {
56	if (message.author.bot \|\| !message.guild \|\| message.channel.type == 'dm') {
57	return;
58	}
59
60	await (this.msg = message);
61
62	await this.spamFilter.start(message);
63	await this.messageFilter.start(message, this.commandManager);
64
65	await this.commandManager.setMessage(message);
66
67	const valid = await this.commandManager.valid();
68	const has = await this.commandManager.has();
69	const snippet = await this.commandManager.snippet();
70	const allowed = await this.commandManager.verify();
71
72	if (valid && has && allowed) {
73	await this.exec();
74	}
75	else if (valid && snippet !== undefined) {
76	await message.channel.send({
77	content: snippet.content
78	});
79	}
80	else if (valid && !has) {
81	await this.commandManager.notFound();
82	}
83	else if (valid && has && !allowed) {
84	await this.commandManager.notAllowed();
85	}
86	});
87
88	this.on("messageUpdate", async (oldMessage, newMessage) => {
89	if (oldMessage.author.bot \|\| oldMessage.content === newMessage.content)
90	return;
91
92	await this.logger.logEdit(oldMessage, newMessage);
93	});
94
95
96	this.on('guildBanAdd', async (ban) => {
97	console.log('test');
98	await this.logger.logBanned(ban);
99	});
100
101	this.on('guildBanRemove', async (ban) => {
102	console.log('test');
103	await this.logger.logUnbanned(ban);
104	});
105
106	this.on("messageDelete", async (message) => {
107	if (message.author.bot)
108	return;
109
110	await this.logger.logDelete(message);
111	});
112
113	this.on("guildCreate", guild => {
114	console.log("Joined a new guild: " + guild.name);
115
116	this.config.props[guild.id] = {
117	prefix: "-",
118	debug: false,
119	};
120
121	this.config.write();
122	})
123
124	this.on("guildDelete", guild => {
125	console.log("Left a guild: " + guild.name);
126	delete this.config.props[guild.id];
127	this.config.write();
128	})
129
130	this.on('guildMemberAdd', async (member) => {
131	console.log('Joined');
132	await this.antiRaid.start(member);
133	await this.logger.logJoined(member);
134	});
135
136	this.on('guildMemberRemove', async (member) => {
137	await this.logger.logLeft(member);
138	});
139	}
140
141	loadConfig() {
142	if (fs.existsSync(path.join(__dirname, this.rootdir, '.env'))) {
143	console.log("Loading .env file");
144	config();
145	}
146	}
147
148	on(event, handler) {
149	this.client.on(event, handler);
150	}
151
152	exec() {
153	this.commandManager.exec();
154	}
155
156	run() {
157	this.client.login(process.env.TOKEN);
158	}
159
160	tempFileCreate(name) {
161	const fullname = path.join(__dirname, '..', 'tmp', name);
162	const file = fs.createWriteStream(fullname);
163
164	return {
165	name: fullname,
166	file
167	};
168	}
169	}
170
171	module.exports = App;