avocadi-bot/src/actions/greeting/greeting.service.ts

import config from "config";
import client from "lib/client";
import { getRandomInt } from "lib/utils";
import {
	getWelcomeContent,
	greetContent,
	sleepContent,
} from "./greeting.components.ts";
import {
	type ChatInputCommandInteraction,
	Client,
	EmbedBuilder,
	type CacheType,
	type GuildMember,
	type Interaction,
	GuildMemberRoleManager,
	type APIInteractionGuildMember,
} from "discord.js";
import { DmService } from "actions/dm/dm.service.ts";
import { Commands, type CommandsType } from "commands/index.ts";

export class GreetingService {
	dmService: DmService;

	constructor() {
		this.dmService = new DmService();
	}

	async handleInteraction(
		interaction: Interaction<CacheType>
	) {

		if (interaction.isChatInputCommand()) {
			await this.handleChatInputCommand(interaction);
			return;
		}

	}
	async handleChatInputCommand(interaction: ChatInputCommandInteraction<CacheType>) {
		const commandName = interaction.commandName as CommandsType;
		switch (commandName) {
			case Commands.Enum.accept:
				await this.acceptUser(interaction);
				return;
			case Commands.Enum.welcome:
				await this.welcomeCommand(interaction);
				return;
			case Commands.Enum.reminder:
				await this.reminderCommand(interaction);
				return;
			default:
				break;
		}
	}

	async welcome(member: GuildMember) {
		console.log("welcome msg");
		const welcomeContent = getWelcomeContent(member);

		try {
			const channels = client.channels;
			const channel = channels.cache.get(config.discord.channelIdWelcome);

			if (channel?.isTextBased() && channel?.isSendable()) {
				await channel.send(welcomeContent);
			}

			await this.dmService.welcomePrivate(member);
		} catch (error) {
			console.error("error while sending a welcome msg:", error);
		}
	}

	async acceptUser(
		interaction: ChatInputCommandInteraction<CacheType>
	) {
		console.log("accept user");

		// get the string option
		const input = interaction.options.getString("input") || "";
		// return the value
		//console.log(input);

		// permission check
		if (await this.checkPermission(interaction.member) !== true) {
			await interaction.reply({
				content: "du hast keine rechte fuer diesen befehl",
				ephemeral: true,
			});
			return;
		}

		try {
			// get user id from mentioning
			const userId = input.replace(/[<@!>]/g, "");
			console.log(userId.toString());
			const guild = interaction.guild;
			if (!guild) {
				await interaction.reply({
					content: "command can only be used on a server",
					ephemeral: true,
				});
				return;
			}

			const member = await guild.members.fetch(userId);
			const username = member.user.username;
			console.log(username);

			if (await this.checkRole(member) === true) {
				await interaction.reply({
					content: `${member.user.username} hat die rolle *lernende:r* schon!`,
					ephemeral: true,
				});
				return;
			}

			await member.roles.add(config.discord.roleStudy);

			await interaction.reply({
				content: `die rolle *lernende:r* wurde erfolgreich an ${member.user.username} vergeben`,
				ephemeral: true,
			});

			this.dmService.acceptDm(member);
		} catch (error) {
			console.error("Fehler beim Hinzufügen der Rolle:", error);
			await interaction.reply({
				content:
					"Es gab einen Fehler beim Hinzufügen der Rolle. Stelle sicher, dass du einen gültigen User erwähnt hast.",
				ephemeral: true,
			});
		}
	}

	async greet() {
		client.user?.setActivity("guten morgen! :3", { type: 4 });
		console.log("set activity: awake");
		client.user?.setPresence({
			status: "online",
		});

		const channels = client.channels;

		const channel = channels.cache.get(config.discord.testChannel);

		if (channel?.isTextBased && channel?.isSendable()) {
			await channel.send({ content: this.getContent(false) });
		}
	}

	async sleep() {
		client.user?.setActivity("zzzzZZ..", { type: 4 });
		console.log("set activity: asleep");
		client.user?.setPresence({
			status: "dnd",
		});

		const channels = client.channels;

		const channel = channels.cache.get(config.discord.testChannel);

		if (channel?.isTextBased && channel?.isSendable()) {
			await channel.send({ content: this.getContent(true) });
		}
	}

