Nome

.env

@@ -0,0 +1 @@
+DISCORD_TOKEN=MTQwMDE0MDg1MDAyOTEzMzgzNA.GHrjJ_.BUbVuE_XjCMGQ0Q2vU7F9tFZsmhWZ5zcsYBGoA

Procfile

@@ -1,5 +1,9 @@
 <<<<<<< HEAD
+<<<<<<< HEAD
 python WIPBOT.py
 =======
 python3 WIPBOT.py
 >>>>>>> 8839ffd (first commit of Discord bot)
+=======
+python WIPBOT.py
+>>>>>>> 462e052 (Salvando alterações locais antes de rebase)

WIPBOTFINAL.py

@@ -0,0 +1,484 @@
+import discord
+from discord.ext import commands
+from discord.ui import View, Select, Button, Modal, TextInput
+from datetime import datetime, timedelta
+import os
+from dotenv import load_dotenv
+load_dotenv()
+jogador_em_progresso = None
+intents = discord.Intents.default()
+intents.message_content = True
+intents.reactions = True
+intents.guilds = True
+intents.members = True
+bot = commands.Bot(command_prefix="!", intents=intents)
+EMOJI_TANK = "🛡️"
+EMOJI_HEALER = "💚"
+EMOJI_DPS = "⚔️"
+DUNGEONS = [
+    "Eco-Dome Al'dani",
+    "Ara-Kara, City of Echoes",
+    "The Dawnbreaker",
+    "Operation: Floodgate",
+    "Priory of the Sacred Flame",
+    "Halls of Atonement",
+    "Tazavesh, the Veiled Market: Streets of Wonder",
+    "Tazavesh, the Veiled Market: So'leah's Gambit"
+]
+DIFICULDADES = [str(i) for i in range(0, 21)] + ["20+"]
+LIMITES = {"Tank": 1, "Healer": 1, "DPS": 3}
+# grupo_mensagem_id = None
+# inscritos = {"Tank": [], "Healer": [], "DPS": []}
+# classes_escolhidas = {}
+# dungeon_escolhida = DUNGEONS[2]
+# dificuldade_escolhida = "10"
+# data_formatada = "06/08/2025"
+# hora_escolhida = "22:00"
+# alteracoes_feitas = {"dungeon": False, "dificuldade": False, "data": False}
+# jogador_em_progresso = None
+
+def format_grupo_embed():
+    def format_role(role):
+        players = inscritos[role]
+        if not players:
+            return "None"
+        return "\n".join(f"{p} ({classes_escolhidas.get(p, 'sem classe')})" for p in players)
+
+    embed = discord.Embed(
+        title=f"Dungeon: {dungeon_escolhida}",
+        description=(
+            f"Dificuldade: {dificuldade_escolhida}\n"
+            f"Marcação: {data_formatada} às {hora_escolhida}"
+        ),
+        color=0x00ffcc
+    )
+    embed.add_field(name=f"{EMOJI_TANK} Tank", value=format_role("Tank"), inline=False)
+    embed.add_field(name=f"{EMOJI_HEALER} Healer", value=format_role("Healer"), inline=False)
+    embed.add_field(name=f"{EMOJI_DPS} DPS", value=format_role("DPS"), inline=False)
+    embed.set_footer(text="Bot created by Kl3z")
+    return embed
+
+async def criar_grupo_customizado(canal):
+    global grupo_mensagem_id, inscritos, dungeon_escolhida, dificuldade_escolhida, data_formatada, hora_escolhida, alteracoes_feitas
+    inscritos = {"Tank": [], "Healer": [], "DPS": []}
+    classes_escolhidas.clear()
+    dungeon_escolhida = DUNGEONS[2]
+    dificuldade_escolhida = "10"
+    data_formatada = "06/08/2025"
+    hora_escolhida = "22:00"
+    alteracoes_feitas = {"dungeon": False, "dificuldade": False, "data": False}
+    embed = format_grupo_embed()
+    mensagem = await canal.send(embed=embed, view=DungeonView())
+    grupo_mensagem_id = mensagem.id
+    await canal.send(
+        "Escolher a tua **Role**:",
+        view=RoleView("Novo jogador", canal.id, grupo_mensagem_id)
+    )
+class StackDropdown(Select):
+    def __init__(self, grupo):
+        self.grupo = grupo
+        options = [
+            discord.SelectOption(label="Plate Stack"),
+            discord.SelectOption(label="Leather Stack"),
+            discord.SelectOption(label="Mail Stack"),
+            discord.SelectOption(label="Cloth Stack")
+        ]
+        super().__init__(placeholder="Escolhe o tipo de stack", options=options)
+
+    async def callback(self, interaction: discord.Interaction):
+        escolha = self.values[0]
+        forum_channel = discord.utils.get(interaction.guild.channels, name="lfg", type=discord.ChannelType.forum)
+        if not forum_channel:
+            await interaction.response.send_message("❌ Canal de fórum 'lfg' não encontrado ou não é do tipo fórum.", ephemeral=True)
+            return
+        thread = await forum_channel.create_thread(name=escolha, content=escolha)
+        await interaction.message.delete()
+        await interaction.response.defer()
+
+class StackView(View):
+    def __init__(self, grupo):
+        super().__init__()
+        self.grupo = grupo
+        self.add_item(StackDropdown(grupo))
+        
+
+@bot.command(name="bot")
+async def bot_command(ctx):
+    grupo_temporario = GrupoDungeon()
+    await ctx.send(view=StackView(grupo_temporario))
+    
+    membro = discord.utils.get(ctx.guild.members, name="carlitosqt")
+    if membro:
+        await ctx.send(f"Parabéns {membro.mention}!")
+
+CLASSES_POR_ROLE = {
+    "Tank": [
+        ("Paladin",    "https://wow.zamimg.com/images/wow/icons/large/spell_holy_avengershield.jpg"),
+        ("Warrior",    "https://wow.zamimg.com/images/wow/icons/large/spell_warrior_protetion_spec.jpg"),
+        ("Death Knight",    "https://wow.zamimg.com/images/wow/icons/large/spell_deathknight_bloodpresence.jpg"),
+        ("Demon Hunter","https://wow.zamimg.com/images/wow/icons/large/ability_demonhunter_specdps.jpg"),
+        ("Monk",       "https://wow.zamimg.com/images/wow/icons/large/spell_monk_brewmaster_spec.jpg"),
+        ("Druid",        "https://wow.zamimg.com/images/wow/icons/large/ability_racial_bearform.jpg")
+    ],
+    "Healer": [
+        ("Priest",     "https://wow.zamimg.com/images/wow/icons/large/spell_holy_powerwordshield.jpg"),
+        ("Shaman",    "https://wow.zamimg.com/images/wow/icons/large/spell_nature_magicimmunity.jpg"),
+        ("Monk",       "https://wow.zamimg.com/images/wow/icons/large/spell_monk_mistweaver_spec.jpg"),
+        ("Druid",     "https://wow.zamimg.com/images/wow/icons/large/spell_nature_healingtouch.jpg"),
+        ("Paladin",          "https://wow.zamimg.com/images/wow/icons/large/spell_holy_holybolt.jpg"),
+        ("Evoker",   "https://wow.zamimg.com/images/wow/icons/large/spell_spec_evoker_preservation.jpg")
+    ],
+    "DPS": [
+        ("Mage",           "https://wow.zamimg.com/images/wow/icons/large/spell_holy_magicalsentry.jpg"),
+        ("Druid",         "https://wow.zamimg.com/images/wow/icons/large/spell_nature_starfall.jpg"),
+        ("Paladin",   "https://wow.zamimg.com/images/wow/icons/large/spell_holy_auraoflight.jpg"),
+        ("Shaman",      "https://wow.zamimg.com/images/wow/icons/large/spell_nature_lightning.jpg"),
+        ("Hunter",  "https://wow.zamimg.com/images/wow/icons/large/ability_hunter_bestialdiscipline.jpg"),
+        ("Rogue",   "https://wow.zamimg.com/images/wow/icons/large/ability_rogue_deadlybrew.jpg"),
+        ("Demon Hunter","https://wow.zamimg.com/images/wow/icons/large/ability_demonhunter_specdps.jpg"),
+        ("Priest",         "https://wow.zamimg.com/images/wow/icons/large/spell_shadow_shadowwordpain.jpg"),
+        ("Death Knight",    "https://wow.zamimg.com/images/wow/icons/large/spell_deathknight_frostpresence.png"),
+        ("Monk",       "https://wow.zamimg.com/images/wow/icons/large/spell_monk_windwalkerspec.jpg"),
+        ("Warrior",          "https://wow.zamimg.com/images/wow/icons/large/ability_warrior_innerrage.jpg"),
+        ("Warlock",    "https://wow.zamimg.com/images/wow/icons/large/spell_shadow_deathcoil.jpg"),
+        ("Evoker",    "https://wow.zamimg.com/images/wow/icons/large/spell_spec_evoker_devastation.jpg")
+    ]
+}
+
+class GrupoDungeon:
+    def __init__(self):
+        self.inscritos = {"Tank": [], "Healer": [], "DPS": []}
+        self.classes_escolhidas = {}
+        self.dungeon_escolhida = DUNGEONS[2]
+        self.dificuldade_escolhida = "10"
+        self.data_formatada = "06/08/2025"
+        self.hora_escolhida = "22:00"
+        self.alteracoes_feitas = {"dungeon": False, "dificuldade": False, "data": False}
+        self.jogador_em_progresso = None
+        self.mensagem_id = None
+        self.canal_id = None
+        self.thread = None
+
+    def format_grupo_embed(self):
+        def format_role(role):
+            players = self.inscritos[role]
+            if not players:
+                return "None"
+            return "\n".join(f"{p} ({self.classes_escolhidas.get(p, 'sem classe')})" for p in players)
+
+        embed = discord.Embed(
+            title=f"Dungeon: {self.dungeon_escolhida}",
+            description=(
+                f"Dificuldade: {self.dificuldade_escolhida}\n"
+                f"Marcação: {self.data_formatada} às {self.hora_escolhida}"
+            ),
+            color=0x00ffcc
+        )
+        embed.add_field(name=f"{EMOJI_TANK} Tank", value=format_role("Tank"), inline=False)
+        embed.add_field(name=f"{EMOJI_HEALER} Healer", value=format_role("Healer"), inline=False)
+        embed.add_field(name=f"{EMOJI_DPS} DPS", value=format_role("DPS"), inline=False)
+        embed.set_footer(text="Bot created by Kl3z")
+        return embed
+
+grupos_ativos = {}
+
+class DungeonDropdown(Select):
+    def __init__(self, grupo: GrupoDungeon):
+        self.grupo = grupo
+        options = [discord.SelectOption(label=d, value=d) for d in DUNGEONS]
+        super().__init__(placeholder="Escolhe a dungeon", min_values=1, max_values=1, options=options)
+
+    async def callback(self, interaction: discord.Interaction):
+        if self.grupo.alteracoes_feitas["dungeon"]:
+            await interaction.response.send_message("❌ A dungeon já foi escolhida e não pode ser alterada novamente.", ephemeral=True)
+            return
+        
+        self.grupo.dungeon_escolhida = self.values[0]
+        self.grupo.alteracoes_feitas["dungeon"] = True
+
+        canal = bot.get_channel(self.grupo.canal_id)
+        mensagem = await canal.fetch_message(self.grupo.mensagem_id)
+        
+        nova_view = DungeonView(self.grupo)
+        if all(self.grupo.alteracoes_feitas.values()):
+            nova_view.clear_items()
+        
+        await mensagem.edit(embed=self.grupo.format_grupo_embed(), view=nova_view)
+        
+        if self.grupo.thread:
+            await self.grupo.thread.edit(name=f"{self.grupo.dungeon_escolhida} - Key {self.grupo.dificuldade_escolhida}")
+        
+        await interaction.response.defer()
+
+class DificuldadeDropdown(Select):
+    def __init__(self, grupo):
+        self.grupo = grupo
+        options = [discord.SelectOption(label=f"Chave {d}", value=d) for d in DIFICULDADES]
+        super().__init__(placeholder="Escolhe a dificuldade", min_values=1, max_values=1, options=options)
+
+    async def callback(self, interaction: discord.Interaction):
+        if self.grupo.alteracoes_feitas["dificuldade"]:
+            await interaction.response.send_message("❌ A dificuldade já foi definida e não pode ser alterada novamente.", ephemeral=True)
+            return
+        
+        self.grupo.dificuldade_escolhida = self.values[0]
+        self.grupo.alteracoes_feitas["dificuldade"] = True
+
+        canal = bot.get_channel(self.grupo.canal_id)
+        mensagem = await canal.fetch_message(self.grupo.mensagem_id)
+        nova_view = DungeonView(self.grupo)
+        if all(self.grupo.alteracoes_feitas.values()):
+            nova_view.clear_items()
+        
+        await mensagem.edit(embed=self.grupo.format_grupo_embed(), view=nova_view)
+        
+        if self.grupo.thread:
+            await self.grupo.thread.edit(name=f"{self.grupo.dungeon_escolhida} - Key {self.grupo.dificuldade_escolhida}")
+        
+        await interaction.response.defer()
+
+class DataModal(Modal, title="Definir Data da Dungeon"):
+    def __init__(self, grupo):
+        super().__init__()
+        self.grupo = grupo
+        self.dia = TextInput(label="Dia do mês (1-31)", placeholder="Ex: 6", max_length=2)
+        self.hora = TextInput(label="Hora (HH:MM)", placeholder="Ex: 22:30", max_length=5)
+        self.add_item(self.dia)
+        self.add_item(self.hora)
+
+    async def on_submit(self, interaction: discord.Interaction):
+        if self.grupo.alteracoes_feitas["data"]:
+            await interaction.response.send_message("❌ A data e hora já foram definidas e não podem ser alteradas novamente.", ephemeral=True)
+            return
+        try:
+            dia_num = int(self.dia.value)
+            if not 1 <= dia_num <= 31:
+                raise ValueError("Dia fora do intervalo")
+            hora_val = datetime.strptime(self.hora.value, "%H:%M").strftime("%H:%M")
+
+            hoje = datetime.now()
+            mes = hoje.month
+            ano = hoje.year
+            if dia_num < hoje.day:
+                mes += 1
+                if mes > 12:
+                    mes = 1
+                    ano += 1
+            data_completa = datetime(year=ano, month=mes, day=dia_num)
+
+            self.grupo.data_formatada = data_completa.strftime("%d/%m/%Y")
+            self.grupo.hora_escolhida = hora_val
+            self.grupo.alteracoes_feitas["data"] = True
+
+            canal = bot.get_channel(self.grupo.canal_id)
+            mensagem = await canal.fetch_message(self.grupo.mensagem_id)
+            nova_view = DungeonView(self.grupo)
+            if all(self.grupo.alteracoes_feitas.values()):
+                nova_view.clear_items()
+            await mensagem.edit(embed=self.grupo.format_grupo_embed(), view=nova_view)
+            await interaction.response.defer()
+
+        except Exception:
+            await interaction.response.send_message("❌ Data ou hora inválida.", ephemeral=True)
+
+class BotaoData(Button):
+    def __init__(self, grupo):
+        super().__init__(label="🗓️ Definir Data", style=discord.ButtonStyle.primary)
+        self.grupo = grupo
+
+    async def callback(self, interaction: discord.Interaction):
+        await interaction.response.send_modal(DataModal(self.grupo))
+
+class DungeonView(View):
+    def __init__(self, grupo):
+        super().__init__(timeout=None)
+        self.grupo = grupo
+        if not self.grupo.alteracoes_feitas["dungeon"]:
+            self.add_item(DungeonDropdown(self.grupo))
+        if not self.grupo.alteracoes_feitas["dificuldade"]:
+            self.add_item(DificuldadeDropdown(self.grupo))
+        if not self.grupo.alteracoes_feitas["data"]:
+            self.add_item(BotaoData(self.grupo))
+
+class RoleDropdown(Select):
+    def __init__(self, jogador, ctx_channel_id, role_msg_id, grupo):
+        self.jogador = jogador
+        self.ctx_channel_id = ctx_channel_id
+        self.role_msg_id = role_msg_id
+        self.grupo = grupo
+        options = []
+        for role in LIMITES:
+            if len(self.grupo.inscritos[role]) < LIMITES[role]:
+                options.append(discord.SelectOption(label=role, description="Escolher esta role"))
+
+        placeholder = "Escolhe a tua role" if options else "Todas as roles preenchidas"
+        super().__init__(placeholder=placeholder, options=options, disabled=(len(options) == 0))
+
+    async def callback(self, interaction: discord.Interaction):
+        if self.grupo.jogador_em_progresso and self.grupo.jogador_em_progresso != interaction.user.display_name:
+            await interaction.response.send_message(
+                f"⏳ Aguarda que {self.grupo.jogador_em_progresso} termine a escolha da classe.",
+                ephemeral=True
+            )
+            return
+            
+        self.grupo.jogador_em_progresso = interaction.user.display_name
+        role = self.values[0]
+        
+        # Remover jogador de qualquer role anterior
+        for r in self.grupo.inscritos:
+            if interaction.user.display_name in self.grupo.inscritos[r]:
+                self.grupo.inscritos[r].remove(interaction.user.display_name)
+        
+        if interaction.user.display_name not in self.grupo.inscritos[role] and len(self.grupo.inscritos[role]) < LIMITES[role]:
+            self.grupo.inscritos[role].append(interaction.user.display_name)
+            canal = bot.get_channel(self.ctx_channel_id)
+            
+            if isinstance(canal, discord.Thread):
+                await canal.join()
+            
+            await interaction.message.delete()
+            
+            # Usar self.grupo.mensagem_id em vez da variável global
+            mensagem = await canal.fetch_message(self.grupo.mensagem_id)
+            await mensagem.edit(embed=self.grupo.format_grupo_embed())
+            
+            await canal.send(
+                f"{interaction.user.display_name}, agora escolhe a tua classe para **{role}**:",
+                view=ClasseView(role, interaction.user.display_name, self.ctx_channel_id, self.grupo)
+            )
+            
+            await interaction.response.defer()
+        else:
+            self.grupo.jogador_em_progresso = None
+            await interaction.response.send_message("❌ Esta role já está cheia ou ocorreu um erro.", ephemeral=True)
+
+class ClasseDropdown(Select):
+    def __init__(self, role, jogador, grupo):
+        self.jogador = jogador
+        self.role = role
+        self.grupo = grupo
+        options = [discord.SelectOption(label=nome, value=nome) for nome, _ in CLASSES_POR_ROLE[role]]
+        super().__init__(placeholder=f"Escolhe a classe ({role})", options=options)
+
+    async def callback(self, interaction: discord.Interaction):
+        self.grupo.classes_escolhidas[self.jogador] = self.values[0]
+        canal = interaction.channel
+        
+        # Usar self.grupo.mensagem_id em vez da variável global
+        mensagem = await canal.fetch_message(self.grupo.mensagem_id)
+        await mensagem.edit(embed=self.grupo.format_grupo_embed())
+        
+        await interaction.message.delete()
+        self.grupo.jogador_em_progresso = None
+        
+        if any(len(self.grupo.inscritos[r]) < LIMITES[r] for r in LIMITES):
+            await canal.send(
+                "Escolher a tua **Role**:",
+                view=RoleView(interaction.user.display_name, canal.id, self.grupo.mensagem_id, self.grupo)
+            )
+        
+        await interaction.response.defer()
+
+class ClasseView(View):
+    def __init__(self, role, jogador, ctx_channel_id, grupo):
+        super().__init__(timeout=None)
+        self.grupo = grupo
+        self.add_item(ClasseDropdown(role, jogador, grupo))
+
+import asyncio
+
+async def agendar_remocao_thread(thread: discord.Thread, data_str: str, hora_str: str):
+    try:
+        alvo = datetime.strptime(f"{data_str} {hora_str}", "%d/%m/%Y %H:%M")
+        agora = datetime.now()
+        segundos_ate_apagar = (alvo + timedelta(minutes=30) - agora).total_seconds()
+
+        if segundos_ate_apagar > 0:
+            await asyncio.sleep(segundos_ate_apagar)
+            await thread.delete()
+            print(f"[INFO] Thread '{thread.name}' apagada automaticamente após 30 minutos.")
+        else:
+            print(f"[INFO] Tempo já passou, thread '{thread.name}' não foi agendada.")
+    except Exception as e:
+        print(f"[ERRO] ao agendar remoção: {e}")
+
+@bot.command(name="criargrupo")
+async def criar_grupo(ctx):
+    # Verificar se o comando foi usado em um local válido
+    if not (isinstance(ctx.channel, discord.ForumChannel) or 
+            (isinstance(ctx.channel, discord.Thread) and 
+             isinstance(ctx.channel.parent, discord.ForumChannel))):
+        await ctx.send("❌ Este comando só pode ser usado em um canal de fórum ou em posts de fórum!", ephemeral=True)
+        return
+    
+    # Determinar o canal de fórum principal
+    forum_channel = ctx.channel if isinstance(ctx.channel, discord.ForumChannel) else ctx.channel.parent
+    
+    # Criar novo grupo
+    novo_grupo = GrupoDungeon()
+    
+    try:
+        # Criar novo post no fórum com tags apropriadas
+        tags = []
+        dungeon_tag = discord.utils.get(forum_channel.available_tags, name=novo_grupo.dungeon_escolhida)
+        if dungeon_tag:
+            tags.append(dungeon_tag)
+        
+        # Criar o post no fórum
+        thread, message = await forum_channel.create_thread(
+            name=f"{novo_grupo.dungeon_escolhida} - Key {novo_grupo.dificuldade_escolhida}",
+            content=f"Dungeon group created by {ctx.author.mention}",
+            embed=novo_grupo.format_grupo_embed(),
+            view=DungeonView(novo_grupo),
+            applied_tags=tags
+        )
+        
+        # Configurar o grupo
+        novo_grupo.thread = thread
+        novo_grupo.canal_id = thread.id
+        novo_grupo.mensagem_id = message.id
+        grupos_ativos[message.id] = novo_grupo
+        
+        # Enviar mensagem para escolher role
+        await thread.send(
+            f"{ctx.author.mention}, escolhe a tua **Role**:",
+            view=RoleView(ctx.author.display_name, thread.id, message.id, novo_grupo)
+        )
+        
+        # Agendar remoção automática
+        asyncio.create_task(
+            agendar_remocao_thread(
+                thread, 
+                novo_grupo.data_formatada, 
+                novo_grupo.hora_escolhida
+            )
+        )
+        
+        # Confirmar criação
+        if ctx.channel.id != thread.id:  # Só responde se não estiver já na thread criada
+            await ctx.send(f"✅ Grupo criado com sucesso! {thread.mention}", ephemeral=True)
+            
+    except discord.HTTPException as e:
+        await ctx.send("❌ Erro ao criar post no fórum. Verifique as permissões do bot.", ephemeral=True)
+        print(f"Erro HTTP ao criar post: {e}")
+    except Exception as e:
+        await ctx.send("❌ Ocorreu um erro inesperado ao criar o grupo.", ephemeral=True)
+        print(f"Erro ao criar grupo: {e}")
+        if 'thread' in locals() and thread:  # Limpeza em caso de erro
+            await thread.delete()
+
+class RoleView(View):
+    def __init__(self, jogador, ctx_channel_id, role_msg_id, grupo):
+        super().__init__(timeout=None)
+        self.grupo = grupo
+        self.add_item(RoleDropdown(jogador, ctx_channel_id, role_msg_id, grupo))
+
+
+@bot.event
+async def on_ready():
+    print(f"Bot ligado como {bot.user}")
+
+bot.run(os.getenv("DISCORD_TOKEN"))
+
+

