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",
                trace: Config.safeParse(req.body.data)
            });

            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	trace: Config.safeParse(req.body.data)
41	});
42
43	return;
44	}
45
46	const { data: body } = req.body;
47
48	if (
49	!await isChannel(body.starboard.channel, req.params.guild)
50	) {
51	res.status(422).json({
52	status: 422,
53	message: "Invalid channels"
54	});
55
56	return;
57	}
58
59	for (const roleID of body.autorole.roles) {
60	if (!await isRole(roleID, req.params.guild)) {
61	res.status(422).json({
62	status: 422,
63	message: "Invalid roles"
64	});
65
66	return;
67	}
68	}
69
70	for (const cmd of body.global_commands) {
71	if (!DiscordClient.client.commands.has(cmd)) {
72	res.status(422).json({
73	status: 422,
74	message: "Invalid command"
75	});
76
77	return;
78	}
79	}
80
81	for (const roleID in body.role_commands) {
82	if (!await isRole(roleID, req.params.guild)) {
83	res.status(422).json({
84	status: 422,
85	message: "Invalid roles (2)"
86	});
87
88	return;
89	}
90
91	console.log(roleID, body.role_commands[roleID]);
92	}
93
94	const previous = {...DiscordClient.client.config.props[req.params.guild]};
95
96	const current = {
97	...DiscordClient.client.config.props[req.params.guild],
98	...body
99	};
100
101	DiscordClient.client.config.props[req.params.guild] = current;
102	DiscordClient.client.config.write();
103
104	await res.json({
105	previous,
106	current,
107	input: req.body
108	});
109	}
110	};