	async newYear() {
		client.user?.setActivity("frohes neues! :)", { type: 4 });
		console.log("set activity: happy new year");
		client.user?.setPresence({
			status: "online",
		});

		/*const channels = client.channels;

		const channel = channels.cache.get(config.discord.channelId);

		if (channel?.isTextBased && channel?.isSendable()) {
			await channel.send({ content: "frohes neues! @everyone" });
		}*/
	}

	getContent(asleep: boolean) {
		if (asleep) {
			return sleepContent[getRandomInt(0, sleepContent.length - 1)];
		}
		return greetContent[getRandomInt(0, greetContent.length - 1)];
	}

	async reminderCommand(
		interaction: ChatInputCommandInteraction<CacheType>) {
		console.log("remind user");

		// get the string option
		const input = interaction.options.getString("input") || "";
		// return the value
		//console.log(input);

		try {
			// permission check
			if (await this.checkPermission(interaction.member) !== true) {
				await interaction.reply({
					content: "du hast keine rechte fuer diesen befehl",
					ephemeral: true,
				});
				return;
			}

			// get user id from mentioning
			const userId = input.replace(/[<@!>]/g, "");
			console.log(userId.toString());
			const guild = interaction.guild;
			if (!guild) {
				await interaction.reply({
					content: "command can only be used on a server",
					ephemeral: true,
				});
				return;
			}

			const member = await guild.members.fetch(userId);
			const username = member.user.username;
			console.log(username);

			if (await this.checkRole(member) === true) {
				await interaction.reply({
					content: `${member.user.username} hat die rolle *lernende:r* schon!`,
					ephemeral: true,
				});
				return;
			}

			await this.dmService.reminderPrivate(member);
			//await member.roles.add(config.discord.roleStudy);

			await interaction.reply({
				content: `${member.user.username} wurde erfolgrich remindet`,
				ephemeral: true,
			});
		} catch (error) {
			console.error("error while reminding:", error);
			await interaction.reply({
				content:
					"Es gab einen Fehler beim reminden. Stelle sicher, dass du einen gültigen User erwähnt hast.",
				ephemeral: true,
			});
		}
	}

	async welcomeCommand(
		interaction: ChatInputCommandInteraction<CacheType>
	) {
		console.log("welcome user");

		// get the string option
		const input = interaction.options.getString("input") || "";
		// return the value
		//console.log(input);

		try {
			// get user id from mentioning
			const userId = input.replace(/[<@!>]/g, "");
			console.log(userId.toString());
			const guild = interaction.guild;
			if (!guild) {
				await interaction.reply({
					content: "command can only be used on a server",
					ephemeral: true,
				});
				return;
			}

			if (await this.checkPermission(interaction.member) !== true) {
				await interaction.reply({
					content: "du hast keine rechte fuer diesen befehl",
					ephemeral: true,
				});
				return;
			}

			// get member from id
			const member = await guild.members.fetch(userId);
			const username = member.user.username;
			console.log(username);

			const welcomeContent = getWelcomeContent(member);

			if (await this.checkRole(member) === true) {
				await interaction.reply({
					content: `${member.user.username} wurde schon begruesst!`,
					ephemeral: true,
				});
			}

			try {
				const channels = client.channels;
				const channel = channels.cache.get(config.discord.channelIdWelcome);

				if (channel?.isTextBased() && channel?.isSendable()) {
					await channel.send(welcomeContent);
				}

				await this.dmService.welcomePrivate(member);

			} catch (error) {
				console.error("error while sending a welcome command msg:", error);
			}

			await interaction.reply({
				content: `erfolgreich welcome command: ${member.user.username}`,
				ephemeral: true,
			});

		} catch (error) {
			console.error("fehler bei welcome command", error);
			await interaction.reply({
				content:
					"fehler bei welcome command",
				ephemeral: true,
			});
		}
	}

	async checkPermission(member: GuildMember | APIInteractionGuildMember | null) {
		let permission = false;
		if (member?.roles instanceof GuildMemberRoleManager) {
			if (member.roles.cache.has(config.discord.roleAdmin) || member.roles.cache.has(config.discord.roleMod)) {
				console.log("user has permission");
				permission = true;
			}
		}
		return permission;
	}

	async checkRole(member: GuildMember) {
		let hasRole = false;
		if (member?.roles instanceof GuildMemberRoleManager) {
			if (member.roles.cache.has(config.discord.roleAdmin) || member.roles.cache.has(config.discord.roleMod)) {
				console.log("user has permission");
				hasRole = true;
			}
		}
		return hasRole;
	}
}