S
📎 1 file 5,596 chars
📄
pasted-code-1787796969401.txt
txt 269 lines
▶
Crea un bot de Discord profesional y completamente funcional desde cero.

Quiero que el bot tenga una arquitectura limpia, modular y fácil de modificar. Usa una tecnología estable para Discord y asegúrate de que TODO el código funcione realmente, sin funciones falsas, botones que no hagan nada ni comandos incompletos.

### OBJETIVO PRINCIPAL

Quiero un bot estilo bot premium para administrar una comunidad de Discord. Debe tener un sistema moderno de comandos, botones, menús desplegables, embeds y configuración por servidor.

### FUNCIONES

#### MODERACIÓN

* /ban
* /unban
* /kick
* /timeout
* /untimeout
* /warn
* /warnings
* /clear
* /slowmode
* /lock
* /unlock
* Sistema automático anti-spam
* Anti-link configurable
* Anti-raid
* Registro de acciones de moderación

#### TICKETS

Crear un sistema completo de tickets.

* Panel de tickets mediante embed
* Botones para abrir ticket
* Categorías configurables
* Crear canales automáticamente
* Permisos privados para staff y usuario
* Botón de cerrar ticket
* Confirmación antes de cerrar
* Transcripción del ticket
* Guardar logs de tickets
* Sistema de reclamación de tickets
* Diferentes tipos de tickets

#### VERIFICACIÓN

Crear un sistema de verificación mediante botón.

* Panel de verificación
* Botón "Verificar"
* Asignación automática de rol
* Mensaje configurable
* Protección contra usuarios no verificados

#### BIENVENIDA

Cuando entre un usuario:

* Enviar mensaje de bienvenida
* Embed personalizable
* Mostrar nombre del usuario
* Mostrar avatar
* Asignar rol automáticamente
* Canal configurable

Cuando salga un usuario:

* Mensaje de despedida
* Canal configurable

#### SISTEMA DE NIVELES

Crear un sistema XP.

* XP por mensajes
* Niveles
* Leaderboard
* Recompensas por nivel
* Cooldown anti-farm
* /rank
* /leaderboard
* /level
* Configuración de XP

#### ECONOMÍA

Crear un sistema de economía.

* /balance
* /daily
* /work
* /pay
* /deposit
* /withdraw
* Tienda
* Inventario
* Monedas configurables
* Base de datos persistente

#### INFORMACIÓN

* /server
* /user
* /avatar
* /banner
* /role
* /channel
* /botinfo
* /ping
* /help

#### CONFIGURACIÓN

Crear un comando:

/setup

Debe abrir un sistema interactivo con botones y menús para configurar:

* Canal de bienvenida
* Canal de despedida
* Canal de logs
* Canal de tickets
* Categoría de tickets
* Rol de staff
* Rol de verificación
* Rol automático
* Sistema anti-links
* Sistema anti-spam
* Sistema de niveles
* Sistema de economía

Toda la configuración debe guardarse en una base de datos.

### PANEL DE CONFIGURACIÓN

Crear un dashboard web moderno para administrar el bot.

El dashboard debe permitir:

* Login con Discord OAuth2
* Ver servidores donde el usuario tiene permisos
* Seleccionar servidor
* Configurar todas las funciones
* Activar/desactivar módulos
* Cambiar colores de embeds
* Cambiar mensajes
* Seleccionar canales
* Seleccionar roles
* Ver estadísticas
* Ver logs

### DISEÑO

Quiero una interfaz moderna y profesional.

Estilo:

* Dark mode
* Diseño premium
* Animaciones suaves
* Tarjetas modernas
* Botones elegantes
* Responsive para PC y móvil
* Dashboard con sidebar
* Iconos
* Buena separación entre secciones

### BASE DE DATOS

Usa una base de datos persistente.

No guardes configuraciones importantes únicamente en archivos JSON si existe una alternativa mejor.

Cada servidor debe tener su propia configuración.

### SEGURIDAD

* Nunca mostrar tokens en el frontend
* Usar variables de entorno
* Crear archivo .env.example
* Validar permisos de Discord
* Comprobar permisos antes de ejecutar comandos
* Manejar errores correctamente
* Evitar crashes
* Evitar duplicación de eventos
* Implementar rate limits cuando sea necesario
* No exponer información sensible

### MANEJO DE ERRORES

Todo comando debe tener manejo de errores.

Si ocurre un error:

* No debe caerse el bot
* Mostrar un mensaje amigable al usuario
* Registrar el error en consola/logs
* Mantener funcionando el resto del bot

### ESTRUCTURA

Organiza el proyecto profesionalmente.

Ejemplo:

src/
commands/
events/
buttons/
modals/
selectMenus/
database/
utils/
config/
dashboard/

Incluye:

* package.json
* README.md
* .env.example
* configuración necesaria
* archivos de inicio
* scripts para instalar y ejecutar

### IMPORTANTE

NO me entregues pseudocódigo.

