Perguntas Anónimas

application/usecases/readDirectMessage.ts

@@ -0,0 +1,64 @@
+import { Message, Client, MessageEmbed, MessageActionRow, MessageButton } from "discord.js";
+import { ChannelSlug } from "../../types";
+import QuestionChatService from "./sendMessageToChannel/sendPerguntaToChannel";
+import DiscordEmbedService from "../../infrastructure/service/discordEmbedService";
+import ChatService from "../../domain/service/chatService";
+import DiscordChatService from "../../infrastructure/service/discordChatService";
+import ChannelResolver from "../../domain/service/channelResolver";
+
+const askedRecently = new Set();
+class DirectMessage {
+  constructor(private message: Message, private client: Client, private channelResolver: ChannelResolver) {}
+
+  async validate() {
+    if (askedRecently.has(this.message.author.id)) {
+      this.message.channel.send("Ainda não podes enviar outra pergunta. Tenta mais tarde.");
+    } else {
+      const chatService: ChatService = new DiscordChatService(this.client);
+      if (this.message.author.id === this.client.user?.id) {
+        return false;
+      }
+
+      if (
+        this.message.channel.type === "DM" &&
+        this.message.content.startsWith("!pergunta") &&
+        this.message.content.split(" ").length > 1 &&
+        this.message.content.length <= 1500
+      ) {
+        askedRecently.add(this.message.author.id);
+        setTimeout(() => {
+          askedRecently.delete(this.message.author.id);
+        }, 60000);
+        return true;
+      }
+      chatService.sendDM(this.message.author.id, "Por favor usa o seguinte formato:\n!pergunta <mensagem>");
+      return false;
+    }
+    return true;
+  }
+
+  async messageApprove() {
+    const chatService: ChatService = new DiscordChatService(this.client);
+    const channelAnonQuestion = this.client.channels.cache.get(this.channelResolver.getBySlug(ChannelSlug.QUESTION));
+    const questionChatService: QuestionChatService = new DiscordEmbedService(this.client);
+    const sentence = this.message.content.split(" ").slice(1).join(" ");
+    const buttons = new MessageActionRow().addComponents(
+      new MessageButton().setLabel("Aprovar").setStyle("SUCCESS").setCustomId("bt1"),
+      new MessageButton().setLabel("Eliminar").setStyle("DANGER").setCustomId("bt2")
+    );
+    const mensagem = new MessageEmbed().setColor("#0099ff").setTitle("Pergunta Anónima").setDescription(sentence);
+
+    await questionChatService.sendEmbedToChannel(
+      mensagem,
+      buttons,
+      this.channelResolver.getBySlug(ChannelSlug.MOD_CHANNEL)
+    );
+
+    await chatService.sendDM(
+      this.message.author.id,
+      `A tua pergunta foi colocada com sucesso.\nApós aprovação poderás visualizar no ${channelAnonQuestion} `
+    );
+  }
+}
+
+export default DirectMessage;

application/usecases/sendMessageToChannel/sendPerguntaToChannel.ts

@@ -0,0 +1,5 @@
+import { MessageEmbed, MessageActionRow } from "discord.js";
+
+export default interface SendMessageToChannel {
+  sendEmbedToChannel(message: MessageEmbed, row: MessageActionRow, channelId: string): void;
+}

domain/service/channelResolver.ts

@@ -3,6 +3,8 @@ import { ChannelSlug } from "../../types";
 const fallbackChannelIds: Record<ChannelSlug, string> = {
   [ChannelSlug.ENTRANCE]: "855861944930402344",
   [ChannelSlug.JOBS]: "876826576749215744",
+  [ChannelSlug.QUESTION]: "1066328934825865216",
+  [ChannelSlug.MOD_CHANNEL]: "987719981443723266",
 };
 
 export default class ChannelResolver {

domain/service/chatService.ts

@@ -1,3 +1,5 @@
 export default interface ChatService {
   sendMessageToChannel(message: string, channelId: string): void;
+  deleteMessageFromChannel(messageId: string, channelId: string): void;
+  sendDM(message: string, userId: string): void;
 }

index.ts

@@ -1,5 +1,6 @@
-import { GuildMember, Message, Client, Intents } from "discord.js";
+import { GuildMember, Message, Client, Intents, MessageEmbed } from "discord.js";
 import * as dotenv from "dotenv";
+import { ChannelSlug } from "./types";
 import SendWelcomeMessageUseCase from "./application/usecases/sendWelcomeMessageUseCase";
 import FileMessageRepository from "./infrastructure/repository/fileMessageRepository";
 import ChatService from "./domain/service/chatService";
@@ -11,13 +12,21 @@ import CommandUseCaseResolver from "./domain/service/commandUseCaseResolver";
 import ChannelResolver from "./domain/service/channelResolver";
 import KataService from "./domain/service/kataService/kataService";
 import CodewarsKataService from "./infrastructure/service/codewarsKataService";
+import DirectMessage from "./application/usecases/readDirectMessage";
 
 dotenv.config();
 
 const { DISCORD_TOKEN } = process.env;
 
 const client = new Client({
-  intents: [Intents.FLAGS.GUILDS, Intents.FLAGS.GUILD_MEMBERS, Intents.FLAGS.GUILD_MESSAGES],
+  partials: ["CHANNEL"],
+  intents: [
+    Intents.FLAGS.GUILDS,
+    Intents.FLAGS.DIRECT_MESSAGES,
+    Intents.FLAGS.DIRECT_MESSAGE_TYPING,
+    Intents.FLAGS.GUILD_MEMBERS,
+    Intents.FLAGS.GUILD_MESSAGES,
+  ],
 });
 
 const messageRepository: MessageRepository = new FileMessageRepository();
@@ -61,3 +70,54 @@ client.on("messageCreate", (messages: Message) => {
     loggerService.log(error);
   }
 });
