api/controllers/ConfigController.ts

/*
* This file is part of SudoBot.
*
* Copyright (C) 2021-2023 OSN Developers.
*
* 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 deepmerge from "deepmerge";
import dot from "dot-object";
import { Response as ExpressResponse } from "express";
import { z } from "zod";
import { Action } from "../../decorators/Action";
import { RequireAuth } from "../../decorators/RequireAuth";
import { Validate } from "../../decorators/Validate";
import { GuildConfigSchema } from "../../types/GuildConfigSchema";
import { logError } from "../../utils/logger";
import Controller from "../Controller";
import Request from "../Request";
import Response from "../Response";

export default class ConfigController extends Controller {
    guildConfigAccessControl(request: Request, response: ExpressResponse) {
        if (!request.user!.guilds.includes(request.params.id)) {
            response.status(403).json({
                error: "You don't have permission to access this resource."
            });

            return false;
        }

        return true;
    }

    @Action("GET", "/config/:id")
    @RequireAuth()
    public async index(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        let commands: string[] | undefined = undefined;

        if (request.query?.commands?.toString()?.toLowerCase() === "true") {
            commands = [];

            for (const [, command] of this.client.commands) {
                if (!commands.includes(command.name)) {
                    commands.push(command.name);
                }
            }
        }

        return {
            config: this.client.configManager.config[request.params.id] ?? null,
            commands
        };
    }

    @Action("PUT", "/config/:id")
    @RequireAuth()
    @Validate(
        z.object({
            data: GuildConfigSchema,
            returnOld: z.boolean().default(false),
            returnNew: z.boolean().default(false)
        })
    )
    public async updatePut(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        const oldConfig = this.client.configManager.config[request.params.id];
        console.log(request.parsedBody);

        if (request.parsedBody) {
            this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, request.parsedBody.data ?? {}, {
                arrayMerge: (target, source, options) => {
                    return source;
                }
            });
            console.log(oldConfig?.prefix, this.client.configManager.config[request.params.id]?.prefix);
        }

        await this.client.configManager.write();

        try {
            await this.client.configManager.load();
        } catch (e) {
            logError(e);
            logError("Configuration was corrupted. Restoring the old configuration.");
            this.client.configManager.config[request.params.id] = oldConfig;
            await this.client.configManager.write();
        }

        return {
            success: true,
            old: request.parsedBody?.returnOld ? oldConfig : undefined,
            new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
        };
    }

    @Action("PATCH", "/config/:id")
    @RequireAuth()
    @Validate(
        z.object({
            data: z.record(z.string(), z.any()),
            returnOld: z.boolean().default(false),
            returnNew: z.boolean().default(false)
        })
    )
    public async updatePatch(request: Request, response: ExpressResponse) {
        if (!this.guildConfigAccessControl(request, response)) {
            return;
        }

        const oldConfig = this.client.configManager.config[request.params.id];

        if (request.parsedBody) {
            const { parsedBody } = request;
            const configObject = dot.object(parsedBody.data);
            const result = GuildConfigSchema.safeParse(configObject);

            if (result.success) {
                this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, result.data);
            } else {
                return new Response({
                    status: 400,
                    body: result.error
                });
            }

            await this.client.configManager.write();

            try {
                await this.client.configManager.load();
            } catch (e) {
                logError(e);
                logError("Configuration was corrupted. Restoring the old configuration.");
                this.client.configManager.config[request.params.id] = oldConfig;
                await this.client.configManager.write();
            }

            return {
                success: true,
                old: request.parsedBody?.returnOld ? oldConfig : undefined,
                new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
            };
        }
    }
}
1	rakinar2	577	/*
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
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 deepmerge from "deepmerge";
21			import dot from "dot-object";
22			import { Response as ExpressResponse } from "express";
23			import { z } from "zod";
24			import { Action } from "../../decorators/Action";
25			import { RequireAuth } from "../../decorators/RequireAuth";
26			import { Validate } from "../../decorators/Validate";
27			import { GuildConfigSchema } from "../../types/GuildConfigSchema";
28			import { logError } from "../../utils/logger";
29			import Controller from "../Controller";
30			import Request from "../Request";
31			import Response from "../Response";
32
33			export default class ConfigController extends Controller {
34			guildConfigAccessControl(request: Request, response: ExpressResponse) {
35			if (!request.user!.guilds.includes(request.params.id)) {
36			response.status(403).json({
37			error: "You don't have permission to access this resource."
38			});
39
40			return false;
41			}
42
43			return true;
44			}
45
46			@Action("GET", "/config/:id")
47			@RequireAuth()
48			public async index(request: Request, response: ExpressResponse) {
49			if (!this.guildConfigAccessControl(request, response)) {
50			return;
51			}
52
53			let commands: string[] \| undefined = undefined;
54
55			if (request.query?.commands?.toString()?.toLowerCase() === "true") {
56			commands = [];
57
58			for (const [, command] of this.client.commands) {
59			if (!commands.includes(command.name)) {
60			commands.push(command.name);
61			}
62			}
63			}
64
65			return {
66			config: this.client.configManager.config[request.params.id] ?? null,
67			commands
68			};
69			}
70
71			@Action("PUT", "/config/:id")
72			@RequireAuth()
73			@Validate(
74			z.object({
75			data: GuildConfigSchema,
76			returnOld: z.boolean().default(false),
77			returnNew: z.boolean().default(false)
78			})
79			)
80			public async updatePut(request: Request, response: ExpressResponse) {
81			if (!this.guildConfigAccessControl(request, response)) {
82			return;
83			}
84
85			const oldConfig = this.client.configManager.config[request.params.id];
86			console.log(request.parsedBody);
87
88			if (request.parsedBody) {
89			this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, request.parsedBody.data ?? {}, {
90			arrayMerge: (target, source, options) => {
91			return source;
92			}
93			});
94			console.log(oldConfig?.prefix, this.client.configManager.config[request.params.id]?.prefix);
95			}
96
97			await this.client.configManager.write();
98
99			try {
100			await this.client.configManager.load();
101			} catch (e) {
102			logError(e);
103			logError("Configuration was corrupted. Restoring the old configuration.");
104			this.client.configManager.config[request.params.id] = oldConfig;
105			await this.client.configManager.write();
106			}
107
108			return {
109			success: true,
110			old: request.parsedBody?.returnOld ? oldConfig : undefined,
111			new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
112			};
113			}
114
115			@Action("PATCH", "/config/:id")
116			@RequireAuth()
117			@Validate(
118			z.object({
119			data: z.record(z.string(), z.any()),
120			returnOld: z.boolean().default(false),
121			returnNew: z.boolean().default(false)
122			})
123			)
124			public async updatePatch(request: Request, response: ExpressResponse) {
125			if (!this.guildConfigAccessControl(request, response)) {
126			return;
127			}
128
129			const oldConfig = this.client.configManager.config[request.params.id];
130
131			if (request.parsedBody) {
132			const { parsedBody } = request;
133			const configObject = dot.object(parsedBody.data);
134			const result = GuildConfigSchema.safeParse(configObject);
135
136			if (result.success) {
137			this.client.configManager.config[request.params.id] = deepmerge(oldConfig as object, result.data);
138			} else {
139			return new Response({
140			status: 400,
141			body: result.error
142			});
143			}
144
145			await this.client.configManager.write();
146
147			try {
148			await this.client.configManager.load();
149			} catch (e) {
150			logError(e);
151			logError("Configuration was corrupted. Restoring the old configuration.");
152			this.client.configManager.config[request.params.id] = oldConfig;
153			await this.client.configManager.write();
154			}
155
156			return {
157			success: true,
158			old: request.parsedBody?.returnOld ? oldConfig : undefined,
159			new: request.parsedBody?.returnNew ? this.client.configManager.config[request.params.id] : undefined
160			};
161			}
162			}
163			}