NO dejes funciones con comentarios como:
"implement this later"
"TODO"
"your code here"

Quiero código REAL y funcional.

Antes de terminar:

1. Comprueba que no existan errores de sintaxis.
2. Comprueba que todas las importaciones existan.
3. Comprueba que los comandos estén registrados correctamente.
4. Comprueba que los botones funcionen.
5. Comprueba que los modales funcionen.
6. Comprueba que la base de datos funcione.
7. Comprueba que el bot pueda iniciarse correctamente.
8. Comprueba que el dashboard pueda conectarse al bot.
9. Crea instrucciones claras para instalarlo.
10. Explica exactamente dónde colocar el DISCORD_TOKEN, CLIENT_ID, CLIENT_SECRET y DATABASE_URL.

Al finalizar, entrega el proyecto completo listo para instalar y ejecutar.

También quiero instrucciones PASO A PASO para:

1. Crear la aplicación en Discord Developer Portal.
2. Crear el bot.
3. Activar los intents necesarios.
4. Obtener las credenciales.
5. Configurar el archivo .env.
6. Invitar el bot a mi servidor.
7. Instalar dependencias.
8. Iniciar el bot.
9. Iniciar el dashboard.
10. Solucionar los errores más comunes.

Si alguna función requiere una configuración adicional de Discord, explícala claramente.

El resultado debe ser un proyecto profesional, funcional y listo para producción.
Kodari AI
KodariAug 27 at 2:22 am 3
DiscordPremiumSuite
Un bot de Discord premium y modular con sistema de moderación completo, tickets con transcripciones, verificación, bienvenidas, niveles XP, economía con base de datos, y un dashboard web moderno con OAuth2. Incluye configuración interactiva por servidor mediante /setup, anti-spam, anti-link, anti-raid, y manejo robusto de errores. Todo persistente con base de datos y panel de administración responsive.

Voy a crear el proyecto en este orden:

  1. Núcleo de configuración, base de datos SQLite y arranque del bot.

  2. Cogs de moderación, tickets, verificación, bienvenida, niveles, economía e información.

  3. Panel interactivo /setup con botones, menú y modal de configuración.

  4. Dashboard Flask con OAuth2 de Discord, gestión por servidor, estilos responsive y documentación de instalación.

La base del bot, sus módulos funcionales, los paneles interactivos y el dashboard ya están creados. Añado ahora la documentación operativa, seguridad de credenciales y los pasos exactos de despliegue.

Proyecto generado desde cero con una arquitectura modular y funcional:

  • Bot discord.py con comandos slash sincronizados.

  • Moderación completa y logs persistentes.

  • Anti-links, anti-spam, anti-raid y protección de verificación.

  • Sistema de tickets con:

    • Tipos de ticket.

    • Canales privados.

    • Reclamar ticket.

    • Confirmación de cierre.

    • Transcripciones.

    • Logs.

  • Verificación mediante botón y asignación de rol.

  • Bienvenidas, despedidas y rol automático.

  • Sistema de niveles y leaderboard.

  • Economía persistente con tienda e inventario.

  • /setup interactivo con menú, botones y modales.

  • Dashboard Flask con OAuth2 de Discord.

  • Configuración de canales, roles, módulos, mensajes y colores desde el dashboard.

  • SQLite persistente mediante DATABASE_URL.

  • .env.example, .gitignore, pyproject.toml, requirements.txt y README completo.

Inicio:

Shell
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
cp .env.example .env

Configura en .env:

Env
DISCORD_TOKEN=TOKEN_DEL_BOT
CLIENT_ID=ID_DE_LA_APLICACION
CLIENT_SECRET=SECRETO_OAUTH2
OAUTH_REDIRECT_URI=http://localhost:5000/oauth/callback
FLASK_SECRET=CLAVE_ALEATORIA_LARGA
DATABASE_URL=sqlite:///data/bot.db

Arranca el bot:

Shell
python run_bot.py

En otra terminal, arranca el dashboard:

Shell
python run_dashboard.py

Dashboard:

Plain Text
http://localhost:5000

El archivo README.md contiene los pasos para crear la aplicación de Discord, activar intents, configurar OAuth2, invitar el bot, conceder permisos, ejecutar el proyecto y solucionar errores comunes.

Kodari can make mistakes. Review important code before using.
Files
cogs
dashboard
.gitignore
bot.py
config.py
database.py
pyproject.toml
README.md
requirements.txt
run_bot.py
run_dashboard.py
utils.py
Code
21 1,550
bot.py
import logging
import re
from collections import defaultdict, deque
from datetime import datetime, timedelta, timezone

import discord
from discord import app_commands
from discord.ext import commands

from config import BOT_PREFIX, DISCORD_TOKEN
from database import Database

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
logger = logging.getLogger("community_bot")