backup/WIPBOT.py

@@ -5,6 +5,7 @@ from datetime import datetime, timedelta
 import os
 from dotenv import load_dotenv
 load_dotenv()
+jogador_em_progresso = None
 intents = discord.Intents.default()
 intents.message_content = True
 intents.reactions = True
@@ -34,6 +35,7 @@ dificuldade_escolhida = "10"
 data_formatada = "06/08/2025"
 hora_escolhida = "22:00"
 alteracoes_feitas = {"dungeon": False, "dificuldade": False, "data": False}
+
 def format_grupo_embed():
     def format_role(role):
         players = inscritos[role]
@@ -54,9 +56,61 @@ def format_grupo_embed():
     embed.add_field(name=f"{EMOJI_DPS} DPS", value=format_role("DPS"), inline=False)
     embed.set_footer(text="Bot created by Kl3z")
     return embed
+
+async def criar_grupo_customizado(canal):
+    global grupo_mensagem_id, inscritos, dungeon_escolhida, dificuldade_escolhida, data_formatada, hora_escolhida, alteracoes_feitas
+    inscritos = {"Tank": [], "Healer": [], "DPS": []}
+    classes_escolhidas.clear()
+    dungeon_escolhida = DUNGEONS[2]
+    dificuldade_escolhida = "10"
+    data_formatada = "06/08/2025"
+    hora_escolhida = "22:00"
+    alteracoes_feitas = {"dungeon": False, "dificuldade": False, "data": False}
+    embed = format_grupo_embed()
+    mensagem = await canal.send(embed=embed, view=DungeonView())
+    grupo_mensagem_id = mensagem.id
+    await canal.send(
+        "Escolher a tua **Role**:",
+        view=RoleView("Novo jogador", canal.id, grupo_mensagem_id)
+    )
+class StackDropdown(Select):
+    def __init__(self):
+        options = [
+            discord.SelectOption(label="Plate Stack"),
+            discord.SelectOption(label="Leather Stack"),
+            discord.SelectOption(label="Mail Stack"),
+            discord.SelectOption(label="Cloth Stack")
+        ]
+        super().__init__(placeholder="Escolhe o tipo de stack", options=options)
+    async def callback(self, interaction: discord.Interaction):
+        escolha = self.values[0]
+        forum_channel = discord.utils.get(interaction.guild.channels, name="lfg", type=discord.ChannelType.forum)
+        if not forum_channel:
+            await interaction.response.send_message("❌ Canal de fórum 'lfg' não encontrado ou não é do tipo fórum.", ephemeral=True)
+            return
+        thread = await forum_channel.create_thread(name=escolha, content=escolha)
+        await interaction.message.delete()
+        await interaction.response.defer()
+        
+
+@bot.command(name="bot")
+async def bot_command(ctx):
+    await ctx.send(view=StackView())
+    membro = discord.utils.get(ctx.guild.members, name="carlitosqt")
+    if membro:
+        await ctx.send(f"Parabéns {membro.mention}!")
+    #else:
+        #await ctx.send("Não encontrei o membro chamado Rixa.")
+
+class StackView(View):
+    def __init__(self):
+        super().__init__()
+        self.add_item(StackDropdown())
+
 CLASSES_POR_ROLE = {
     "Tank": [
         ("Protection Paladin",    "https://wow.zamimg.com/images/wow/icons/large/spell_holy_avengershield.jpg"),
+        ("Protection Warrior",    "https://wow.zamimg.com/images/wow/icons/large/spell_warrior_protetion_spec.jpg"),
         ("Blood Death Knight",    "https://wow.zamimg.com/images/wow/icons/large/spell_deathknight_bloodpresence.jpg"),
         ("Vengeance Demon Hunter","https://wow.zamimg.com/images/wow/icons/large/ability_demonhunter_specdps.jpg"),
         ("Brewmaster Monk",       "https://wow.zamimg.com/images/wow/icons/large/spell_monk_brewmaster_spec.jpg"),
@@ -96,23 +150,6 @@ CLASSES_POR_ROLE = {
         ("Frost Mage",            "https://wow.zamimg.com/images/wow/icons/large/spell_frost_frostbolt02.jpg")
     ]
 }
-
-class ClasseDropdown(Select):
-    def __init__(self, role, jogador):
-        self.jogador = jogador
-        options = [discord.SelectOption(label=nome, value=nome, description="", emoji=None) for nome, _ in CLASSES_POR_ROLE[role]]
-        super().__init__(placeholder=f"Escolhe a classe ({role})", min_values=1, max_values=1, options=options)
-
-    async def callback(self, interaction: discord.Interaction):
-        classes_escolhidas[self.jogador] = self.values[0]
-        mensagem = await interaction.channel.fetch_message(grupo_mensagem_id)
-        await mensagem.edit(embed=format_grupo_embed())
-        await interaction.response.send_message(f"Classe escolhida: **{self.values[0]}**", ephemeral=True)
-
-class ClasseView(View):
-    def __init__(self, role, jogador):
-        super().__init__(timeout=60)
-        self.add_item(ClasseDropdown(role, jogador))
 class DungeonDropdown(Select):
     def __init__(self):
         options = [discord.SelectOption(label=d, value=d) for d in DUNGEONS]
@@ -130,8 +167,12 @@ class DungeonDropdown(Select):
         nova_view = DungeonView()
         if all(alteracoes_feitas.values()):
             nova_view.clear_items()
+        
         await mensagem.edit(embed=format_grupo_embed(), view=nova_view)
-        await interaction.response.send_message(f"Dungeon atualizada para **{dungeon_escolhida}**", ephemeral=True)
+        if isinstance(interaction.channel, discord.Thread):
+            await interaction.channel.edit(name=f"{dungeon_escolhida} - Key {dificuldade_escolhida}")
+        
+        await interaction.response.defer()
 
 class DificuldadeDropdown(Select):
     def __init__(self):
@@ -145,13 +186,16 @@ class DificuldadeDropdown(Select):
             return
         dificuldade_escolhida = self.values[0]
         alteracoes_feitas["dificuldade"] = True
-
         mensagem = await interaction.channel.fetch_message(grupo_mensagem_id)
         nova_view = DungeonView()
         if all(alteracoes_feitas.values()):
             nova_view.clear_items()
         await mensagem.edit(embed=format_grupo_embed(), view=nova_view)
-        await interaction.response.send_message(f"Dificuldade atualizada para **+{dificuldade_escolhida}**", ephemeral=True)
+        if isinstance(interaction.channel, discord.Thread):
+            await interaction.channel.edit(name=f"{dungeon_escolhida} - Key {dificuldade_escolhida}")
+        
+        await interaction.response.defer()
+
 class DataModal(Modal, title="Definir Data da Dungeon"):
     dia = TextInput(label="Dia do mês (1-31)", placeholder="Ex: 6", max_length=2)
     hora = TextInput(label="Hora (HH:MM)", placeholder="Ex: 22:30", max_length=5)
@@ -190,7 +234,7 @@ class DataModal(Modal, title="Definir Data da Dungeon"):
         if all(alteracoes_feitas.values()):
             nova_view.clear_items()
         await mensagem.edit(embed=format_grupo_embed(), view=nova_view)
-        await interaction.response.send_message(f"Data agendada: **{data_formatada} às {hora_escolhida}**", ephemeral=True)
+        await interaction.response.defer()
 
 class BotaoData(Button):
     def __init__(self):
@@ -208,6 +252,93 @@ class DungeonView(View):
             self.add_item(DificuldadeDropdown())
         if not alteracoes_feitas["data"]:
             self.add_item(BotaoData())
+class RoleDropdown(Select):
+    def __init__(self, jogador, ctx_channel_id, role_msg_id):
+        self.jogador = jogador
+        self.ctx_channel_id = ctx_channel_id
+        self.role_msg_id = role_msg_id
+        options = []
+        for role in LIMITES:
+            if len(inscritos[role]) < LIMITES[role]:
+                options.append(discord.SelectOption(label=role, description="Escolher esta role"))
+
+        placeholder = "Escolhe a tua role" if options else "Todas as roles preenchidas"
+        super().__init__(placeholder=placeholder, options=options, disabled=(len(options) == 0))
+
+    async def callback(self, interaction: discord.Interaction):
+        global jogador_em_progresso
+        jogador = interaction.user.display_name
+        if jogador_em_progresso and jogador_em_progresso != jogador:
+            await interaction.response.send_message(
+                f"⏳ Aguarda que {jogador_em_progresso} termine a escolha da classe.",
+                ephemeral=True
+            )
+            return
+        jogador_em_progresso = jogador
+        role = self.values[0]
+        for r in inscritos:
+            if jogador in inscritos[r]:
+                inscritos[r].remove(jogador)
+        if jogador not in inscritos[role] and len(inscritos[role]) < LIMITES[role]:
+            inscritos[role].append(jogador)
+            canal = bot.get_channel(self.ctx_channel_id)
+            if isinstance(canal, discord.Thread):
+                await canal.join()
+            await interaction.message.delete()
+            mensagem = await canal.fetch_message(grupo_mensagem_id)
+            await mensagem.edit(embed=format_grupo_embed())
+            await canal.send(
+                f"{jogador}, agora escolhe a tua classe para **{role}**:",
+                view=ClasseView(role, jogador, self.ctx_channel_id)
+            )
+            await interaction.response.defer()
+        else:
+            jogador_em_progresso = None
+            await interaction.response.send_message("❌ Esta role já está cheia ou ocorreu um erro.", ephemeral=True)
+
+class ClasseDropdown(Select):
+    def __init__(self, role, jogador):
+        self.jogador = jogador
+        options = [discord.SelectOption(label=nome, value=nome) for nome, _ in CLASSES_POR_ROLE[role]]
+        super().__init__(placeholder=f"Escolhe a classe ({role})", options=options)
+    async def callback(self, interaction: discord.Interaction):
+        global jogador_em_progresso
+        classes_escolhidas[self.jogador] = self.values[0]
+        canal = interaction.channel
+        mensagem = await canal.fetch_message(grupo_mensagem_id)
+        await mensagem.edit(embed=format_grupo_embed())
+        await interaction.message.delete()
+        jogador_em_progresso = None
+        if any(len(inscritos[r]) < LIMITES[r] for r in LIMITES):
+            await canal.send(
+                "Escolher a tua **Role**:",
+                view=RoleView(interaction.user.display_name, canal.id, grupo_mensagem_id)
+            )
+        await interaction.response.defer()
+
+class ClasseView(View):
+    def __init__(self, role, jogador, ctx_channel_id):
+        super().__init__()
+        dropdown = ClasseDropdown(role, jogador)
+        dropdown.ctx_channel_id = ctx_channel_id
+        self.add_item(dropdown)
+
+import asyncio
+
+async def agendar_remocao_thread(thread: discord.Thread, data_str: str, hora_str: str):
+    try:
+        alvo = datetime.strptime(f"{data_str} {hora_str}", "%d/%m/%Y %H:%M")
+        agora = datetime.now()
+        segundos_ate_apagar = (alvo + timedelta(minutes=30) - agora).total_seconds()
+
+        if segundos_ate_apagar > 0:
+            await asyncio.sleep(segundos_ate_apagar)
+            await thread.delete()
+            print(f"[INFO] Thread '{thread.name}' apagada automaticamente após 30 minutos.")
+        else:
+            print(f"[INFO] Tempo já passou, thread '{thread.name}' não foi agendada.")
+    except Exception as e:
+        print(f"[ERRO] ao agendar remoção: {e}")
 
 @bot.command(name="criargrupo")
 async def criar_grupo(ctx):
@@ -223,81 +354,26 @@ async def criar_grupo(ctx):
     embed = format_grupo_embed()
     mensagem = await ctx.send(embed=embed, view=DungeonView())
     grupo_mensagem_id = mensagem.id
-    await mensagem.add_reaction(EMOJI_TANK)
-    await mensagem.add_reaction(EMOJI_HEALER)
-    await mensagem.add_reaction(EMOJI_DPS)
 
-@bot.event
+    if isinstance(ctx.channel, discord.Thread):
-async def on_raw_reaction_add(payload):
+        asyncio.create_task(agendar_remocao_thread(ctx.channel, data_formatada, hora_escolhida))
-    if payload.message_id != grupo_mensagem_id or payload.user_id == bot.user.id:
+
-        return
+    role_msg = await ctx.send(
-    guild = bot.get_guild(payload.guild_id)
+    "Escolher a tua **Role**:",
-    member = guild.get_member(payload.user_id)
+    view=RoleView(ctx.author.display_name, ctx.channel.id, grupo_mensagem_id)
-    if member is None:
+    )
-        member = await guild.fetch_member(payload.user_id)
+
-    nome = member.display_name
+
-    emoji = str(payload.emoji)
+class RoleView(View):
-    role = None
+    def __init__(self, jogador, ctx_channel_id, role_msg_id):
-    if emoji == EMOJI_TANK:
+        super().__init__(timeout=None)
-        role = "Tank"
+        self.add_item(RoleDropdown(jogador, ctx_channel_id, role_msg_id))
-    elif emoji == EMOJI_HEALER:
-        role = "Healer"
-    elif emoji == EMOJI_DPS:
-        role = "DPS"
-    if role:
-        if len(inscritos[role]) >= LIMITES[role] and nome not in inscritos[role]:
-            channel = bot.get_channel(payload.channel_id)
-            mensagem = await channel.fetch_message(payload.message_id)
-            await mensagem.remove_reaction(emoji, member)
-            return
-        for r in inscritos:
-            if nome in inscritos[r]:
-                inscritos[r].remove(nome)
-        inscritos[role].append(nome)
-        channel = bot.get_channel(payload.channel_id)
-        mensagem = await channel.fetch_message(payload.message_id)
-        await mensagem.edit(embed=format_grupo_embed())
-        if role in CLASSES_POR_ROLE:
-            await channel.send(f"{member.mention}, escolhe a tua classe:", view=ClasseView(role, nome))
 
-@bot.event
-async def on_raw_reaction_remove(payload):
-    if payload.message_id != grupo_mensagem_id or payload.user_id == bot.user.id:
-        return
-    guild = bot.get_guild(payload.guild_id)
-    member = guild.get_member(payload.user_id)
-    if member is None:
-        member = await guild.fetch_member(payload.user_id)
-    nome = member.display_name
-    emoji = str(payload.emoji)
-    role = None
-    if emoji == EMOJI_TANK:
-        role = "Tank"
-    elif emoji == EMOJI_HEALER:
-        role = "Healer"
-    elif emoji == EMOJI_DPS:
-        role = "DPS"
-    if role and nome in inscritos[role]:
-        inscritos[role].remove(nome)
-        classes_escolhidas.pop(nome, None)
-        channel = bot.get_channel(payload.channel_id)
-        mensagem = await channel.fetch_message(payload.message_id)
-        await mensagem.edit(embed=format_grupo_embed())
-        if role in CLASSES_POR_ROLE:
-            await channel.send(f"{member.mention}, escolhe a tua classe:", view=ClasseView(role, nome))
-<<<<<<< HEAD
-        if (len(inscritos["Tank"]) == LIMITES["Tank"] and len(inscritos["Healer"]) == LIMITES["Healer"] and len(inscritos["DPS"]) == LIMITES["DPS"]):
-=======
-        if (
-            len(inscritos["Tank"]) == LIMITES["Tank"] and
-            len(inscritos["Healer"]) == LIMITES["Healer"] and
-            len(inscritos["DPS"]) == LIMITES["DPS"]
-        ):
->>>>>>> 8839ffd (first commit of Discord bot)
-            await channel.send("🎉 Dungeon Encerrada! Parabéns <@Rixa>, felicidades 🎉")
 
 @bot.event
 async def on_ready():
     print(f"Bot ligado como {bot.user}")
 
 bot.run(os.getenv("DISCORD_TOKEN"))
+
+

railway.json

@@ -1,3 +1,4 @@
+<<<<<<< HEAD
 {
   "build": {
     "builder": "NIXPACKS"
@@ -6,3 +7,13 @@
     "startCommand": "python3 WIPBOT.py"
   }
 }
+=======
+{
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "python3 WIPBOT.py"
+  }
+}
+>>>>>>> 462e052 (Salvando alterações locais antes de rebase)