src/services/TriggerService.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 {
    ActionRowBuilder,
    ActivityType,
    ButtonBuilder,
    ButtonStyle,
    ClientEvents,
    GuildMember,
    Message,
    Presence,
    Snowflake
} from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { TriggerType } from "../types/TriggerSchema";
import { logError } from "../utils/logger";

export const name = "triggerService";

const handlers = {
    sticky_message: "triggerMessageSticky",
    member_status_update: "triggerMemberStatusUpdate"
} satisfies Record<TriggerType["type"], Extract<keyof TriggerService, `trigger${string}`>>;

const events = {
    sticky_message: ["messageCreate"],
    member_status_update: ["presenceUpdate"]
} satisfies Record<TriggerType["type"], (keyof ClientEvents)[]>;

type TriggerHandlerContext<M extends boolean = false> = {
    message: M extends false ? Message | undefined : M extends true ? Message : never;
    member?: GuildMember;
    newPresence?: Presence;
    oldPresence?: Presence | null;
};

export default class TriggerService extends Service implements HasEventListeners {
    private readonly lastStickyMessages: Record<`${Snowflake}_${Snowflake}`, Message | undefined> = {};
    private readonly lastStickyMessageQueues: Record<`${Snowflake}_${Snowflake}`, boolean> = {};

    private config(guildId: Snowflake) {
        return this.client.configManager.config[guildId]?.auto_triggers;
    }

    @GatewayEventListener("presenceUpdate")
    onPresenceUpdate(oldPresence: Presence | null, newPresence: Presence) {
        if (newPresence?.user?.bot) {
            return false;
        }

        const config = this.config(newPresence?.guild?.id ?? "");

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

        this.processTriggers(
            config.triggers,
            {
                roles: [...(newPresence?.member?.roles.cache.keys() ?? [])],
                userId: newPresence.user?.id,
                context: {
                    message: undefined,
                    oldPresence,
                    newPresence
                }
            },
            ["presenceUpdate"]
        );
    }

    onMessageCreate(message: Message<boolean>) {
        if (message.author.bot) {
            return false;
        }

        const config = this.config(message.guildId!);

        if (!config?.enabled || config?.global_disabled_channels?.includes(message.channelId!)) {
            return false;
        }

        this.processMessageTriggers(message, config.triggers);
        return true;
    }

    processTriggers(
        triggers: TriggerType[],
        data: Parameters<typeof this.processTrigger<false>>[1],
        triggerEvents: (keyof ClientEvents)[] | undefined = undefined
    ) {
        loop: for (const trigger of triggers) {
            if (triggerEvents !== undefined) {
                for (const triggerEvent of triggerEvents) {
                    if (!(events[trigger.type] as any).includes(triggerEvent)) {
                        continue loop;
                    }
                }
            }

            this.processTrigger<boolean>(trigger, data).catch(logError);
        }
    }

    processMessageTriggers(message: Message, triggers: TriggerType[]) {
        for (const trigger of triggers) {
            if (!(events[trigger.type] as any).includes("messageCreate")) {
                continue;
            }

            this.processTrigger(trigger, {
                channelId: message.channelId!,
                roles: message.member!.roles.cache.keys(),
                userId: message.author.id,
                context: {
                    message
                }
            }).catch(logError);
        }
    }

    async processTrigger<B extends true | false>(
        trigger: TriggerType,
        {
            channelId,
            roles,
            userId,
            context
        }: {
            channelId?: string;
            userId?: string;
            roles?: IterableIterator<Snowflake> | Snowflake[];
            context: TriggerHandlerContext<B>;
        }
    ) {
        if (channelId && !trigger.enabled_channels.includes(channelId)) {
            return;
        }

        if (userId && trigger.ignore_users.includes(userId)) {
            return;
        }

        if (roles) {
            for (const roleId of roles) {
                if (trigger.ignore_roles.includes(roleId)) {
                    return;
                }
            }
        }

        const callback = this[handlers[trigger.type]].bind(this);

        if (handlers[trigger.type].startsWith("triggerMessage")) {
            if (!context.message) {
                throw new Error(
                    "Attempting to call a message trigger without specifying a message object inside the context. This is an internal error."
                );
            }
        }

        if (handlers[trigger.type].startsWith("trigger")) {
            await callback(trigger as any, context as any);
        }
    }

