src/services/BallotManager.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 { Ballot } from "@prisma/client";
import { CacheType, EmbedBuilder, Interaction, Snowflake } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { log, logError } from "../utils/logger";
import { getEmoji } from "../utils/utils";

export const name = "ballotManager";

export default class BallotManager extends Service implements HasEventListeners {
    protected readonly changedBallots = new Map<`${Snowflake}_${Snowflake}_${Snowflake}`, Ballot>();
    protected readonly recentUsers = new Map<Snowflake, number>();
    protected readonly cooldown = 3000;
    protected readonly updateInterval = 10_000;
    protected timeout: NodeJS.Timeout | null = null;
    protected updateTimeout: NodeJS.Timeout | null = null;

    @GatewayEventListener("interactionCreate")
    async onInteractionCreate(interaction: Interaction<CacheType>) {
        if (!interaction.isButton() || !interaction.customId.startsWith("ballot__")) {
            return;
        }

        const [, mode] = interaction.customId.split("__");

        if (mode !== "upvote" && mode !== "downvote") {
            return;
        }

        const lastRequest = this.recentUsers.get(interaction.user.id);

        if (lastRequest !== undefined && lastRequest <= this.cooldown) {
            await interaction.reply({
                ephemeral: true,
                content: `${getEmoji(this.client, "error")} Whoa there! Please wait for ${Math.ceil(
                    (this.cooldown - lastRequest) / 1000
                )} seconds before trying to upvote/downvote again!`
            });

            return;
        }

        this.timeout ??= setTimeout(() => {
            for (const [userId, lastRequest] of this.recentUsers) {
                if (lastRequest >= this.cooldown) {
                    this.recentUsers.delete(userId);
                }
            }

            this.timeout = null;
        }, this.cooldown);

        this.recentUsers.set(interaction.user.id, Date.now());

        await interaction.deferReply({
            ephemeral: true
        });

        const key = `${interaction.guildId!}_${interaction.channelId!}_${interaction.message.id}` as const;
        const ballot =
            this.changedBallots.get(key) ??
            (await this.client.prisma.ballot.findFirst({
                where: {
                    guildId: interaction.guildId!,
                    channelId: interaction.channelId!,
                    messageId: interaction.message.id
                }
            }));

        if (!ballot) {
            return;
        }

        log("Before", ballot.upvotes, ballot.downvotes);
        const previousTotalVotes = ballot.upvotes.length - ballot.downvotes.length;

        const added = this.modifyBallotVotes(ballot, interaction.user.id, mode);

        log("After", ballot.upvotes, ballot.downvotes);

        this.changedBallots.set(key, ballot);

        this.updateTimeout ??= setTimeout(() => {
            for (const [, ballot] of this.changedBallots) {
                log("Updating ballot: ", ballot.id);
                this.client.prisma.ballot
                    .updateMany({
                        where: {
                            id: ballot.id,
                            guildId: interaction.guildId!
                        },
                        data: {
                            upvotes: {
                                set: ballot.upvotes
                            },
                            downvotes: {
                                set: ballot.downvotes
                            }
                        }
                    })
                    .catch(logError);
            }

            this.changedBallots.clear();
        }, this.updateInterval);

        const newTotalVotes = ballot.upvotes.length - ballot.downvotes.length;

        if (newTotalVotes !== previousTotalVotes) {
            await interaction.message.edit({
                embeds: [
                    new EmbedBuilder(interaction.message.embeds[0].data).setFooter({
                        text: `${newTotalVotes} Vote${newTotalVotes === 1 ? "" : "s"} • React to vote!`
                    })
                ]
            });
        }

        await interaction.editReply({
            content: `Successfully ${
                added === null ? "changed" : added ? "added" : "removed"
            } your vote! If you want to ${added === false ? "add" : "remove"} your vote${added === false ? " back" : ""}, press the same button again.`
        });
    }