+
+client.on("message", async (message) => {
+  const directMessage = new DirectMessage(message, client, channelResolver);
+  const validationCheck = await directMessage.validate();
+  if (validationCheck) {
+    directMessage.messageApprove();
+  }
+});
+
+client.on("interactionCreate", async (interaction) => {
+  if (!interaction.isButton()) return;
+
+  const {
+    message: {
+      id: messageId,
+      embeds: [{ description: messageContent }],
+    },
+    channelId,
+  } = interaction;
+
+  const userName = interaction.member?.user.username;
+
+  if (!messageContent) return;
+  const messageApprovedEmbed = new MessageEmbed()
+    .setColor("#0099ff")
+    .setTitle("Pergunta Anónima")
+    .setDescription(messageContent)
+    .setFooter({ text: `Aprovado por ${userName}` });
+
+  switch (interaction.customId) {
+    case "bt1":
+      {
+        const sentence = `PERGUNTA ANÓNIMA:\n${messageContent}`;
+        chatService.sendMessageToChannel(sentence, channelResolver.getBySlug(ChannelSlug.QUESTION));
+        interaction.update({ components: [], embeds: [messageApprovedEmbed] });
+        chatService.sendDM(interaction.user.id, "A tua mensagem foi aprovada.");
+      }
+      break;
+
+    case "bt2":
+      chatService.deleteMessageFromChannel(messageId, channelId);
+      chatService.sendDM(
+        interaction.user.id,
+        "A tua mensagem não foi aprovada.\nVerifica se está de acordo com as regras."
+      );
+      break;
+    default: {
+      console.log("default");
+    }
+  }
+});

infrastructure/service/discordChatService.ts

@@ -14,7 +14,31 @@ export default class DiscordChatService implements ChatService {
     if (!channel.isText()) {
       throw new Error(`Channel with id ${channelId} is not a text channel!`);
     }
-
     channel.send(message);
   }
+
+  async deleteMessageFromChannel(messageId: string, channelId: string): Promise<void> {
+    const channel = await this.client.channels.fetch(channelId);
+
+    if (channel === null) {
+      throw new Error(`Channel with id ${channelId} not found!`);
+    }
+
+    if (!channel.isText()) {
+      throw new Error(`Channel with id ${channelId} is not a text channel!`);
+    }
+
+    channel.messages.delete(messageId);
+  }
+
+  async sendDM(userId: string, message: string): Promise<boolean> {
+    try {
+      const user = await this.client.users.fetch(userId);
+      await user.send(message);
+      return true;
+    } catch (e) {
+      console.error(e);
+      return false;
+    }
+  }
 }

infrastructure/service/discordEmbedService.ts

@@ -0,0 +1,19 @@
+import { Client, MessageEmbed, MessageActionRow } from "discord.js";
+
+export default class DiscordEmbedService {
+  constructor(private client: Client) {}
+
+  async sendEmbedToChannel(embed: MessageEmbed, row: MessageActionRow, channelId: string): Promise<void> {
+    const channel = await this.client.channels.fetch(channelId);
+
+    if (channel === null) {
+      throw new Error(`Channel with id ${channelId} not found!`);
+    }
+
+    if (!channel.isText()) {
+      throw new Error(`Channel with id ${channelId} is not a text channel!`);
+    }
+
+    channel.send({ embeds: [embed], components: [row] });
+  }
+}