api/controllers/ConfigController.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* SudoBot is free software; you can redistribute it and/or modify it
* under the terms of the GNU Affero General Public License as published by 
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
* 
* SudoBot is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License 
* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
*/

import { dot, object } from "dot-object";
import { body } from "express-validator";
import { z as zod } from "zod";
import KeyValuePair from "../../types/KeyValuePair";
import Controller from "../Controller";
import RequireAuth from "../middleware/RequireAuth";
import ValidatorError from "../middleware/ValidatorError";
import Request from "../Request";
import merge from 'ts-deepmerge';

export default class ConfigController extends Controller {
    globalMiddleware(): Function[] {
        return [RequireAuth, ValidatorError];
    }

    middleware(): KeyValuePair<Function[]> {
        return {
            update: [
                body(["config"]).isObject()
            ]
        };
    }

    private zodSchema(id: string) {
        const snowflake = zod.string().regex(/\d+/, { message: "The given value is not a Snowflake" });
        const config = this.client.config.props[id];

        const schema = zod.object({
            "prefix": zod.string().optional(),
            "debug": zod.boolean().optional(),
            "mute_role": snowflake.optional(),
            "gen_role": snowflake.optional(),
            "logging_channel": snowflake.optional(),
            "logging_channel_join_leave": snowflake.optional(),
            "mod_role": snowflake.optional(),
            "announcement_channel": snowflake.optional(),
            "admin": snowflake.optional(),
            "lockall": zod.array(zod.string()).optional(),
            "warn_notallowed": zod.boolean().optional(),
            "role_commands": zod.record(
                snowflake,
                zod.array(zod.string().min(1))
            ).optional().default({}),
            "autoclear": zod.object({
                "enabled": zod.boolean().optional(),
                "channels": zod.array(snowflake).optional().default(config.autoclear.channels)
            }).optional(),
            "verification": zod.object({
                "enabled": zod.boolean().optional(),
                "role": snowflake.optional()
            }).optional(),
            "welcomer": zod.object({
                "enabled": zod.boolean().optional(),
                "channel": snowflake.optional(),
                "message": zod.string().min(1).or(zod.null()).optional(),
                "randomize": zod.boolean().optional()
            }).optional(),
            "cooldown": zod.object({
                "enabled": zod.boolean().optional(),
                "global": zod.any().optional(),
                "cmds": zod.object({}).optional()
            }).optional(),
            "starboard": zod.object({
                "enabled": zod.boolean().optional(),
                "reactions": zod.number().int().optional(),
                "channel": snowflake.optional()
            }).optional(),
            "autorole": zod.object({
                "enabled": zod.boolean().optional(),
                "roles": zod.array(snowflake).optional().default(config.autorole.roles)
            }).optional(),
            "spam_filter": zod.object({
                "enabled": zod.boolean().optional(),
                "limit": zod.number().int().optional(),
                "time": zod.number().optional(),
                "diff": zod.number().optional(),
                "exclude": zod.array(snowflake).optional().default(config.spam_filter.exclude),
                "samelimit": zod.number().int().optional(),
                "unmute_in": zod.number().optional()
            }).optional(),
            "raid": zod.object({
                "enabled": zod.boolean().optional(),
                "max_joins": zod.number().int().optional(),
                "time": zod.number().optional(),
                "channels": zod.array(snowflake).optional().default(config.raid.channels),
                "exclude": zod.boolean().optional()
            }).optional(),
            "global_commands": zod.array(zod.string()).optional().default(config.global_commands),
            "filters": zod.object({
                "ignore_staff": zod.boolean().optional(),
                "chars_repeated": zod.number().int().optional(),
                "words_repeated": zod.number().int().optional(),
                "words": zod.array(zod.string()).optional().default(config.filters.words),
                "tokens": zod.array(zod.string()).optional().default(config.filters.tokens),
                "invite_message": zod.string().optional(),
                "words_excluded": zod.array(snowflake).optional().default(config.filters.words_excluded),
                "domain_excluded": zod.array(snowflake).optional().default(config.filters.domain_excluded),
                "invite_excluded": zod.array(snowflake).optional().default(config.filters.invite_excluded),
                "words_enabled": zod.boolean().optional(),
                "invite_enabled": zod.boolean().optional(),
                "domain_enabled": zod.boolean().optional(),
                "regex": zod.boolean().optional(),
                "file_mimes_excluded": zod.array(zod.string()).optional().default(config.filters.file_mimes_excluded),
                "file_types_excluded": zod.array(zod.string()).optional().default(config.filters.file_types_excluded),
                "domains": zod.array(zod.string()).optional().default(config.filters.domains),
                "regex_patterns": zod.array(zod.string()).optional().default(config.filters.regex_patterns),
                "rickrolls_enabled": zod.boolean().optional(),
                "pings": zod.number().int().optional()
            }).optional()
        });

        return schema;
    }