    private modifyBallotVotes(ballot: Ballot, userId: Snowflake, mode: "upvote" | "downvote") {
        const upvoteIndex = ballot.upvotes.indexOf(userId);
        const downvoteIndex = ballot.downvotes.indexOf(userId);

        if (upvoteIndex !== -1 && downvoteIndex !== -1) {
            mode === "upvote" ? ballot.downvotes.splice(downvoteIndex, 1) : ballot.upvotes.splice(upvoteIndex, 1);
            return false;
        } else if (upvoteIndex === -1 && downvoteIndex === -1) {
            mode === "upvote" ? ballot.upvotes.push(userId) : ballot.downvotes.push(userId);
            return true;
        } else {
            if (mode === "upvote") {
                upvoteIndex === -1 ? ballot.upvotes.push(userId) : ballot.upvotes.splice(upvoteIndex, 1);
                downvoteIndex === -1 ? null : ballot.downvotes.splice(downvoteIndex, 1);
            } else {
                downvoteIndex === -1 ? ballot.downvotes.push(userId) : ballot.downvotes.splice(downvoteIndex, 1);
                upvoteIndex === -1 ? null : ballot.upvotes.splice(upvoteIndex, 1);
            }

            return mode === "upvote"
                ? downvoteIndex !== -1
                    ? null
                    : upvoteIndex === -1
                : upvoteIndex !== -1
                ? null
                : downvoteIndex === -1;
        }
    }

    create({
        content,
        guildId,
        userId,
        files,
        channelId,
        messageId,
        anonymous
    }: {
        content: string;
        guildId: Snowflake;
        channelId: Snowflake;
        messageId: Snowflake;
        userId: Snowflake;
        files?: string[];
        anonymous?: boolean;
    }) {
        return this.client.prisma.ballot.create({
            data: {
                content,
                guildId,
                userId,
                files,
                channelId,
                messageId,
                anonymous
            }
        });
    }

    delete({ id, guildId }: { id: number; guildId: Snowflake }) {
        return this.client.prisma.ballot.deleteMany({
            where: {
                id,
                guildId
            }
        });
    }