    async triggerMemberStatusUpdate(
        trigger: Extract<TriggerType, { type: "member_status_update" }>,
        { newPresence, oldPresence }: TriggerHandlerContext<false>
    ) {
        if (!newPresence || !oldPresence || (!trigger.must_contain && !trigger.must_not_contain)) {
            return;
        }

        const oldStatus = oldPresence?.activities.find(a => a.type === ActivityType.Custom)?.state ?? "";
        const newStatus = newPresence?.activities.find(a => a.type === ActivityType.Custom)?.state ?? "";

        if (newPresence.status === "offline" || newPresence.status === "invisible") {
            return;
        }

        if (oldStatus === newStatus) {
            return;
        }

        if (trigger.must_contain) {
            for (const string of trigger.must_contain) {
                if (!newStatus.includes(string)) {
                    return;
                }
            }
        }

        if (trigger.must_not_contain) {
            for (const string of trigger.must_not_contain) {
                if (newStatus.includes(string)) {
                    return;
                }
            }
        }

        try {
            if (trigger.action === "assign_role") {
                await newPresence.member?.roles.add(trigger.roles);
            } else if (trigger.action === "take_away_role") {
                await newPresence.member?.roles.remove(trigger.roles);
            }
        } catch (e) {
            logError(e);
        }
    }

    async triggerMessageSticky(
        trigger: Extract<TriggerType, { type: "sticky_message" }>,
        { message }: TriggerHandlerContext<true>
    ) {
        if (!this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`]) {
            this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`] = true;

            setTimeout(async () => {
                const lastStickyMessage = this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`];

                if (lastStickyMessage) {
                    try {
                        await lastStickyMessage.delete();
                        this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`] = undefined;
                    } catch (e) {
                        logError(e);
                        return;
                    }
                }

