zyxf_f

cześć zrób mi bota discord do ticketów przywitań weryfikacji konkursów mecheniki levelów i ladna wiadomosc z boostami

Kodari AI
KodariAug 22 at 9:28 am 2
  1. Utworzę kompletny bot Discord w Pythonie z modułami ticketów, powitań, weryfikacji, konkursów, leveli i obsługi boostów.

  2. Dodam trwałą bazę SQLite, slash-komendy, przyciski oraz konfigurację przez .env.

  3. Dodam instrukcję uruchomienia i wymagane zależności.

Utworzyłem kompletnego bota Discord w Pythonie z:

  • 🎫 systemem prywatnych ticketów,

  • 👋 wiadomościami powitalnymi,

  • ✅ panelem weryfikacji rolą,

  • 🎉 konkursami z przyciskiem udziału i automatycznym losowaniem,

  • 📊 systemem XP, leveli i rankingiem,

  • 💎 estetycznym panelem boostów oraz podziękowaniami za boost,

  • 💾 bazą SQLite,

  • ⚙️ konfiguracją przez .env,

  • 📖 instrukcją uruchomienia w README.md.

Pliki projektu:

  • bot.py

  • database.py

  • views.py

  • requirements.txt

  • .env.example

  • README.md

Aby uruchomić:

Shell
pip install -r requirements.txt

Następnie skopiuj .env.example jako .env, wpisz token bota oraz ID kanałów i uruchom:

Shell
python bot.py
Kodari can make mistakes. Review important code before using.
Files
bot.py
database.py
README.md
requirements.txt
views.py
Code
5 741
bot.py
import logging
import os
import random
import re
import time
from datetime import datetime, timezone
from typing import Optional

import discord
from discord import app_commands
from discord.ext import commands, tasks
from dotenv import load_dotenv

from database import Database
from views import CloseTicketView, ContestView, TicketPanelView, VerificationView


load_dotenv()
logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(name)s | %(message)s")
logger = logging.getLogger("kodari-bot")


def env_int(name: str) -> Optional[int]:
    value = os.getenv(name, "").strip()
    if not value:
        return None
    try:
        return int(value)
    except ValueError:
        logger.warning("Zmienna %s nie jest poprawnym ID.", name)
        return None


