api/routes/mod-config.ts

import { Request, Response } from "express";
import DiscordClient from "../../client/Client";
import auth from "../Auth";
import guildAuth from "../GuildAuth";
import { Route } from "../Router";
import { z } from 'zod';
import { isChannel, isRole } from "../Validator";

export default <Route> {
    path: '/config/mod/:guild',
    middleware: [guildAuth],
    async post(req: Request, res: Response) {
        const dataArray = await z.array(z.string());

        const Config = await z.object({
            mute_role: z.string(),
            gen_role: z.string(),
            logging_channel: z.string(),
            logging_channel_join_leave: z.string(),
            mod_role: z.string(),
            announcement_channel: z.string(),
            spam_filter: z.object({
                enabled: z.boolean(),
                limit: z.number().int(),
                time: z.number(),
                diff: z.number(),
                exclude: dataArray,
                samelimit: z.number().int(),
                unmute_in: z.number()
            }),
            raid: z.object({
                enabled: z.boolean(),
                max_joins: z.number().int(),
                time: z.number(),
                channels: dataArray,
                exclude: z.boolean()
            }),
            lockall: dataArray,
            // warn_notallowed: z.boolean(),
            // global_commands: dataArray,
            // role_commands: z.any(),
            filters: z.object({
                ignore_staff: z.boolean(),
                words_enabled: z.boolean(),
                invite_enabled: z.boolean(),
                regex: z.boolean(),
                chars_repeated: z.number().int(),
                words_repeated: z.number().int(),
                words: dataArray,
                invite_message: z.string(),
                words_excluded: dataArray,
                invite_excluded: dataArray,
                file_mimes_excluded: dataArray,
                file_types_excluded: dataArray
            })
        });

        console.log(req.body.data);        
        const parsed = Config.safeParse(req.body.data);

        if (!req.body.data || !parsed.success) {
            console.log(parsed);
            
            res.status(422).json({
                status: 422,
                message: "Unprocessable entity"
            });

            return;
        }

        const { data: body } = req.body;      

        if (
            !(await isRole(body.mod_role, req.params.guild)) ||
            !(await isRole(body.gen_role, req.params.guild)) ||
            !(await isRole(body.mute_role, req.params.guild))
        ) {
            res.status(422).json({
                status: 422,
                message: "Invalid roles"
            });

            return;
        }

        // for (const roleID in body.role_commands) {
        //     if (!await isRole(roleID, req.params.guild)) {
        //         res.status(422).json({
        //             status: 422,
        //             message: "Invalid roles (2)"
        //         });

        //         return;
        //     }
        // }

        await console.log(body.logging_channel, await isChannel(body.logging_channel, req.params.guild));
        

        if (
            !await isChannel(body.logging_channel, req.params.guild) ||
            !await isChannel(body.logging_channel_join_leave, req.params.guild) ||
            !await isChannel(body.announcement_channel, req.params.guild)
        ) {
            res.status(422).json({
                status: 422,
                message: "Invalid channels"
            });

            return;
        }
        
        const { spam_filter, raid, filters } = body;

        for (const id of body.spam_filter.exclude) {
            if (!await isChannel(id, req.params.guild)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid channels (2)"
                });
    
                return;
            }
        }

        for (const id of raid.channels) {
            if (!await isChannel(id, req.params.guild)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid channels (3)"
                });
    
                return;
            }
        }

        for (const id of body.lockall) {
            if (!await isChannel(id, req.params.guild)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid channels (4)"
                });
    
                return;
            }
        }

        for (const id of filters.words_excluded) {
            if (!await isChannel(id, req.params.guild)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid channels (5)"
                });
    
                return;
            }
        }

        for (const id of filters.invite_excluded) {
            if (!await isChannel(id, req.params.guild)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid channels (6)"
                });
    
                return;
            }
        }

        // for (const cmd of body.global_commands) {
        //     if (!DiscordClient.client.commands.has(cmd)) {
        //         res.status(422).json({
        //             status: 422,
        //             message: "Invalid command"
        //         });
    
        //         return;
        //     }
        // }

        const previous = {...DiscordClient.client.config.props[req.params.guild]};

        const current = {
            ...DiscordClient.client.config.props[req.params.guild],
            mute_role: body.mute_role,
            gen_role: body.gen_role,
            logging_channel: body.logging_channel,
            logging_channel_join_leave: body.logging_channel_join_leave,
            mod_role: body.mod_role,
            announcement_channel: body.announcement_channel,
            spam_filter: {
                enabled: spam_filter.enabled,
                limit: parseInt(spam_filter.limit),
                time: parseInt(spam_filter.time),
                diff: parseInt(spam_filter.diff),
                exclude: spam_filter.exclude,
                samelimit: parseInt(spam_filter.samelimit),
                unmute_in: spam_filter.unmute_in
            },
            raid: {
                enabled: raid.enabled,
                max_joins: parseInt(raid.max_joins),
                time: raid.time,
                channels: raid.channels,
                exclude: raid.exclude
            },
            lockall: body.lockall,
            // warn_notallowed: body.warn_notallowed,
            // global_commands: body.global_commands,
            // role_commands: body.role_commands,
            filters: {
                ...filters,
                chars_repeated: parseInt(filters.chars_repeated),
                words_repeated: parseInt(filters.words_repeated),
            }
        };

        DiscordClient.client.config.props[req.params.guild] = current;
        DiscordClient.client.config.write();

        await res.json({
            previous,
            current,
            input: req.body
        });
    }
};
1	import { Request, Response } from "express";
2	import DiscordClient from "../../client/Client";
3	import auth from "../Auth";
4	import guildAuth from "../GuildAuth";
5	import { Route } from "../Router";
6	import { z } from 'zod';
7	import { isChannel, isRole } from "../Validator";
8
9	export default <Route> {
10	path: '/config/mod/:guild',
11	middleware: [guildAuth],
12	async post(req: Request, res: Response) {
13	const dataArray = await z.array(z.string());
14
15	const Config = await z.object({
16	mute_role: z.string(),
17	gen_role: z.string(),
18	logging_channel: z.string(),
19	logging_channel_join_leave: z.string(),
20	mod_role: z.string(),
21	announcement_channel: z.string(),
22	spam_filter: z.object({
23	enabled: z.boolean(),
24	limit: z.number().int(),
25	time: z.number(),
26	diff: z.number(),
27	exclude: dataArray,
28	samelimit: z.number().int(),
29	unmute_in: z.number()
30	}),
31	raid: z.object({
32	enabled: z.boolean(),
33	max_joins: z.number().int(),
34	time: z.number(),
35	channels: dataArray,
36	exclude: z.boolean()
37	}),
38	lockall: dataArray,
39	// warn_notallowed: z.boolean(),
40	// global_commands: dataArray,
41	// role_commands: z.any(),
42	filters: z.object({
43	ignore_staff: z.boolean(),
44	words_enabled: z.boolean(),
45	invite_enabled: z.boolean(),
46	regex: z.boolean(),
47	chars_repeated: z.number().int(),
48	words_repeated: z.number().int(),
49	words: dataArray,
50	invite_message: z.string(),
51	words_excluded: dataArray,
52	invite_excluded: dataArray,
53	file_mimes_excluded: dataArray,
54	file_types_excluded: dataArray
55	})
56	});
57
58	console.log(req.body.data);
59	const parsed = Config.safeParse(req.body.data);
60
61	if (!req.body.data \|\| !parsed.success) {
62	console.log(parsed);
63
64	res.status(422).json({
65	status: 422,
66	message: "Unprocessable entity"
67	});
68
69	return;
70	}
71
72	const { data: body } = req.body;
73
74	if (
75	!(await isRole(body.mod_role, req.params.guild)) \|\|
76	!(await isRole(body.gen_role, req.params.guild)) \|\|
77	!(await isRole(body.mute_role, req.params.guild))
78	) {
79	res.status(422).json({
80	status: 422,
81	message: "Invalid roles"
82	});
83
84	return;
85	}
86
87	// for (const roleID in body.role_commands) {
88	// if (!await isRole(roleID, req.params.guild)) {
89	// res.status(422).json({
90	// status: 422,
91	// message: "Invalid roles (2)"
92	// });
93
94	// return;
95	// }
96	// }
97
98	await console.log(body.logging_channel, await isChannel(body.logging_channel, req.params.guild));
99
100
101	if (
102	!await isChannel(body.logging_channel, req.params.guild) \|\|
103	!await isChannel(body.logging_channel_join_leave, req.params.guild) \|\|
104	!await isChannel(body.announcement_channel, req.params.guild)
105	) {
106	res.status(422).json({
107	status: 422,
108	message: "Invalid channels"
109	});
110
111	return;
112	}
113
114	const { spam_filter, raid, filters } = body;
115
116	for (const id of body.spam_filter.exclude) {
117	if (!await isChannel(id, req.params.guild)) {
118	res.status(422).json({
119	status: 422,
120	message: "Invalid channels (2)"
121	});
122
123	return;
124	}
125	}
126
127	for (const id of raid.channels) {
128	if (!await isChannel(id, req.params.guild)) {
129	res.status(422).json({
130	status: 422,
131	message: "Invalid channels (3)"
132	});
133
134	return;
135	}
136	}
137
138	for (const id of body.lockall) {
139	if (!await isChannel(id, req.params.guild)) {
140	res.status(422).json({
141	status: 422,
142	message: "Invalid channels (4)"
143	});
144
145	return;
146	}
147	}
148
149	for (const id of filters.words_excluded) {
150	if (!await isChannel(id, req.params.guild)) {
151	res.status(422).json({
152	status: 422,
153	message: "Invalid channels (5)"
154	});
155
156	return;
157	}
158	}
159
160	for (const id of filters.invite_excluded) {
161	if (!await isChannel(id, req.params.guild)) {
162	res.status(422).json({
163	status: 422,
164	message: "Invalid channels (6)"
165	});
166
167	return;
168	}
169	}
170
171	// for (const cmd of body.global_commands) {
172	// if (!DiscordClient.client.commands.has(cmd)) {
173	// res.status(422).json({
174	// status: 422,
175	// message: "Invalid command"
176	// });
177
178	// return;
179	// }
180	// }
181
182	const previous = {...DiscordClient.client.config.props[req.params.guild]};
183
184	const current = {
185	...DiscordClient.client.config.props[req.params.guild],
186	mute_role: body.mute_role,
187	gen_role: body.gen_role,
188	logging_channel: body.logging_channel,
189	logging_channel_join_leave: body.logging_channel_join_leave,
190	mod_role: body.mod_role,
191	announcement_channel: body.announcement_channel,
192	spam_filter: {
193	enabled: spam_filter.enabled,
194	limit: parseInt(spam_filter.limit),
195	time: parseInt(spam_filter.time),
196	diff: parseInt(spam_filter.diff),
197	exclude: spam_filter.exclude,
198	samelimit: parseInt(spam_filter.samelimit),
199	unmute_in: spam_filter.unmute_in
200	},
201	raid: {
202	enabled: raid.enabled,
203	max_joins: parseInt(raid.max_joins),
204	time: raid.time,
205	channels: raid.channels,
206	exclude: raid.exclude
207	},
208	lockall: body.lockall,
209	// warn_notallowed: body.warn_notallowed,
210	// global_commands: body.global_commands,
211	// role_commands: body.role_commands,
212	filters: {
213	...filters,
214	chars_repeated: parseInt(filters.chars_repeated),
215	words_repeated: parseInt(filters.words_repeated),
216	}
217	};
218
219	DiscordClient.client.config.props[req.params.guild] = current;
220	DiscordClient.client.config.write();
221
222	await res.json({
223	previous,
224	current,
225	input: req.body
226	});
227	}
228	};