src/services/SurveyService.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2024 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 {
    ActionRowBuilder,
    ButtonInteraction,
    CacheType,
    ChatInputCommandInteraction,
    GuildMember,
    HeadingLevel,
    Interaction,
    ModalBuilder,
    ModalSubmitInteraction,
    PermissionsString,
    TextInputBuilder,
    TextInputStyle,
    heading
} from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { userInfo } from "../utils/embed";
import { safeChannelFetch } from "../utils/fetch";
import { chunkedString } from "../utils/utils";
import { GuildConfig } from "./ConfigManager";

export const name = "surveyService";

export default class SurveyService extends Service implements HasEventListeners {
    @GatewayEventListener("interactionCreate")
    public async onInteractionCreate(interaction: Interaction<CacheType>) {
        const config = this.client.configManager.config[interaction.guildId!]?.survey;

        if (!config?.enabled) {
            return;
        }

        if (interaction.isButton() && interaction.customId.startsWith("survey_")) {
            await this.onSurveyShowRequest(interaction);
            return;
        }

        if (interaction.isModalSubmit() && interaction.customId.startsWith("survey_")) {
            await this.onModalSubmit(interaction);
            return;
        }
    }

    public async onSurveyShowRequest(interaction: ButtonInteraction | ChatInputCommandInteraction) {
        const config = this.client.configManager.config[interaction.guildId!]?.survey;

        if (!config?.enabled) {
            await interaction.reply({
                content: "Sorry, surveys are not enabled on this server.",
                ephemeral: true
            });

            return;
        }

        const customId = interaction.isButton()
            ? interaction.customId.replace(/^survey_/, "")
            : interaction.options.getString("survey", true);
        const surveyConfig = config.surveys[customId as unknown as keyof typeof config.surveys];

        if (!surveyConfig) {
            await interaction.reply({
                content: "That survey does not exist!",
                ephemeral: true
            });

            return;
        }

        if (!this.checkPreconditions(interaction, surveyConfig)) {
            await interaction.reply({
                content: "Sorry, you do not meet the requirements to fill out this survey.",
                ephemeral: true
            });

            return;
        }

        const modal = this.buildModal(customId.toLowerCase(), surveyConfig);
        await interaction.showModal(modal);
    }

    public async onModalSubmit(interaction: ModalSubmitInteraction<CacheType>) {
        const config = this.client.configManager.config[interaction.guildId!]?.survey;

        if (!config?.enabled) {
            await interaction.reply({
                content: "Sorry, surveys are not enabled on this server.",
                ephemeral: true
            });

            return;
        }

        const customId = interaction.customId.replace(/^survey_/, "");
        const surveyConfig = config.surveys[customId as unknown as keyof typeof config.surveys];

        if (!surveyConfig) {
            await interaction.reply({
                content: "That survey does not exist!",
                ephemeral: true
            });

            return;
        }

        if (!this.checkPreconditions(interaction, surveyConfig)) {
            await interaction.reply({
                content: "Sorry, you do not meet the requirements to fill out this survey.",
                ephemeral: true
            });

            return;
        }

        let i = 0;
        let summary = `${heading(
            `Survey completed by <@${interaction.user.id}> (${interaction.user.id})`,
            HeadingLevel.One
        )}\n${userInfo(interaction.user)}\n\n`;

        for (const question of surveyConfig.questions) {
            const answer = interaction.fields.getTextInputValue(
                `survey_${customId}_question_${i++}`
            );

            if (question.required && !answer) {
                await interaction.reply({
                    content: "You must fill out all required questions!",
                    ephemeral: true
                });

                return;
            }

            summary += `${heading(question.question, HeadingLevel.Three)}\n${answer}\n`;
        }

        await interaction.reply({
            content: surveyConfig.end_message ?? "Thank you for filling out the form!",
            ephemeral: true
        });

        const logChannelId = surveyConfig.log_channel ?? config.default_log_channel;

        if (!logChannelId) {
            this.client.logger.warn("No log channel specified for survey completion.");
            return;
        }

        const logChannel = await safeChannelFetch(interaction.guild!, logChannelId);

        if (!logChannel?.isTextBased()) {
            this.client.logger.warn(
                "Log channel specified for survey completion does not exist or is not text-based."
            );

            return;
        }

        chunkedString(summary, 2000).forEach(chunk =>
            logChannel.send({
                content: chunk,
                allowedMentions: { parse: [], roles: [], users: [] }
            })
        );
    }