class KodariBot(commands.Bot):
    def __init__(self):
        intents = discord.Intents.default()
        intents.members = True
        intents.message_content = True
        intents.messages = True
        super().__init__(command_prefix=commands.when_mentioned_or("!"), intents=intents)
        self.config = {
            "guild_id": env_int("GUILD_ID"),
            "welcome_channel_id": env_int("WELCOME_CHANNEL_ID"),
            "verification_role_id": env_int("VERIFICATION_ROLE_ID"),
            "boost_channel_id": env_int("BOOST_CHANNEL_ID"),
            "ticket_category_id": env_int("TICKET_CATEGORY_ID"),
            "level_up_channel_id": env_int("LEVEL_UP_CHANNEL_ID"),
            "log_channel_id": env_int("LOG_CHANNEL_ID"),
            "xp_cooldown": max(0, int(os.getenv("XP_COOLDOWN_SECONDS", "60"))),
        }
        self.db = Database(os.getenv("DATABASE_PATH", "data/bot.db"))
        self.xp_cooldowns: dict[tuple[int, int], float] = {}

    async def setup_hook(self):
        self.add_view(TicketPanelView(self))
        self.add_view(CloseTicketView(self))
        self.add_view(VerificationView(self))
        for contest in self.db.active_contests():
            self.add_view(ContestView(self, contest["id"]))

        guild_id = self.config["guild_id"]
        if guild_id:
            guild = discord.Object(id=guild_id)
            self.tree.copy_global_to(guild=guild)
            await self.tree.sync(guild=guild)
            logger.info("Slash-komendy zsynchronizowane z serwerem %s.", guild_id)
        else:
            await self.tree.sync()
            logger.info("Slash-komendy zsynchronizowane globalnie.")
        self.contest_watcher.start()

    async def on_ready(self):
        logger.info("Zalogowano jako %s (%s).", self.user, self.user.id if self.user else "?")

    def current_timestamp(self) -> int:
        return int(time.time())

    async def send_log(self, guild: Optional[discord.Guild], content: str) -> None:
        if guild is None:
            return
        channel_id = self.config["log_channel_id"]
        channel = guild.get_channel(channel_id) if channel_id else None
        if isinstance(channel, discord.TextChannel):
            try:
                await channel.send(content)
            except discord.HTTPException:
                logger.warning("Nie udało się wysłać logu na serwerze %s.", guild.id)

    async def create_ticket(self, guild: discord.Guild, member: discord.Member) -> discord.TextChannel:
        topic = f"ticket_owner:{member.id}"
        existing = next(
            (channel for channel in guild.text_channels if channel.topic == topic),
            None,
        )
        if existing:
            return existing

        category_id = self.config["ticket_category_id"]
        category = guild.get_channel(category_id) if category_id else None
        if not isinstance(category, discord.CategoryChannel):
            category = None

        overwrites = {
            guild.default_role: discord.PermissionOverwrite(view_channel=False),
            member: discord.PermissionOverwrite(
                view_channel=True,
                send_messages=True,
                read_message_history=True,
                attach_files=True,
            ),
        }
        if guild.me:
            overwrites[guild.me] = discord.PermissionOverwrite(
                view_channel=True,
                send_messages=True,
                read_message_history=True,
                manage_channels=True,
            )

        channel = await guild.create_text_channel(
            name=f"ticket-{member.id}",
            category=category,
            topic=topic,
            overwrites=overwrites,
            reason=f"Ticket utworzony przez {member}",
        )
        embed = discord.Embed(
            title="🎫 Ticket otwarty",
            description=(
                f"Witaj {member.mention}! Opisz dokładnie, w czym możemy pomóc.\n"
                "Ktoś z ekipy odpowie tak szybko, jak to możliwe."
            ),
            color=discord.Color.blurple(),
        )
        embed.set_footer(text="Nie udostępniaj tutaj haseł ani prywatnych tokenów.")
        await channel.send(embed=embed, view=CloseTicketView(self))
        await self.send_log(guild, f"Utworzono ticket {channel.mention} dla {member.mention}.")
        return channel

    def contest_embed(self, contest: dict, ended: bool = False, winners: Optional[list[int]] = None) -> discord.Embed:
        if ended:
            winner_text = "Brak zgłoszeń."
            if winners:
                winner_text = " ".join(f"<@{user_id}>" for user_id in winners)
            embed = discord.Embed(
                title="🎉 Konkurs zakończony",
                description=f"**Nagroda:** {contest['prize']}\n\n**Zwycięzcy:** {winner_text}",
                color=discord.Color.gold(),
            )
            embed.set_footer(text=f"Konkurs #{contest['id']}")
            return embed

        end_time = datetime.fromtimestamp(contest["ends_at"], tz=timezone.utc)
        embed = discord.Embed(
            title="🎉 KONKURS",
            description=(
                f"## {contest['prize']}\n\n"
                f"Kliknij przycisk **Weź udział**, aby dołączyć.\n"
                f"Liczba zwycięzców: **{contest['winners']}**\n"
                f"Koniec: {discord.utils.format_dt(end_time, style='R')}"
            ),
            color=discord.Color.from_rgb(255, 92, 168),
        )
        embed.set_footer(text=f"Konkurs #{contest['id']} • Powodzenia wszystkim!")
        return embed

    async def finish_contest(self, contest_id: int) -> bool:
        contest = self.db.get_contest(contest_id)
        if contest is None or contest["ended"]:
            return False
        if not self.db.mark_contest_ended(contest_id):
            return False
        entries = self.db.contest_entries(contest_id)
        winners = random.sample(entries, min(len(entries), contest["winners"]))
        channel = self.get_channel(contest["channel_id"])
        if isinstance(channel, discord.TextChannel):
            if contest["message_id"]:
                try:
                    message = await channel.fetch_message(contest["message_id"])
                    await message.edit(
                        embed=self.contest_embed(contest, ended=True, winners=winners),
                        view=ContestView(self, contest_id, disabled=True),
                    )
                except discord.HTTPException:
                    pass
            if winners:
                mentions = " ".join(f"<@{user_id}>" for user_id in winners)
                await channel.send(f"🎊 Gratulacje {mentions}! Wygrywacie **{contest['prize']}**!")
            else:
                await channel.send("Konkurs zakończony, ale nikt nie wziął udziału.")
        return True

    @tasks.loop(minutes=1)
    async def contest_watcher(self):
        for contest in self.db.active_contests():
            if contest["ends_at"] <= self.current_timestamp():
                await self.finish_contest(contest["id"])

    @contest_watcher.before_loop
    async def before_contest_watcher(self):