                try {
                    const sentMessage = await message.channel.send({
                        content: trigger.message,
                        components:
                            trigger.buttons.length === 0
                                ? undefined
                                : [
                                      new ActionRowBuilder<ButtonBuilder>().addComponents(
                                          ...trigger.buttons.map(({ label, url }) =>
                                              new ButtonBuilder().setStyle(ButtonStyle.Link).setURL(url).setLabel(label)
                                          )
                                      )
                                  ]
                    });

                    this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`] = sentMessage;
                    this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`] = false;
                } catch (e) {
                    logError(e);
                }
            }, 2000);
        }
    }
}
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 {
21			ActionRowBuilder,
22			ActivityType,
23			ButtonBuilder,
24			ButtonStyle,
25			ClientEvents,
26			GuildMember,
27			Message,
28			Presence,
29			Snowflake
30			} from "discord.js";
31			import Service from "../core/Service";
32			import { GatewayEventListener } from "../decorators/GatewayEventListener";
33			import { HasEventListeners } from "../types/HasEventListeners";
34			import { TriggerType } from "../types/TriggerSchema";
35			import { logError } from "../utils/logger";
36
37			export const name = "triggerService";
38
39			const handlers = {
40			sticky_message: "triggerMessageSticky",
41			member_status_update: "triggerMemberStatusUpdate"
42			} satisfies Record<TriggerType["type"], Extract<keyof TriggerService, `trigger${string}`>>;
43
44			const events = {
45			sticky_message: ["messageCreate"],
46			member_status_update: ["presenceUpdate"]
47			} satisfies Record<TriggerType["type"], (keyof ClientEvents)[]>;
48
49			type TriggerHandlerContext<M extends boolean = false> = {
50			message: M extends false ? Message \| undefined : M extends true ? Message : never;
51			member?: GuildMember;
52			newPresence?: Presence;
53			oldPresence?: Presence \| null;
54			};
55
56			export default class TriggerService extends Service implements HasEventListeners {
57			private readonly lastStickyMessages: Record<`${Snowflake}_${Snowflake}`, Message \| undefined> = {};
58			private readonly lastStickyMessageQueues: Record<`${Snowflake}_${Snowflake}`, boolean> = {};
59
60			private config(guildId: Snowflake) {
61			return this.client.configManager.config[guildId]?.auto_triggers;
62			}
63
64			@GatewayEventListener("presenceUpdate")
65			onPresenceUpdate(oldPresence: Presence \| null, newPresence: Presence) {
66			if (newPresence?.user?.bot) {
67			return false;
68			}
69
70			const config = this.config(newPresence?.guild?.id ?? "");
71
72			if (!config?.enabled) {
73			return false;
74			}
75
76			this.processTriggers(
77			config.triggers,
78			{
79			roles: [...(newPresence?.member?.roles.cache.keys() ?? [])],
80			userId: newPresence.user?.id,
81			context: {
82			message: undefined,
83			oldPresence,
84			newPresence
85			}
86			},
87			["presenceUpdate"]
88			);
89			}
90
91			onMessageCreate(message: Message<boolean>) {
92			if (message.author.bot) {
93			return false;
94			}
95
96			const config = this.config(message.guildId!);
97
98			if (!config?.enabled \|\| config?.global_disabled_channels?.includes(message.channelId!)) {
99			return false;
100			}
101
102			this.processMessageTriggers(message, config.triggers);
103			return true;
104			}
105
106			processTriggers(
107			triggers: TriggerType[],
108			data: Parameters<typeof this.processTrigger<false>>[1],
109			triggerEvents: (keyof ClientEvents)[] \| undefined = undefined
110			) {
111			loop: for (const trigger of triggers) {
112			if (triggerEvents !== undefined) {
113			for (const triggerEvent of triggerEvents) {
114			if (!(events[trigger.type] as any).includes(triggerEvent)) {
115			continue loop;
116			}
117			}
118			}
119
120			this.processTrigger<boolean>(trigger, data).catch(logError);
121			}
122			}
123
124			processMessageTriggers(message: Message, triggers: TriggerType[]) {
125			for (const trigger of triggers) {
126			if (!(events[trigger.type] as any).includes("messageCreate")) {
127			continue;
128			}
129
130			this.processTrigger(trigger, {
131			channelId: message.channelId!,
132			roles: message.member!.roles.cache.keys(),
133			userId: message.author.id,
134			context: {
135			message
136			}
137			}).catch(logError);
138			}
139			}
140
141			async processTrigger<B extends true \| false>(
142			trigger: TriggerType,
143			{
144			channelId,
145			roles,
146			userId,
147			context
148			}: {
149			channelId?: string;
150			userId?: string;
151			roles?: IterableIterator<Snowflake> \| Snowflake[];
152			context: TriggerHandlerContext<B>;
153			}
154			) {
155			if (channelId && !trigger.enabled_channels.includes(channelId)) {
156			return;
157			}
158
159			if (userId && trigger.ignore_users.includes(userId)) {
160			return;
161			}
162
163			if (roles) {
164			for (const roleId of roles) {
165			if (trigger.ignore_roles.includes(roleId)) {
166			return;
167			}
168			}
169			}
170
171			const callback = this[handlers[trigger.type]].bind(this);
172
173			if (handlers[trigger.type].startsWith("triggerMessage")) {
174			if (!context.message) {
175			throw new Error(
176			"Attempting to call a message trigger without specifying a message object inside the context. This is an internal error."
177			);
178			}
179			}
180
181			if (handlers[trigger.type].startsWith("trigger")) {
182			await callback(trigger as any, context as any);
183			}
184			}
185
186			async triggerMemberStatusUpdate(
187			trigger: Extract<TriggerType, { type: "member_status_update" }>,
188			{ newPresence, oldPresence }: TriggerHandlerContext<false>
189			) {
190			if (!newPresence \|\| !oldPresence \|\| (!trigger.must_contain && !trigger.must_not_contain)) {
191			return;
192			}
193
194			const oldStatus = oldPresence?.activities.find(a => a.type === ActivityType.Custom)?.state ?? "";
195			const newStatus = newPresence?.activities.find(a => a.type === ActivityType.Custom)?.state ?? "";
196
197			if (newPresence.status === "offline" \|\| newPresence.status === "invisible") {
198			return;
199			}
200
201			if (oldStatus === newStatus) {
202			return;
203			}
204
205			if (trigger.must_contain) {
206			for (const string of trigger.must_contain) {
207			if (!newStatus.includes(string)) {
208			return;
209			}
210			}
211			}
212
213			if (trigger.must_not_contain) {
214			for (const string of trigger.must_not_contain) {
215			if (newStatus.includes(string)) {
216			return;
217			}
218			}
219			}
220
221			try {
222			if (trigger.action === "assign_role") {
223			await newPresence.member?.roles.add(trigger.roles);
224			} else if (trigger.action === "take_away_role") {
225			await newPresence.member?.roles.remove(trigger.roles);
226			}
227			} catch (e) {
228			logError(e);
229			}
230			}
231
232			async triggerMessageSticky(
233			trigger: Extract<TriggerType, { type: "sticky_message" }>,
234			{ message }: TriggerHandlerContext<true>
235			) {
236			if (!this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`]) {
237			this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`] = true;
238
239			setTimeout(async () => {
240			const lastStickyMessage = this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`];
241
242			if (lastStickyMessage) {
243			try {
244			await lastStickyMessage.delete();
245			this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`] = undefined;
246			} catch (e) {
247			logError(e);
248			return;
249			}
250			}
251
252			try {
253			const sentMessage = await message.channel.send({
254			content: trigger.message,
255			components:
256			trigger.buttons.length === 0
257			? undefined
258			: [
259			new ActionRowBuilder<ButtonBuilder>().addComponents(
260			...trigger.buttons.map(({ label, url }) =>
261			new ButtonBuilder().setStyle(ButtonStyle.Link).setURL(url).setLabel(label)
262			)
263			)
264			]
265			});
266
267			this.lastStickyMessages[`${message.guildId!}_${message.channelId!}`] = sentMessage;
268			this.lastStickyMessageQueues[`${message.guildId!}_${message.channelId!}`] = false;
269			} catch (e) {
270			logError(e);
271			}
272			}, 2000);
273			}
274			}
275			}