src/utils/Queue.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 { Guild, TextChannel } from "discord.js";
import Client from "../core/Client";
import { logError } from "./logger";
import { isTextableChannel } from "./utils";

export interface QueueConstructorOptions {
    client: Client;
    createdAt: Date;
    willRunAt: Date;
    guild: Guild;
    channelId?: string;
    messageId?: string;
    userId: string;
    filePath: string;
    args: string[];
    id?: number;
    name: string;
}

export default abstract class Queue {
    protected readonly client: Client;
    public readonly createdAt: Date;
    public readonly willRunAt: Date;
    public readonly guild: Guild;
    public readonly channelId: string | undefined;
    public readonly messageId: string | undefined;
    public readonly userId: string;
    public readonly filePath: string;
    public readonly args: string[] = [];

    constructor({ client, createdAt, willRunAt, guild, channelId, messageId, userId, filePath, args }: QueueConstructorOptions) {
        this.client = client;
        this.createdAt = createdAt;
        this.willRunAt = willRunAt;
        this.guild = guild;
        this.channelId = channelId;
        this.messageId = messageId;
        this.userId = userId;
        this.filePath = filePath;
        this.args = args;
    }

    async channel() {
        if (!this.channelId) return;

        try {
            return await (this.guild.channels.cache.get(this.channelId) ?? this.guild.channels.fetch(this.channelId));
        } catch (e) {
            logError(e);
            return null;
        }
    }

    async message(channel?: TextChannel) {
        if (!this.messageId) return null;

        try {
            const fetchedChannel = channel ?? (await this.channel());

            if (!fetchedChannel || !isTextableChannel(fetchedChannel)) return null;

            return fetchedChannel.messages.cache.get(this.messageId) ?? (await fetchedChannel.messages.fetch(this.messageId));
        } catch (e) {
            logError(e);
            return null;
        }
    }

    abstract run(...args: string[]): Promise<any> | any;
}
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 { Guild, TextChannel } from "discord.js";
21	import Client from "../core/Client";
22	import { logError } from "./logger";
23	import { isTextableChannel } from "./utils";
24
25	export interface QueueConstructorOptions {
26	client: Client;
27	createdAt: Date;
28	willRunAt: Date;
29	guild: Guild;
30	channelId?: string;
31	messageId?: string;
32	userId: string;
33	filePath: string;
34	args: string[];
35	id?: number;
36	name: string;
37	}
38
39	export default abstract class Queue {
40	protected readonly client: Client;
41	public readonly createdAt: Date;
42	public readonly willRunAt: Date;
43	public readonly guild: Guild;
44	public readonly channelId: string \| undefined;
45	public readonly messageId: string \| undefined;
46	public readonly userId: string;
47	public readonly filePath: string;
48	public readonly args: string[] = [];
49
50	constructor({ client, createdAt, willRunAt, guild, channelId, messageId, userId, filePath, args }: QueueConstructorOptions) {
51	this.client = client;
52	this.createdAt = createdAt;
53	this.willRunAt = willRunAt;
54	this.guild = guild;
55	this.channelId = channelId;
56	this.messageId = messageId;
57	this.userId = userId;
58	this.filePath = filePath;
59	this.args = args;
60	}
61
62	async channel() {
63	if (!this.channelId) return;
64
65	try {
66	return await (this.guild.channels.cache.get(this.channelId) ?? this.guild.channels.fetch(this.channelId));
67	} catch (e) {
68	logError(e);
69	return null;
70	}
71	}
72
73	async message(channel?: TextChannel) {
74	if (!this.messageId) return null;
75
76	try {
77	const fetchedChannel = channel ?? (await this.channel());
78
79	if (!fetchedChannel \|\| !isTextableChannel(fetchedChannel)) return null;
80
81	return fetchedChannel.messages.cache.get(this.messageId) ?? (await fetchedChannel.messages.fetch(this.messageId));
82	} catch (e) {
83	logError(e);
84	return null;
85	}
86	}
87
88	abstract run(...args: string[]): Promise<any> \| any;
89	}