Perguntas Anónimas

application/usecases/readDirectMessage.ts

@@ -0,0 +1,47 @@
+import { Message, Client, MessageEmbed, MessageActionRow, MessageButton } from "discord.js";
+import sendDM from "./sendMessageToChannel/sendDM";
+import PerguntaChatService from "./sendMessageToChannel/sendPerguntaToChannel";
+import DiscordEmbedService from "../../infrastructure/service/discordEmbedService";
+
+class DirectMessage {
+  constructor(private message: Message, private client: Client) {}
+
+  async validate() {
+    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
+    ) {
+      return true;
+    }
+    sendDM(this.client, this.message.author.id, "Por favor usa o seguinte formato:\n!pergunta <mensagem>");
+    return false;
+  }
+
+  async messageApprove() {
+    const canalPerguntaAnonima = this.client.channels.cache.get("1066328934825865216");
+    const chatService: PerguntaChatService = new DiscordEmbedService(this.client);
+    const modChannel = "987719981443723266";
+    const sentence = this.message.content.split(" ").slice(1).join(" ");
+    const row = new MessageActionRow().addComponents(
+      new MessageButton().setLabel("Aprovar").setStyle("SUCCESS").setCustomId("bt1"),
+      new MessageButton().setCustomId("bt2").setLabel("Eliminar").setStyle("DANGER")
+    );
+    const Mensagem = new MessageEmbed().setColor("#0099ff").setTitle("Pergunta Anónima").setDescription(sentence);
+
+    await chatService.sendEmbedToChannel(Mensagem, row, modChannel);
+    const dmSent = sendDM(
+      this.client,
+      this.message.author.id,
+      `A tua pergunta foi colocada com sucesso.\nApós aprovação poderás visualizar no ${canalPerguntaAnonima} `
+    );
+    if (!dmSent) console.log("dm não enviada");
+  }
+}
+
+export default DirectMessage;

application/usecases/sendMessageToChannel/sendDM.ts

@@ -0,0 +1,18 @@
+import { Client } from "discord.js";
+
+function sendMessage(client: Client, userId: string, message: string): boolean {
+  client.users
+    .fetch(userId)
+    .then(async (user) => {
+      const exists = await user.send(message);
+      const res = !!exists;
+      return res;
+    })
+    .catch((e) => {
+      console.log(e);
+      return false;
+    });
+  return false;
+}
+
+export default sendMessage;

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,7 @@ import { ChannelSlug } from "../../types";
 const fallbackChannelIds: Record<ChannelSlug, string> = {
   [ChannelSlug.ENTRANCE]: "855861944930402344",
   [ChannelSlug.JOBS]: "876826576749215744",
+  [ChannelSlug.QUESTION]: "876826576749215744",
 };
 
 export default class ChannelResolver {

domain/service/chatService.ts

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

index.ts

@@ -1,4 +1,4 @@
-import { GuildMember, Message, Client, Intents } from "discord.js";
+import { GuildMember, Message, Client, Intents, MessageEmbed } from "discord.js";
 import * as dotenv from "dotenv";
 import SendWelcomeMessageUseCase from "./application/usecases/sendWelcomeMessageUseCase";
 import FileMessageRepository from "./infrastructure/repository/fileMessageRepository";
@@ -11,15 +11,24 @@ 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 canalPerguntaAnonima = "1066328934825865216";
 const messageRepository: MessageRepository = new FileMessageRepository();
 const chatService: ChatService = new DiscordChatService(client);
 const loggerService: LoggerService = new ConsoleLoggerService();
@@ -61,3 +70,49 @@ client.on("messageCreate", (messages: Message) => {
     loggerService.log(error);
   }
 });
+
+client.on("message", async (message) => {
+  const directMessage = new DirectMessage(message, client);
+  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, canalPerguntaAnonima);
+        interaction.update({ components: [], embeds: [messageApprovedEmbed] });
+      }
+      break;
+
+    case "bt2":
+      chatService.deleteMessageFromChannel(messageId, channelId);
+      break;
+    default: {
+      console.log("default");
+    }
+  }
+});

infrastructure/service/discordChatService.ts

@@ -14,7 +14,20 @@ 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);
+  }
 }

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] });
+  }
+}