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 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 config = this.client.config.props[id];
        return this.client.config.schema(config);
    }

    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 (!isNaN(int)) {
                            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	/**
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 KeyValuePair from "../../types/KeyValuePair";
23	import Controller from "../Controller";
24	import RequireAuth from "../middleware/RequireAuth";
25	import ValidatorError from "../middleware/ValidatorError";
26	import Request from "../Request";
27	import merge from 'ts-deepmerge';
28
29	export default class ConfigController extends Controller {
30	globalMiddleware(): Function[] {
31	return [RequireAuth, ValidatorError];
32	}
33
34	middleware(): KeyValuePair<Function[]> {
35	return {
36	update: [
37	body(["config"]).isObject()
38	]
39	};
40	}
41
42	private zodSchema(id: string) {
43	const config = this.client.config.props[id];
44	return this.client.config.schema(config);
45	}
46
47	public async index(request: Request) {
48	const { id } = request.params;
49
50	if (!request.user?.guilds.includes(id)) {
51	return this.response({ error: "You don't have permission to access configuration of this guild." }, 403);
52	}
53
54	if (id === "global" \|\| !this.client.config.props[id]) {
55	return this.response({ error: "No configuration found for the given guild ID" }, 404);
56	}
57
58	return this.client.config.props[id];
59	}
60
61	public async update(request: Request) {
62	const { id } = request.params;
63	const { config: origconfig } = request.body;
64
65	console.log(origconfig);
66
67	try {
68	const currentConfigDotObject = this.client.config.props[id];
69
70	console.log("Current config: ", currentConfigDotObject);
71
72	const result = this.zodSchema(id).safeParse(object(origconfig));
73
74	if (!result?.success) {
75	return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
76	}
77
78	const config = result.data;
79	const newConfig = merge.withOptions({ mergeArrays: false }, currentConfigDotObject, config);
80	const result2 = this.zodSchema(id).safeParse(newConfig);
81
82	if (!result2?.success) {
83	console.log(result2.error.errors);
84	return this.response({ error: 'Internal Server Error (500)', error_type: 'internal' }, 500);
85	}
86
87	console.log('Final', newConfig);
88	this.client.config.props[id] = newConfig;
89	this.client.config.write();
90	return { message: "Configuration updated", previous: dot(currentConfigDotObject), new: dot(this.client.config.props[id]) };
91	}
92	catch (e) {
93	console.log(e);
94	return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
95	}
96	}
97
98	public async update2(request: Request) {
99	const { id } = request.params;
100	const { config: origconfig } = request.body;
101
102	console.log(origconfig);
103
104	try {
105	const currentConfigDotObject = dot(this.client.config.props[id]);
106	let newConfigDotObject = {...currentConfigDotObject};
107
108	console.log("Current config: ", currentConfigDotObject);
109
110	const result = this.zodSchema(id).safeParse(object({...origconfig}));
111
112	if (!result?.success) {
113	return this.response({ error: "The data schema does not match.", error_type: 'validation', errors: result.error.errors }, 422);
114	}
115
116	const config = result.data;
117
118	console.log(config);
119
120	for (const key in config) {
121	const configKey = key as keyof typeof config;
122	const regexMatched = /(.+)\[\d+\]/g.test(configKey);
123
124	if (typeof currentConfigDotObject[configKey] === 'undefined' && !regexMatched) {
125	console.log(configKey, config[configKey]);
126
127	if (currentConfigDotObject[configKey] instanceof Array && config[configKey] instanceof Array) {
128	console.log('Array');
129	}
130	else
131	return this.response({ error: `The key '${configKey}' is not allowed` }, 422);
132	}
133
134	if (!regexMatched && config[configKey] !== null && config[configKey] !== null && typeof config[configKey] !== typeof currentConfigDotObject[configKey]) {
135	console.log(typeof config[configKey], typeof currentConfigDotObject[configKey]);
136
137	if (typeof currentConfigDotObject[configKey] === 'number' && typeof config[configKey] === 'string') {
138	const int = parseInt(config[configKey]!.toString());
139
140	if (!isNaN(int)) {
141	newConfigDotObject[configKey] = int;
142	console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
143	continue;
144	}
145	}
146
147	return this.response({ error: `The key '${configKey}' has incompatible value type '${config[configKey] === null ? 'null' : typeof config[configKey]}'` }, 422);
148	}
149
150	console.log("Updating: ", configKey, config[configKey], newConfigDotObject[configKey]);
151	}
152
153	const newObj = object({...newConfigDotObject});
154	const configObj = object({...config});
155
156	// console.log("Newobj", newObj);
157	// console.log("Configobj", configObj);
158
159	newConfigDotObject = merge.withOptions({ mergeArrays: false }, newObj, configObj);
160	console.log("Output: ", newConfigDotObject);
161
162	this.client.config.props[id] = newConfigDotObject;
163	this.client.config.write();
164
165	return { message: "Configuration updated", previous: currentConfigDotObject, new: dot(this.client.config.props[id]) };
166	}
167	catch (e) {
168	console.log(e);
169	return this.response({ error: 'Internal Server Error', error_type: 'internal' }, 500);
170	}
171	}
172	}