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];

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

        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 as unknown as object);
            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
87			if (request.parsedBody) {
88			this.client.configManager.config[request.params.id] = deepmerge(
89			oldConfig as object,
90			request.parsedBody.data ?? {},
91			{
92			arrayMerge: (target, source) => {
93			return source;
94			}
95			}
96			) as unknown as (typeof this.client.configManager.config)[string];
97			}
98
99			await this.client.configManager.write();
100
101			try {
102			await this.client.configManager.load();
103			} catch (e) {
104			logError(e);
105			logError("Configuration was corrupted. Restoring the old configuration.");
106			this.client.configManager.config[request.params.id] = oldConfig;
107			await this.client.configManager.write();
108			}
109
110			return {
111			success: true,
112			old: request.parsedBody?.returnOld ? oldConfig : undefined,
113			new: request.parsedBody?.returnNew
114			? this.client.configManager.config[request.params.id]
115			: undefined
116			};
117			}
118
119			@Action("PATCH", "/config/:id")
120			@RequireAuth()
121			@Validate(
122			z.object({
123			data: z.record(z.string(), z.any()),
124			returnOld: z.boolean().default(false),
125			returnNew: z.boolean().default(false)
126			})
127			)
128			public async updatePatch(request: Request, response: ExpressResponse) {
129			if (!this.guildConfigAccessControl(request, response)) {
130			return;
131			}
132
133			const oldConfig = this.client.configManager.config[request.params.id];
134
135			if (request.parsedBody) {
136			const { parsedBody } = request;
137			const configObject = dot.object(parsedBody.data as unknown as object);
138			const result = GuildConfigSchema.safeParse(configObject);
139
140			if (result.success) {
141			this.client.configManager.config[request.params.id] = deepmerge(
142			oldConfig as object,
143			result.data
144			);
145			} else {
146			return new Response({
147			status: 400,
148			body: result.error
149			});
150			}
151
152			await this.client.configManager.write();
153
154			try {
155			await this.client.configManager.load();
156			} catch (e) {
157			logError(e);
158			logError("Configuration was corrupted. Restoring the old configuration.");
159			this.client.configManager.config[request.params.id] = oldConfig;
160			await this.client.configManager.write();
161			}
162
163			return {
164			success: true,
165			old: request.parsedBody?.returnOld ? oldConfig : undefined,
166			new: request.parsedBody?.returnNew
167			? this.client.configManager.config[request.params.id]
168			: undefined
169			};
170			}
171			}
172			}