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(),
            autoclear: z.object({
                enabled: z.boolean(),
                channels: dataArray
            }),
            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, autoclear } = body;

        console.log(autoclear);        

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