    upvote({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
        return this.client.prisma.ballot.updateMany({
            where: {
                id,
                guildId
            },
            data: {
                upvotes: {
                    push: userId
                }
            }
        });
    }

    downvote({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
        return this.client.prisma.ballot.updateMany({
            where: {
                id,
                guildId
            },
            data: {
                downvotes: {
                    push: userId
                }
            }
        });
    }

    async upvoteRemove({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
        const ballot = await this.get({ id, guildId });

        if (!ballot || ballot.upvotes.length === 0) {
            return { count: 0 };
        }

        return this.client.prisma.ballot.updateMany({
            where: {
                id,
                guildId
            },
            data: {
                upvotes: {
                    set: ballot.upvotes.filter(id => id !== userId)
                }
            }
        });
    }

    async downvoteRemove({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
        const ballot = await this.get({ id, guildId });

        if (!ballot || ballot.downvotes.length === 0) {
            return { count: 0 };
        }

        return this.client.prisma.ballot.updateMany({
            where: {
                id,
                guildId
            },
            data: {
                downvotes: {
                    set: ballot.downvotes.filter(id => id !== userId)
                }
            }
        });
    }

    get({ id, guildId }: { id: number; guildId: Snowflake }) {
        return this.client.prisma.ballot.findFirst({
            where: {
                id,
                guildId
            }
        });
    }
}
1	/**
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 { Ballot } from "@prisma/client";
21	import { CacheType, EmbedBuilder, Interaction, Snowflake } from "discord.js";
22	import Service from "../core/Service";
23	import { GatewayEventListener } from "../decorators/GatewayEventListener";
24	import { HasEventListeners } from "../types/HasEventListeners";
25	import { log, logError } from "../utils/logger";
26	import { getEmoji } from "../utils/utils";
27
28	export const name = "ballotManager";
29
30	export default class BallotManager extends Service implements HasEventListeners {
31	protected readonly changedBallots = new Map<`${Snowflake}_${Snowflake}_${Snowflake}`, Ballot>();
32	protected readonly recentUsers = new Map<Snowflake, number>();
33	protected readonly cooldown = 3000;
34	protected readonly updateInterval = 10_000;
35	protected timeout: NodeJS.Timeout \| null = null;
36	protected updateTimeout: NodeJS.Timeout \| null = null;
37
38	@GatewayEventListener("interactionCreate")
39	async onInteractionCreate(interaction: Interaction<CacheType>) {
40	if (!interaction.isButton() \|\| !interaction.customId.startsWith("ballot__")) {
41	return;
42	}
43
44	const [, mode] = interaction.customId.split("__");
45
46	if (mode !== "upvote" && mode !== "downvote") {
47	return;
48	}
49
50	const lastRequest = this.recentUsers.get(interaction.user.id);
51
52	if (lastRequest !== undefined && lastRequest <= this.cooldown) {
53	await interaction.reply({
54	ephemeral: true,
55	content: `${getEmoji(this.client, "error")} Whoa there! Please wait for ${Math.ceil(
56	(this.cooldown - lastRequest) / 1000
57	)} seconds before trying to upvote/downvote again!`
58	});
59
60	return;
61	}
62
63	this.timeout ??= setTimeout(() => {
64	for (const [userId, lastRequest] of this.recentUsers) {
65	if (lastRequest >= this.cooldown) {
66	this.recentUsers.delete(userId);
67	}
68	}
69
70	this.timeout = null;
71	}, this.cooldown);
72
73	this.recentUsers.set(interaction.user.id, Date.now());
74
75	await interaction.deferReply({
76	ephemeral: true
77	});
78
79	const key = `${interaction.guildId!}_${interaction.channelId!}_${interaction.message.id}` as const;
80	const ballot =
81	this.changedBallots.get(key) ??
82	(await this.client.prisma.ballot.findFirst({
83	where: {
84	guildId: interaction.guildId!,
85	channelId: interaction.channelId!,
86	messageId: interaction.message.id
87	}
88	}));
89
90	if (!ballot) {
91	return;
92	}
93
94	log("Before", ballot.upvotes, ballot.downvotes);
95	const previousTotalVotes = ballot.upvotes.length - ballot.downvotes.length;
96
97	const added = this.modifyBallotVotes(ballot, interaction.user.id, mode);
98
99	log("After", ballot.upvotes, ballot.downvotes);
100
101	this.changedBallots.set(key, ballot);
102
103	this.updateTimeout ??= setTimeout(() => {
104	for (const [, ballot] of this.changedBallots) {
105	log("Updating ballot: ", ballot.id);
106	this.client.prisma.ballot
107	.updateMany({
108	where: {
109	id: ballot.id,
110	guildId: interaction.guildId!
111	},
112	data: {
113	upvotes: {
114	set: ballot.upvotes
115	},
116	downvotes: {
117	set: ballot.downvotes
118	}
119	}
120	})
121	.catch(logError);
122	}
123
124	this.changedBallots.clear();
125	}, this.updateInterval);
126
127	const newTotalVotes = ballot.upvotes.length - ballot.downvotes.length;
128
129	if (newTotalVotes !== previousTotalVotes) {
130	await interaction.message.edit({
131	embeds: [
132	new EmbedBuilder(interaction.message.embeds[0].data).setFooter({
133	text: `${newTotalVotes} Vote${newTotalVotes === 1 ? "" : "s"} • React to vote!`
134	})
135	]
136	});
137	}
138
139	await interaction.editReply({
140	content: `Successfully ${
141	added === null ? "changed" : added ? "added" : "removed"
142	} your vote! If you want to ${added === false ? "add" : "remove"} your vote${added === false ? " back" : ""}, press the same button again.`
143	});
144	}
145
146	private modifyBallotVotes(ballot: Ballot, userId: Snowflake, mode: "upvote" \| "downvote") {
147	const upvoteIndex = ballot.upvotes.indexOf(userId);
148	const downvoteIndex = ballot.downvotes.indexOf(userId);
149
150	if (upvoteIndex !== -1 && downvoteIndex !== -1) {
151	mode === "upvote" ? ballot.downvotes.splice(downvoteIndex, 1) : ballot.upvotes.splice(upvoteIndex, 1);
152	return false;
153	} else if (upvoteIndex === -1 && downvoteIndex === -1) {
154	mode === "upvote" ? ballot.upvotes.push(userId) : ballot.downvotes.push(userId);
155	return true;
156	} else {
157	if (mode === "upvote") {
158	upvoteIndex === -1 ? ballot.upvotes.push(userId) : ballot.upvotes.splice(upvoteIndex, 1);
159	downvoteIndex === -1 ? null : ballot.downvotes.splice(downvoteIndex, 1);
160	} else {
161	downvoteIndex === -1 ? ballot.downvotes.push(userId) : ballot.downvotes.splice(downvoteIndex, 1);
162	upvoteIndex === -1 ? null : ballot.upvotes.splice(upvoteIndex, 1);
163	}
164
165	return mode === "upvote"
166	? downvoteIndex !== -1
167	? null
168	: upvoteIndex === -1
169	: upvoteIndex !== -1
170	? null
171	: downvoteIndex === -1;
172	}
173	}
174
175	create({
176	content,
177	guildId,
178	userId,
179	files,
180	channelId,
181	messageId,
182	anonymous
183	}: {
184	content: string;
185	guildId: Snowflake;
186	channelId: Snowflake;
187	messageId: Snowflake;
188	userId: Snowflake;
189	files?: string[];
190	anonymous?: boolean;
191	}) {
192	return this.client.prisma.ballot.create({
193	data: {
194	content,
195	guildId,
196	userId,
197	files,
198	channelId,
199	messageId,
200	anonymous
201	}
202	});
203	}
204
205	delete({ id, guildId }: { id: number; guildId: Snowflake }) {
206	return this.client.prisma.ballot.deleteMany({
207	where: {
208	id,
209	guildId
210	}
211	});
212	}
213
214	upvote({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
215	return this.client.prisma.ballot.updateMany({
216	where: {
217	id,
218	guildId
219	},
220	data: {
221	upvotes: {
222	push: userId
223	}
224	}
225	});
226	}
227
228	downvote({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
229	return this.client.prisma.ballot.updateMany({
230	where: {
231	id,
232	guildId
233	},
234	data: {
235	downvotes: {
236	push: userId
237	}
238	}
239	});
240	}
241
242	async upvoteRemove({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
243	const ballot = await this.get({ id, guildId });
244
245	if (!ballot \|\| ballot.upvotes.length === 0) {
246	return { count: 0 };
247	}
248
249	return this.client.prisma.ballot.updateMany({
250	where: {
251	id,
252	guildId
253	},
254	data: {
255	upvotes: {
256	set: ballot.upvotes.filter(id => id !== userId)
257	}
258	}
259	});
260	}
261
262	async downvoteRemove({ id, guildId, userId }: { id: number; guildId: Snowflake; userId: Snowflake }) {
263	const ballot = await this.get({ id, guildId });
264
265	if (!ballot \|\| ballot.downvotes.length === 0) {
266	return { count: 0 };
267	}
268
269	return this.client.prisma.ballot.updateMany({
270	where: {
271	id,
272	guildId
273	},
274	data: {
275	downvotes: {
276	set: ballot.downvotes.filter(id => id !== userId)
277	}
278	}
279	});
280	}
281
282	get({ id, guildId }: { id: number; guildId: Snowflake }) {
283	return this.client.prisma.ballot.findFirst({
284	where: {
285	id,
286	guildId
287	}
288	});
289	}
290	}