Perguntas Anónimas

application/usecases/readDirectMessage.ts

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

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;
+  sendDirectMessageToUser(message: string, userId: string): void;
 }

domain/service/commandUseCaseResolver.ts

@@ -56,7 +56,8 @@ export default class CommandUseCaseResolver {
       "!ja": async () =>
         new SendMessageToChannelUseCase(deps).execute({
           channelId: context.channelId,
-          message: ":point_right: https://dontasktoask.com/pt-pt/",
+          message: 
+          ":point_right: https://dontasktoask.com/pt-pt/",
         }),
       "!oc": async () =>
         new SendMessageToChannelUseCase(deps).execute({

index.ts

@@ -1,8 +1,11 @@
-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";
+import DiscordEmbedService from "./infrastructure/service/discordEmbedService";
+import QuestionChatService from "./application/usecases/sendMessageToChannel/sendPerguntaToChannel";
 import DiscordChatService from "./infrastructure/service/discordChatService";
 import ConsoleLoggerService from "./infrastructure/service/consoleLoggerService";
 import MessageRepository from "./domain/repository/messageRepository";
@@ -11,15 +14,23 @@ 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 questionChatService: QuestionChatService = new DiscordEmbedService(client);
 const messageRepository: MessageRepository = new FileMessageRepository();
 const chatService: ChatService = new DiscordChatService(client);
 const loggerService: LoggerService = new ConsoleLoggerService();
@@ -61,3 +72,52 @@ client.on("messageCreate", (messages: Message) => {
     loggerService.log(error);
   }
 });
+
+client.on("message", async (message) => {
+  const directMessage = new DirectMessage(message, client, channelResolver, chatService, questionChatService);
+
+  if (await directMessage.isValid()) {
+    directMessage.approveMessage();
+  }
+});
+
+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.slice(0, 3)) {
+    case "apr":
+      {
+        const sentence = `PERGUNTA ANÓNIMA:\n${messageContent}`;
+        chatService.sendMessageToChannel(sentence, channelResolver.getBySlug(ChannelSlug.QUESTION));
+        interaction.update({ components: [], embeds: [messageApprovedEmbed] });
+        chatService.sendDirectMessageToUser(interaction.customId.slice(3), "A tua mensagem foi aprovada.");
+      }
+      break;
+
+    case "rej":
+      chatService.deleteMessageFromChannel(messageId, channelId);
+      chatService.sendDirectMessageToUser(
+        interaction.customId.slice(3),
+        "A tua mensagem não foi aprovada.\nVerifica se está de acordo com as regras."
+      );
+      break;
+    default:
+      break;
+  }
+});

infrastructure/service/discordChatService.ts

@@ -14,7 +14,25 @@ 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 sendDirectMessageToUser(userId: string, message: string): Promise<void> {
+    const user = await this.client.users.fetch(userId);
+    await user.send(message);
+  }
 }

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