class CommunityBot(commands.Bot):
    def __init__(self):
        intents = discord.Intents.default()
        intents.members = True
        intents.message_content = True
        intents.presences = False
        super().__init__(command_prefix=BOT_PREFIX, intents=intents, help_command=None)
        self.db = Database()
        self.message_times: dict[tuple[int, int], deque[datetime]] = defaultdict(deque)
        self.xp_cooldowns: dict[tuple[int, int], datetime] = {}
        self.recent_joins: dict[int, deque[datetime]] = defaultdict(deque)

    async def setup_hook(self) -> None:
        self.db.init()
        from cogs.economy import EconomyCog
        from cogs.info import InfoCog
        from cogs.levels import LevelsCog
        from cogs.moderation import ModerationCog
        from cogs.setup import SetupCog
        from cogs.tickets import TicketControlsView, TicketOpenView, TicketsCog
        from cogs.verification import VerifyView, VerificationCog
        from cogs.welcome import WelcomeCog

        for cog in (ModerationCog, TicketsCog, VerificationCog, WelcomeCog, LevelsCog, EconomyCog, InfoCog, SetupCog):
            await self.add_cog(cog(self))
        self.add_view(TicketOpenView(self))
        self.add_view(TicketControlsView(self))
        self.add_view(VerifyView(self))
        self.tree.on_error = self.on_app_command_error
        await self.tree.sync()
        logger.info("Comandos globales sincronizados")

    async def on_ready(self) -> None:
        logger.info("Conectado como %s en %d servidores", self.user, len(self.guilds))

    async def on_guild_join(self, guild: discord.Guild) -> None:
        self.db.ensure_guild(guild.id)

    async def on_message(self, message: discord.Message) -> None:
        if message.author.bot or not message.guild:
            return
        settings = self.db.settings(message.guild.id)
        verify_role = message.guild.get_role(settings.get("verify_role_id")) if settings.get("verify_role_id") else None
        if settings["verification_protection"] and verify_role and verify_role not in message.author.roles:
            try:
                await message.delete()
            except discord.HTTPException:
                logger.exception("No se pudo eliminar un mensaje de un usuario no verificado")
            return
        if settings["anti_links"] and re.search(r"(?:https?://|www\.|discord\.gg/)", message.content, re.IGNORECASE):
            if not message.author.guild_permissions.manage_messages:
                try:
                    await message.delete()
                    await message.channel.send(f"{message.author.mention}, los enlaces no están permitidos aquí.", delete_after=5)
                    await self._record_automatic(message, "anti-link", "Enlace eliminado")
                except discord.HTTPException:
                    logger.exception("No se pudo gestionar un enlace")
                return
        if settings["anti_spam"]:
            key = (message.guild.id, message.author.id)
            now = datetime.now(timezone.utc)
            history = self.message_times[key]
            history.append(now)
            while history and (now - history[0]).total_seconds() > 8:
                history.popleft()
            if len(history) >= 6:
                try:
                    await message.delete()
                    await message.author.timeout(timedelta(seconds=30), reason="Anti-spam automático")
                    await self._record_automatic(message, "anti-spam", "Usuario limitado durante 30 segundos")
                except (discord.HTTPException, discord.Forbidden):
                    logger.exception("No se pudo gestionar el spam")
                history.clear()
                return
        if settings["levels_enabled"]:
            key = (message.guild.id, message.author.id)
            now = datetime.now(timezone.utc)
            if now >= self.xp_cooldowns.get(key, datetime.min.replace(tzinfo=timezone.utc)):
                self.xp_cooldowns[key] = now + timedelta(seconds=max(5, settings["xp_cooldown"]))
                xp, level, advanced = self.db.add_xp(message.guild.id, message.author.id, 10)
                if advanced:
                    await message.channel.send(f"🎉 {message.author.mention} ha alcanzado el nivel **{level}**.", delete_after=8)
        await self.process_commands(message)

    async def _record_automatic(self, message: discord.Message, action: str, details: str) -> None:
        self.db.add_moderation_log(message.guild.id, action, message.author.id, self.user.id if self.user else 0, details)

    async def on_app_command_error(self, interaction: discord.Interaction, error: app_commands.AppCommandError) -> None:
        if isinstance(error, app_commands.errors.MissingPermissions):
            text = "No tienes los permisos necesarios para usar este comando."
        elif isinstance(error, app_commands.errors.CheckFailure):
            text = "No puedes ejecutar este comando en este contexto."
        else:
            logger.exception("Error en comando de aplicación", exc_info=error)
            text = "Ocurrió un error inesperado. El equipo ha sido notificado."
        if interaction.response.is_done():
            await interaction.followup.send(text, ephemeral=True)
        else:
            await interaction.response.send_message(text, ephemeral=True)


def main() -> None:
    if not DISCORD_TOKEN:
        raise SystemExit("Falta DISCORD_TOKEN. Copia .env.example a .env y configúralo.")
    bot = CommunityBot()
    bot.run(DISCORD_TOKEN, log_handler=None)


if __name__ == "__main__":
    main()