    public async index(request: Request) {
        const { id } = request.params;

        if (!request.user?.guilds.includes(id)) {
            return this.response({ error: "You don't have permission to access configuration of this guild." }, 403);
        }

        if (id === "global" || !this.client.config.props[id]) {
            return this.response({ error: "No configuration found for the given guild ID" }, 404);
        }

        return this.client.config.props[id];
    }

    public async update(request: Request) {
        const { id } = request.params;
        const { config: origconfig } = request.body;

        console.log(origconfig);        

        try {
            const currentConfigDotObject = this.client.config.props[id];
    
            console.log("Current config: ", currentConfigDotObject);

            const result = this.zodSchema(id).safeParse(object(origconfig));

            if (!result?.success) {
                return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
            }

            const config = result.data;
            const newConfig = merge.withOptions({ mergeArrays: false }, currentConfigDotObject, config);
            const result2 = this.zodSchema(id).safeParse(newConfig);

            if (!result2?.success) {
                console.log(result2.error.errors);                
                return this.response({ error: 'Internal Server Error (500)', error_type: 'internal' }, 500);
            }

            console.log('Final', newConfig);
            this.client.config.props[id] = newConfig;
            this.client.config.write();       
            return { message: "Configuration updated", previous: dot(currentConfigDotObject), new: dot(this.client.config.props[id]) };     
        }
        catch (e) {
            console.log(e);
            return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
        }
    }