    private checkPreconditions(
        interaction: Interaction,
        surveyConfig: NonNullable<GuildConfig["survey"]>["surveys"][string]
    ) {
        return (
            surveyConfig &&
            (!surveyConfig.required_channels?.length ||
                surveyConfig.required_channels.includes(interaction.channelId!)) &&
            (!surveyConfig.required_roles?.length ||
                (interaction.member instanceof GuildMember &&
                    surveyConfig.required_roles.some(role =>
                        (interaction.member as GuildMember)?.roles.cache.has(role)
                    ))) &&
            (!surveyConfig.required_permissions?.length ||
                (interaction.member as GuildMember).permissions.has(
                    surveyConfig.required_permissions as PermissionsString[],
                    true
                )) &&
            (!surveyConfig.required_users?.length ||
                surveyConfig.required_users.includes(interaction.user.id))
        );
    }

    public buildModal(
        customId: string,
        surveyConfig: NonNullable<GuildConfig["survey"]>["surveys"][string]
    ) {
        const components: ActionRowBuilder<TextInputBuilder>[] = [];
        let i = 0;

        for (const question of surveyConfig.questions) {
            const input = new TextInputBuilder()
                .setCustomId(`survey_${customId}_question_${i}`)
                .setLabel(question.question);

            if (question.maxLength) {
                input.setMaxLength(question.maxLength);
            }

            if (question.minLength) {
                input.setMinLength(question.minLength);
            }

            if (question.placeholder) {
                input.setPlaceholder(question.placeholder);
            }

            if (question.default_value) {
                input.setValue(question.default_value);
            }

            const row = new ActionRowBuilder<TextInputBuilder>().addComponents(
                input
                    .setRequired(question.required)
                    .setStyle(
                        question.type === "paragraph"
                            ? TextInputStyle.Paragraph
                            : TextInputStyle.Short
                    )
            );

            components.push(row);
            i++;
        }

        return new ModalBuilder()
            .setCustomId(`survey_${customId}`)
            .setTitle(surveyConfig.name)
            .setComponents(components);
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2024 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 {
21	ActionRowBuilder,
22	ButtonInteraction,
23	CacheType,
24	ChatInputCommandInteraction,
25	GuildMember,
26	HeadingLevel,
27	Interaction,
28	ModalBuilder,
29	ModalSubmitInteraction,
30	PermissionsString,
31	TextInputBuilder,
32	TextInputStyle,
33	heading
34	} from "discord.js";
35	import Service from "../core/Service";
36	import { GatewayEventListener } from "../decorators/GatewayEventListener";
37	import { HasEventListeners } from "../types/HasEventListeners";
38	import { userInfo } from "../utils/embed";
39	import { safeChannelFetch } from "../utils/fetch";
40	import { chunkedString } from "../utils/utils";
41	import { GuildConfig } from "./ConfigManager";
42
43	export const name = "surveyService";
44
45	export default class SurveyService extends Service implements HasEventListeners {
46	@GatewayEventListener("interactionCreate")
47	public async onInteractionCreate(interaction: Interaction<CacheType>) {
48	const config = this.client.configManager.config[interaction.guildId!]?.survey;
49
50	if (!config?.enabled) {
51	return;
52	}
53
54	if (interaction.isButton() && interaction.customId.startsWith("survey_")) {
55	await this.onSurveyShowRequest(interaction);
56	return;
57	}
58
59	if (interaction.isModalSubmit() && interaction.customId.startsWith("survey_")) {
60	await this.onModalSubmit(interaction);
61	return;
62	}
63	}
64
65	public async onSurveyShowRequest(interaction: ButtonInteraction \| ChatInputCommandInteraction) {
66	const config = this.client.configManager.config[interaction.guildId!]?.survey;
67
68	if (!config?.enabled) {
69	await interaction.reply({
70	content: "Sorry, surveys are not enabled on this server.",
71	ephemeral: true
72	});
73
74	return;
75	}
76
77	const customId = interaction.isButton()
78	? interaction.customId.replace(/^survey_/, "")
79	: interaction.options.getString("survey", true);
80	const surveyConfig = config.surveys[customId as unknown as keyof typeof config.surveys];
81
82	if (!surveyConfig) {
83	await interaction.reply({
84	content: "That survey does not exist!",
85	ephemeral: true
86	});
87
88	return;
89	}
90
91	if (!this.checkPreconditions(interaction, surveyConfig)) {
92	await interaction.reply({
93	content: "Sorry, you do not meet the requirements to fill out this survey.",
94	ephemeral: true
95	});
96
97	return;
98	}
99
100	const modal = this.buildModal(customId.toLowerCase(), surveyConfig);
101	await interaction.showModal(modal);
102	}
103
104	public async onModalSubmit(interaction: ModalSubmitInteraction<CacheType>) {
105	const config = this.client.configManager.config[interaction.guildId!]?.survey;
106
107	if (!config?.enabled) {
108	await interaction.reply({
109	content: "Sorry, surveys are not enabled on this server.",
110	ephemeral: true
111	});
112
113	return;
114	}
115
116	const customId = interaction.customId.replace(/^survey_/, "");
117	const surveyConfig = config.surveys[customId as unknown as keyof typeof config.surveys];
118
119	if (!surveyConfig) {
120	await interaction.reply({
121	content: "That survey does not exist!",
122	ephemeral: true
123	});
124
125	return;
126	}
127
128	if (!this.checkPreconditions(interaction, surveyConfig)) {
129	await interaction.reply({
130	content: "Sorry, you do not meet the requirements to fill out this survey.",
131	ephemeral: true
132	});
133
134	return;
135	}
136
137	let i = 0;
138	let summary = `${heading(
139	`Survey completed by <@${interaction.user.id}> (${interaction.user.id})`,
140	HeadingLevel.One
141	)}\n${userInfo(interaction.user)}\n\n`;
142
143	for (const question of surveyConfig.questions) {
144	const answer = interaction.fields.getTextInputValue(
145	`survey_${customId}_question_${i++}`
146	);
147
148	if (question.required && !answer) {
149	await interaction.reply({
150	content: "You must fill out all required questions!",
151	ephemeral: true
152	});
153
154	return;
155	}
156
157	summary += `${heading(question.question, HeadingLevel.Three)}\n${answer}\n`;
158	}
159
160	await interaction.reply({
161	content: surveyConfig.end_message ?? "Thank you for filling out the form!",
162	ephemeral: true
163	});
164
165	const logChannelId = surveyConfig.log_channel ?? config.default_log_channel;
166
167	if (!logChannelId) {
168	this.client.logger.warn("No log channel specified for survey completion.");
169	return;
170	}
171
172	const logChannel = await safeChannelFetch(interaction.guild!, logChannelId);
173
174	if (!logChannel?.isTextBased()) {
175	this.client.logger.warn(
176	"Log channel specified for survey completion does not exist or is not text-based."
177	);
178
179	return;
180	}
181
182	chunkedString(summary, 2000).forEach(chunk =>
183	logChannel.send({
184	content: chunk,
185	allowedMentions: { parse: [], roles: [], users: [] }
186	})
187	);
188	}
189
190	private checkPreconditions(
191	interaction: Interaction,
192	surveyConfig: NonNullable<GuildConfig["survey"]>["surveys"][string]
193	) {
194	return (
195	surveyConfig &&
196	(!surveyConfig.required_channels?.length \|\|
197	surveyConfig.required_channels.includes(interaction.channelId!)) &&
198	(!surveyConfig.required_roles?.length \|\|
199	(interaction.member instanceof GuildMember &&
200	surveyConfig.required_roles.some(role =>
201	(interaction.member as GuildMember)?.roles.cache.has(role)
202	))) &&
203	(!surveyConfig.required_permissions?.length \|\|
204	(interaction.member as GuildMember).permissions.has(
205	surveyConfig.required_permissions as PermissionsString[],
206	true
207	)) &&
208	(!surveyConfig.required_users?.length \|\|
209	surveyConfig.required_users.includes(interaction.user.id))
210	);
211	}
212
213	public buildModal(
214	customId: string,
215	surveyConfig: NonNullable<GuildConfig["survey"]>["surveys"][string]
216	) {
217	const components: ActionRowBuilder<TextInputBuilder>[] = [];
218	let i = 0;
219
220	for (const question of surveyConfig.questions) {
221	const input = new TextInputBuilder()
222	.setCustomId(`survey_${customId}_question_${i}`)
223	.setLabel(question.question);
224
225	if (question.maxLength) {
226	input.setMaxLength(question.maxLength);
227	}
228
229	if (question.minLength) {
230	input.setMinLength(question.minLength);
231	}
232
233	if (question.placeholder) {
234	input.setPlaceholder(question.placeholder);
235	}
236
237	if (question.default_value) {
238	input.setValue(question.default_value);
239	}
240
241	const row = new ActionRowBuilder<TextInputBuilder>().addComponents(
242	input
243	.setRequired(question.required)
244	.setStyle(
245	question.type === "paragraph"
246	? TextInputStyle.Paragraph
247	: TextInputStyle.Short
248	)
249	);
250
251	components.push(row);
252	i++;
253	}
254
255	return new ModalBuilder()
256	.setCustomId(`survey_${customId}`)
257	.setTitle(surveyConfig.name)
258	.setComponents(components);
259	}
260	}