api/routes/misc-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/misc/:guild',
    middleware: [guildAuth],
    async post(req: Request, res: Response) {
        console.log('log');
        
        const dataArray = await z.array(z.string());

        const Config = await z.object({
            prefix: z.string(),
            debug: z.boolean(),
            starboard: z.object({
                enabled: z.boolean(),
                reactions: z.number().int(),
                channel: z.string()
            }),
            autorole: z.object({
                enabled: z.boolean(),
                roles: dataArray
            }),
            warn_notallowed: z.boolean(),
            global_commands: dataArray,
            role_commands: z.any(),
        });

        console.log(req.body.data);        

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

            return;
        }

        const { data: body } = req.body;        

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

            return;
        }

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

                return;
            }
        }

        for (const cmd of body.global_commands) {
            if (!DiscordClient.client.commands.has(cmd)) {
                res.status(422).json({
                    status: 422,
                    message: "Invalid command"
                });
    
                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;
            }

            console.log(roleID, body.role_commands[roleID]);
        }

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

        const current = {
            ...DiscordClient.client.config.props[req.params.guild],
            ...body
        };

        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/misc/:guild',
11	middleware: [guildAuth],
12	async post(req: Request, res: Response) {
13	console.log('log');
14
15	const dataArray = await z.array(z.string());
16
17	const Config = await z.object({
18	prefix: z.string(),
19	debug: z.boolean(),
20	starboard: z.object({
21	enabled: z.boolean(),
22	reactions: z.number().int(),
23	channel: z.string()
24	}),
25	autorole: z.object({
26	enabled: z.boolean(),
27	roles: dataArray
28	}),
29	warn_notallowed: z.boolean(),
30	global_commands: dataArray,
31	role_commands: z.any(),
32	});
33
34	console.log(req.body.data);
35
36	if (!req.body.data \|\| !Config.safeParse(req.body.data).success) {
37	res.status(422).json({
38	status: 422,
39	message: "Unprocessable entity"
40	});
41
42	return;
43	}
44
45	const { data: body } = req.body;
46
47	if (
48	!await isChannel(body.starboard.channel, req.params.guild)
49	) {
50	res.status(422).json({
51	status: 422,
52	message: "Invalid channels"
53	});
54
55	return;
56	}
57
58	for (const roleID of body.autorole.roles) {
59	if (!await isRole(roleID, req.params.guild)) {
60	res.status(422).json({
61	status: 422,
62	message: "Invalid roles"
63	});
64
65	return;
66	}
67	}
68
69	for (const cmd of body.global_commands) {
70	if (!DiscordClient.client.commands.has(cmd)) {
71	res.status(422).json({
72	status: 422,
73	message: "Invalid command"
74	});
75
76	return;
77	}
78	}
79
80	for (const roleID in body.role_commands) {
81	if (!await isRole(roleID, req.params.guild)) {
82	res.status(422).json({
83	status: 422,
84	message: "Invalid roles (2)"
85	});
86
87	return;
88	}
89
90	console.log(roleID, body.role_commands[roleID]);
91	}
92
93	const previous = {...DiscordClient.client.config.props[req.params.guild]};
94
95	const current = {
96	...DiscordClient.client.config.props[req.params.guild],
97	...body
98	};
99
100	DiscordClient.client.config.props[req.params.guild] = current;
101	DiscordClient.client.config.write();
102
103	await res.json({
104	previous,
105	current,
106	input: req.body
107	});
108	}
109	};