    public async update2(request: Request) {
        const { id } = request.params;
        const { config: origconfig } = request.body;

        console.log(origconfig);        

        try {
            const currentConfigDotObject = dot(this.client.config.props[id]);
            let newConfigDotObject = {...currentConfigDotObject};
    
            console.log("Current config: ", currentConfigDotObject);

            const result = this.zodSchema(id).safeParse(object({...origconfig}));

            if (!result?.success) {
                return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
            }

            const config = result.data;

            console.log(config);            

            for (const key in config) {
                const configKey = key as keyof typeof config;
                const regexMatched = /(.+)\[\d+\]/g.test(configKey);
                
                if (typeof currentConfigDotObject[configKey] === 'undefined' && !regexMatched) {
                    console.log(configKey, config[configKey]);
                    
                    if (currentConfigDotObject[configKey] instanceof Array && config[configKey] instanceof Array) {
                        console.log('Array');                        
                    }
                    else
                        return this.response({ error: `The key '${configKey}' is not allowed` }, 422);
                }

                if (!regexMatched && config[configKey] !== null && config[configKey] !== null && typeof config[configKey] !== typeof currentConfigDotObject[configKey]) {
                    console.log(typeof config[configKey], typeof currentConfigDotObject[configKey]);    
                    
                    if (typeof currentConfigDotObject[configKey] === 'number' && typeof config[configKey] === 'string') {
                        const int = parseInt(config[configKey]!.toString());

                        if (int !== NaN) {
                            newConfigDotObject[configKey] = int;
                            console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
                            continue;
                        } 
                    }
                    
                    return this.response({ error: `The key '${configKey}' has incompatible value type '${config[configKey] === null ? 'null' : typeof config[configKey]}'` }, 422);
                }

                console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
            }

            const newObj = object({...newConfigDotObject});
            const configObj = object({...config});

            // console.log("Newobj", newObj);
            // console.log("Configobj", configObj);

            newConfigDotObject = merge.withOptions({ mergeArrays: false }, newObj, configObj);
            console.log("Output: ", newConfigDotObject);

            this.client.config.props[id] = newConfigDotObject;
            this.client.config.write();

            return { message: "Configuration updated", previous: currentConfigDotObject, new: dot(this.client.config.props[id]) };
        }
        catch (e) {
            console.log(e);
            return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
        }
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { dot, object } from "dot-object";
21			import { body } from "express-validator";
22			import { z as zod } from "zod";
23			import KeyValuePair from "../../types/KeyValuePair";
24			import Controller from "../Controller";
25			import RequireAuth from "../middleware/RequireAuth";
26			import ValidatorError from "../middleware/ValidatorError";
27			import Request from "../Request";
28			import merge from 'ts-deepmerge';
29
30			export default class ConfigController extends Controller {
31			globalMiddleware(): Function[] {
32			return [RequireAuth, ValidatorError];
33			}
34
35			middleware(): KeyValuePair<Function[]> {
36			return {
37			update: [
38			body(["config"]).isObject()
39			]
40			};
41			}
42
43			private zodSchema(id: string) {
44			const snowflake = zod.string().regex(/\d+/, { message: "The given value is not a Snowflake" });
45			const config = this.client.config.props[id];
46
47			const schema = zod.object({
48			"prefix": zod.string().optional(),
49			"debug": zod.boolean().optional(),
50			"mute_role": snowflake.optional(),
51			"gen_role": snowflake.optional(),
52			"logging_channel": snowflake.optional(),
53			"logging_channel_join_leave": snowflake.optional(),
54			"mod_role": snowflake.optional(),
55			"announcement_channel": snowflake.optional(),
56			"admin": snowflake.optional(),
57			"lockall": zod.array(zod.string()).optional(),
58			"warn_notallowed": zod.boolean().optional(),
59			"role_commands": zod.record(
60			snowflake,
61			zod.array(zod.string().min(1))
62			).optional().default({}),
63			"autoclear": zod.object({
64			"enabled": zod.boolean().optional(),
65			"channels": zod.array(snowflake).optional().default(config.autoclear.channels)
66			}).optional(),
67			"verification": zod.object({
68			"enabled": zod.boolean().optional(),
69			"role": snowflake.optional()
70			}).optional(),
71			"welcomer": zod.object({
72			"enabled": zod.boolean().optional(),
73			"channel": snowflake.optional(),
74			"message": zod.string().min(1).or(zod.null()).optional(),
75			"randomize": zod.boolean().optional()
76			}).optional(),
77			"cooldown": zod.object({
78			"enabled": zod.boolean().optional(),
79			"global": zod.any().optional(),
80			"cmds": zod.object({}).optional()
81			}).optional(),
82			"starboard": zod.object({
83			"enabled": zod.boolean().optional(),
84			"reactions": zod.number().int().optional(),
85			"channel": snowflake.optional()
86			}).optional(),
87			"autorole": zod.object({
88			"enabled": zod.boolean().optional(),
89			"roles": zod.array(snowflake).optional().default(config.autorole.roles)
90			}).optional(),
91			"spam_filter": zod.object({
92			"enabled": zod.boolean().optional(),
93			"limit": zod.number().int().optional(),
94			"time": zod.number().optional(),
95			"diff": zod.number().optional(),
96			"exclude": zod.array(snowflake).optional().default(config.spam_filter.exclude),
97			"samelimit": zod.number().int().optional(),
98			"unmute_in": zod.number().optional()
99			}).optional(),
100			"raid": zod.object({
101			"enabled": zod.boolean().optional(),
102			"max_joins": zod.number().int().optional(),
103			"time": zod.number().optional(),
104			"channels": zod.array(snowflake).optional().default(config.raid.channels),
105			"exclude": zod.boolean().optional()
106			}).optional(),
107			"global_commands": zod.array(zod.string()).optional().default(config.global_commands),
108			"filters": zod.object({
109			"ignore_staff": zod.boolean().optional(),
110			"chars_repeated": zod.number().int().optional(),
111			"words_repeated": zod.number().int().optional(),
112			"words": zod.array(zod.string()).optional().default(config.filters.words),
113			"tokens": zod.array(zod.string()).optional().default(config.filters.tokens),
114			"invite_message": zod.string().optional(),
115			"words_excluded": zod.array(snowflake).optional().default(config.filters.words_excluded),
116			"domain_excluded": zod.array(snowflake).optional().default(config.filters.domain_excluded),
117			"invite_excluded": zod.array(snowflake).optional().default(config.filters.invite_excluded),
118			"words_enabled": zod.boolean().optional(),
119			"invite_enabled": zod.boolean().optional(),
120			"domain_enabled": zod.boolean().optional(),
121			"regex": zod.boolean().optional(),
122			"file_mimes_excluded": zod.array(zod.string()).optional().default(config.filters.file_mimes_excluded),
123			"file_types_excluded": zod.array(zod.string()).optional().default(config.filters.file_types_excluded),
124			"domains": zod.array(zod.string()).optional().default(config.filters.domains),
125			"regex_patterns": zod.array(zod.string()).optional().default(config.filters.regex_patterns),
126			"rickrolls_enabled": zod.boolean().optional(),
127			"pings": zod.number().int().optional()
128			}).optional()
129			});
130
131			return schema;
132			}
133
134			public async index(request: Request) {
135			const { id } = request.params;
136
137			if (!request.user?.guilds.includes(id)) {
138			return this.response({ error: "You don't have permission to access configuration of this guild." }, 403);
139			}
140
141			if (id === "global" \|\| !this.client.config.props[id]) {
142			return this.response({ error: "No configuration found for the given guild ID" }, 404);
143			}
144
145			return this.client.config.props[id];
146			}
147
148			public async update(request: Request) {
149			const { id } = request.params;
150			const { config: origconfig } = request.body;
151
152			console.log(origconfig);
153
154			try {
155			const currentConfigDotObject = this.client.config.props[id];
156
157			console.log("Current config: ", currentConfigDotObject);
158
159			const result = this.zodSchema(id).safeParse(object(origconfig));
160
161			if (!result?.success) {
162			return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
163			}
164
165			const config = result.data;
166			const newConfig = merge.withOptions({ mergeArrays: false }, currentConfigDotObject, config);
167			const result2 = this.zodSchema(id).safeParse(newConfig);
168
169			if (!result2?.success) {
170			console.log(result2.error.errors);
171			return this.response({ error: 'Internal Server Error (500)', error_type: 'internal' }, 500);
172			}
173
174			console.log('Final', newConfig);
175			this.client.config.props[id] = newConfig;
176			this.client.config.write();
177			return { message: "Configuration updated", previous: dot(currentConfigDotObject), new: dot(this.client.config.props[id]) };
178			}
179			catch (e) {
180			console.log(e);
181			return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
182			}
183			}
184
185			public async update2(request: Request) {
186			const { id } = request.params;
187			const { config: origconfig } = request.body;
188
189			console.log(origconfig);
190
191			try {
192			const currentConfigDotObject = dot(this.client.config.props[id]);
193			let newConfigDotObject = {...currentConfigDotObject};
194
195			console.log("Current config: ", currentConfigDotObject);
196
197			const result = this.zodSchema(id).safeParse(object({...origconfig}));
198
199			if (!result?.success) {
200			return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
201			}
202
203			const config = result.data;
204
205			console.log(config);
206
207			for (const key in config) {
208			const configKey = key as keyof typeof config;
209			const regexMatched = /(.+)\[\d+\]/g.test(configKey);
210
211			if (typeof currentConfigDotObject[configKey] === 'undefined' && !regexMatched) {
212			console.log(configKey, config[configKey]);
213
214			if (currentConfigDotObject[configKey] instanceof Array && config[configKey] instanceof Array) {
215			console.log('Array');
216			}
217			else
218			return this.response({ error: `The key '${configKey}' is not allowed` }, 422);
219			}
220
221			if (!regexMatched && config[configKey] !== null && config[configKey] !== null && typeof config[configKey] !== typeof currentConfigDotObject[configKey]) {
222			console.log(typeof config[configKey], typeof currentConfigDotObject[configKey]);
223
224			if (typeof currentConfigDotObject[configKey] === 'number' && typeof config[configKey] === 'string') {
225			const int = parseInt(config[configKey]!.toString());
226
227			if (int !== NaN) {
228			newConfigDotObject[configKey] = int;
229			console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
230			continue;
231			}
232			}
233
234			return this.response({ error: `The key '${configKey}' has incompatible value type '${config[configKey] === null ? 'null' : typeof config[configKey]}'` }, 422);
235			}
236
237			console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
238			}
239
240			const newObj = object({...newConfigDotObject});
241			const configObj = object({...config});
242
243			// console.log("Newobj", newObj);
244			// console.log("Configobj", configObj);
245
246			newConfigDotObject = merge.withOptions({ mergeArrays: false }, newObj, configObj);
247			console.log("Output: ", newConfigDotObject);
248
249			this.client.config.props[id] = newConfigDotObject;
250			this.client.config.write();
251
252			return { message: "Configuration updated", previous: currentConfigDotObject, new: dot(this.client.config.props[id]) };
253			}
254			catch (e) {
255			console.log(e);
256			return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
257			}
258			}
259			}