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");
const AFKEngine = require("./AFKEngine");
const Starboard = require("./Starboard");
const { runTimeouts, setTimeoutv2 } = require("./setTimeout");
const autoRole = require("./AutoRole");

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,
                Intents.FLAGS.GUILD_MESSAGE_REACTIONS,
                Intents.FLAGS.GUILD_EMOJIS_AND_STICKERS,
            ]
        });

        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.afkEngine = new AFKEngine();
        this.starboard = new Starboard();
        this.boot();
    }

    boot() {
        const events = {
            MESSAGE_REACTION_ADD: 'messageReactionAdd',
        };
        
        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();
            
            runTimeouts();

            // setTimeoutv2(path.resolve(__dirname, '../queues/send.js'), 10000, "Hello world");
        });

        this.on('raw', async event => {
            if (!events.hasOwnProperty(event.t))
                return;
        
            const { d: data } = event;
            const user = this.client.users.cache.find(i => i.id === data.user_id);
            const channel = this.client.channels.cache.find(i => i.id === data.channel_id) || await user.createDM();
        
            if (channel.messages.cache.has(data.message_id)) 
                return;
        
            const message = await channel.messages.fetch(data.message_id);
        
            const emojiKey = (data.emoji.id) ? `${data.emoji.name}:${data.emoji.id}` : data.emoji.name;
            const reaction = message.reactions.cache.get(emojiKey);
        
            this.client.emit(events[event.t], reaction, user);
        });

        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,
                    files: snippet.files.map(f => {
                        return {
                            attachment: path.resolve(__dirname, '..', 'storage', f)
                        }
                    })
                });
            }
            else if (valid && !has) {
                await this.commandManager.notFound();
            }
            else if (valid && has && !allowed) {
                await this.commandManager.notAllowed();
            }
            else if(!valid) {
                await this.afkEngine.start(message);
            }
        });

        this.on("messageUpdate", async (oldMessage, newMessage) => {
            if (oldMessage.author.bot || !oldMessage.guild || oldMessage.channel.type == 'dm' || oldMessage.content === newMessage.content)
                return;

            let msg = await this.msg;
            await (this.msg = newMessage);
        
            await this.spamFilter.basic(newMessage);
            await this.messageFilter.start(newMessage, this.commandManager);

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

        this.on("messageReactionAdd", async (reaction, message) => {
            console.log('inside');

            if (!reaction || !reaction.message || !message.guild || message.channel.type == 'dm') {
                return;
            }
            
            await (this.msg = reaction.message);
            await this.starboard.handle(reaction, message);
        });

        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 || !message.guild || message.channel.type == 'dm')
                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 autoRole(member, member.guild);
            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	const AFKEngine = require("./AFKEngine");
15	const Starboard = require("./Starboard");
16	const { runTimeouts, setTimeoutv2 } = require("./setTimeout");
17	const autoRole = require("./AutoRole");
18
19	class App {
20	constructor(rootdir) {
21	global.app = App.app = this;
22	this.rootdir = rootdir;
23	this.loadConfig();
24	this.env = process.env;
25
26	this.client = new Client({
27	partials: ["CHANNEL"],
28	intents: [
29	Intents.FLAGS.GUILDS,
30	Intents.FLAGS.GUILD_MESSAGES,
31	Intents.FLAGS.DIRECT_MESSAGES,
32	Intents.FLAGS.DIRECT_MESSAGE_TYPING,
33	Intents.FLAGS.GUILD_PRESENCES,
34	Intents.FLAGS.GUILD_MEMBERS,
35	Intents.FLAGS.GUILD_BANS,
36	Intents.FLAGS.GUILD_MESSAGE_REACTIONS,
37	Intents.FLAGS.GUILD_EMOJIS_AND_STICKERS,
38	]
39	});
40
41	this.config = new Config();
42	this.db = new Database(path.resolve(__dirname, '..', 'database.db'));
43	this.commandManager = new CommandManager(path.resolve(__dirname, rootdir, "commands"));
44	this.logger = new Logger();
45	this.spamFilter = new SpamFilter();
46	this.antiRaid = new AntiRaid();
47	this.messageFilter = new MessageFilter();
48	this.afkEngine = new AFKEngine();
49	this.starboard = new Starboard();
50	this.boot();
51	}
52
53	boot() {
54	const events = {
55	MESSAGE_REACTION_ADD: 'messageReactionAdd',
56	};
57
58	this.on('ready', () => {
59	console.log("Logged in as " + this.client.user.tag);
60
61	this.client.user.setStatus(random(['dnd', 'idle']));
62	this.client.user.setActivity("over the server", { type: "WATCHING" });
63
64	server();
65
66	runTimeouts();
67
68	// setTimeoutv2(path.resolve(__dirname, '../queues/send.js'), 10000, "Hello world");
69	});
70
71	this.on('raw', async event => {
72	if (!events.hasOwnProperty(event.t))
73	return;
74
75	const { d: data } = event;
76	const user = this.client.users.cache.find(i => i.id === data.user_id);
77	const channel = this.client.channels.cache.find(i => i.id === data.channel_id) \|\| await user.createDM();
78
79	if (channel.messages.cache.has(data.message_id))
80	return;
81
82	const message = await channel.messages.fetch(data.message_id);
83
84	const emojiKey = (data.emoji.id) ? `${data.emoji.name}:${data.emoji.id}` : data.emoji.name;
85	const reaction = message.reactions.cache.get(emojiKey);
86
87	this.client.emit(events[event.t], reaction, user);
88	});
89
90	this.on('messageCreate', async (message) => {
91	if (message.author.bot \|\| !message.guild \|\| message.channel.type == 'dm') {
92	return;
93	}
94
95	await (this.msg = message);
96
97	await this.spamFilter.start(message);
98	await this.messageFilter.start(message, this.commandManager);
99
100	await this.commandManager.setMessage(message);
101
102	const valid = await this.commandManager.valid();
103	const has = await this.commandManager.has();
104	const snippet = await this.commandManager.snippet();
105	const allowed = await this.commandManager.verify();
106
107	if (valid && has && allowed) {
108	await this.exec();
109	}
110	else if (valid && snippet !== undefined) {
111	await message.channel.send({
112	content: snippet.content,
113	files: snippet.files.map(f => {
114	return {
115	attachment: path.resolve(__dirname, '..', 'storage', f)
116	}
117	})
118	});
119	}
120	else if (valid && !has) {
121	await this.commandManager.notFound();
122	}
123	else if (valid && has && !allowed) {
124	await this.commandManager.notAllowed();
125	}
126	else if(!valid) {
127	await this.afkEngine.start(message);
128	}
129	});
130
131	this.on("messageUpdate", async (oldMessage, newMessage) => {
132	if (oldMessage.author.bot \|\| !oldMessage.guild \|\| oldMessage.channel.type == 'dm' \|\| oldMessage.content === newMessage.content)
133	return;
134
135	let msg = await this.msg;
136	await (this.msg = newMessage);
137
138	await this.spamFilter.basic(newMessage);
139	await this.messageFilter.start(newMessage, this.commandManager);
140
141	await this.logger.logEdit(oldMessage, newMessage);
142	await (this.msg = msg);
143	});
144
145	this.on("messageReactionAdd", async (reaction, message) => {
146	console.log('inside');
147
148	if (!reaction \|\| !reaction.message \|\| !message.guild \|\| message.channel.type == 'dm') {
149	return;
150	}
151
152	await (this.msg = reaction.message);
153	await this.starboard.handle(reaction, message);
154	});
155
156	this.on('guildBanAdd', async (ban) => {
157	console.log('test');
158	await this.logger.logBanned(ban);
159	});
160
161	this.on('guildBanRemove', async (ban) => {
162	console.log('test');
163	await this.logger.logUnbanned(ban);
164	});
165
166	this.on("messageDelete", async (message) => {
167	if (message.author.bot \|\| !message.guild \|\| message.channel.type == 'dm')
168	return;
169
170	await this.logger.logDelete(message);
171	});
172
173	this.on("guildCreate", guild => {
174	console.log("Joined a new guild: " + guild.name);
175
176	this.config.props[guild.id] = {
177	prefix: "-",
178	debug: false,
179	};
180
181	this.config.write();
182	})
183
184	this.on("guildDelete", guild => {
185	console.log("Left a guild: " + guild.name);
186	delete this.config.props[guild.id];
187	this.config.write();
188	})
189
190	this.on('guildMemberAdd', async (member) => {
191	console.log('Joined');
192	await autoRole(member, member.guild);
193	await this.antiRaid.start(member);
194	await this.logger.logJoined(member);
195	});
196
197	this.on('guildMemberRemove', async (member) => {
198	await this.logger.logLeft(member);
199	});
200	}
201
202	loadConfig() {
203	if (fs.existsSync(path.join(__dirname, this.rootdir, '.env'))) {
204	console.log("Loading .env file");
205	config();
206	}
207	}
208
209	on(event, handler) {
210	this.client.on(event, handler);
211	}
212
213	exec() {
214	this.commandManager.exec();
215	}
216
217	run() {
218	this.client.login(process.env.TOKEN);
219	}
220
221	tempFileCreate(name) {
222	const fullname = path.join(__dirname, '..', 'tmp', name);
223	const file = fs.createWriteStream(fullname);
224
225	return {
226	name: fullname,
227	file
228	};
229	}
230	}
231
232	module.exports = App;