events/guildMember/GuildMemberUpdateEvent.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 { InfractionType } from "@prisma/client";
import { AuditLogEvent, Events, GuildMember } from "discord.js";
import EventListener from "../../core/EventListener";
import { logError } from "../../utils/logger";

export default class GuildMemberUpdateEvent extends EventListener<Events.GuildMemberUpdate> {
    public readonly name = Events.GuildMemberUpdate;

    async execute(oldMember: GuildMember, newMember: GuildMember) {
        super.execute(oldMember, newMember);

        if (oldMember.nickname !== newMember.nickname) {
            await this.client.logger.logNicknameUpdate(oldMember, newMember);
        }

        if (!oldMember.roles.cache.equals(newMember.roles.cache)) {
            await this.client.logger.logMemberRoleUpdate(oldMember, newMember);
        }

        if (!oldMember.communicationDisabledUntil && newMember.communicationDisabledUntil) {
            setTimeout(async () => {
                try {
                    const auditLog = (
                        await newMember.guild.fetchAuditLogs({
                            limit: 1,
                            type: AuditLogEvent.MemberUpdate
                        })
                    ).entries.first();

                    if (auditLog?.executor?.id && auditLog.executor.id !== this.client.user?.id) {
                        const timeout = auditLog.changes.reverse().find(change => change.key === "communication_disabled_until");

                        if (!timeout) return;

                        const infraction = await this.client.prisma.infraction.create({
                            data: {
                                guildId: newMember.guild.id,
                                moderatorId: auditLog.executor.id,
                                type: InfractionType.TIMEOUT,
                                userId: newMember.user.id,
                                reason: auditLog.reason ?? undefined
                            }
                        });

                        await this.client.logger.logMemberTimeout(newMember, {
                            moderator: auditLog.executor,
                            id: infraction.id.toString(),
                            reason: auditLog.reason ?? undefined
                        });
                    }
                } catch (e) {
                    logError(e);
                }
            }, 3500);
        } else if (oldMember.communicationDisabledUntil && !newMember.communicationDisabledUntil) {
            setTimeout(async () => {
                try {
                    const auditLog = (
                        await newMember.guild.fetchAuditLogs({
                            limit: 1,
                            type: AuditLogEvent.MemberUpdate
                        })
                    ).entries.first();

                    if (auditLog?.executor?.id && auditLog.executor.id !== this.client.user?.id) {
                        const infraction = await this.client.prisma.infraction.create({
                            data: {
                                guildId: newMember.guild.id,
                                moderatorId: auditLog.executor.id,
                                type: InfractionType.TIMEOUT_REMOVE,
                                userId: newMember.user.id
                            }
                        });

                        await this.client.logger.logMemberTimeoutRemove(newMember, {
                            moderator: auditLog.executor,
                            id: infraction.id.toString()
                        });
                    }
                } catch (e) {
                    logError(e);
                }
            }, 2000);
        }
    }
}
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 { InfractionType } from "@prisma/client";
21	import { AuditLogEvent, Events, GuildMember } from "discord.js";
22	import EventListener from "../../core/EventListener";
23	import { logError } from "../../utils/logger";
24
25	export default class GuildMemberUpdateEvent extends EventListener<Events.GuildMemberUpdate> {
26	public readonly name = Events.GuildMemberUpdate;
27
28	async execute(oldMember: GuildMember, newMember: GuildMember) {
29	super.execute(oldMember, newMember);
30
31	if (oldMember.nickname !== newMember.nickname) {
32	await this.client.logger.logNicknameUpdate(oldMember, newMember);
33	}
34
35	if (!oldMember.roles.cache.equals(newMember.roles.cache)) {
36	await this.client.logger.logMemberRoleUpdate(oldMember, newMember);
37	}
38
39	if (!oldMember.communicationDisabledUntil && newMember.communicationDisabledUntil) {
40	setTimeout(async () => {
41	try {
42	const auditLog = (
43	await newMember.guild.fetchAuditLogs({
44	limit: 1,
45	type: AuditLogEvent.MemberUpdate
46	})
47	).entries.first();
48
49	if (auditLog?.executor?.id && auditLog.executor.id !== this.client.user?.id) {
50	const timeout = auditLog.changes.reverse().find(change => change.key === "communication_disabled_until");
51
52	if (!timeout) return;
53
54	const infraction = await this.client.prisma.infraction.create({
55	data: {
56	guildId: newMember.guild.id,
57	moderatorId: auditLog.executor.id,
58	type: InfractionType.TIMEOUT,
59	userId: newMember.user.id,
60	reason: auditLog.reason ?? undefined
61	}
62	});
63
64	await this.client.logger.logMemberTimeout(newMember, {
65	moderator: auditLog.executor,
66	id: infraction.id.toString(),
67	reason: auditLog.reason ?? undefined
68	});
69	}
70	} catch (e) {
71	logError(e);
72	}
73	}, 3500);
74	} else if (oldMember.communicationDisabledUntil && !newMember.communicationDisabledUntil) {
75	setTimeout(async () => {
76	try {
77	const auditLog = (
78	await newMember.guild.fetchAuditLogs({
79	limit: 1,
80	type: AuditLogEvent.MemberUpdate
81	})
82	).entries.first();
83
84	if (auditLog?.executor?.id && auditLog.executor.id !== this.client.user?.id) {
85	const infraction = await this.client.prisma.infraction.create({
86	data: {
87	guildId: newMember.guild.id,
88	moderatorId: auditLog.executor.id,
89	type: InfractionType.TIMEOUT_REMOVE,
90	userId: newMember.user.id
91	}
92	});
93
94	await this.client.logger.logMemberTimeoutRemove(newMember, {
95	moderator: auditLog.executor,
96	id: infraction.id.toString()
97	});
98	}
99	} catch (e) {
100	logError(e);
101	}
102	}, 2000);
103	}
104	}
105	}