botDC.py

from datetime import datetime, timedelta
import os
from typing import Optional

import discord
from discord.ext import commands
from dctoken import token

##################################################################################################################

# Bot-Setup
intents: discord.Intents = discord.Intents.all()
intents.message_content = True
intents.messages = True
bot: commands.Bot = commands.Bot(command_prefix='!', intents=intents)

##################################################################################################################

def info(message: str) -> None:
    print(f'\033[90m{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} \033[94mINFO     \033[35mBOT \033[0m{message}')

def warn(message: str) -> None:
    print(f'\033[90m{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} \033[94mWARNING  \033[35mBOT \033[0m{message}')

def error(message: str) -> None:
    print(f'\033[90m{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} \033[94mERROR    \033[35mBOT \033[0m{message}')

def critical(message: str) -> None:
    print(f'\033[90m{datetime.now().strftime("%Y-%m-%d %H:%M:%S")} \033[94mCRITICAL \033[35mBOT \033[0m{message}')

##################################################################################################################

@bot.event
async def on_ready() -> None:
    await bot.tree.sync()
    info(f'Bot {bot.user} has connected to Discord and is live!')


@bot.event
async def on_exit() -> None:
    info(f"Bot is shutting down!")

@bot.event
async def on_reaction_add(reaction: discord.Reaction, user: discord.Member) -> None:
    if reaction.emoji == '🗑️' and user != bot.user:
        await reaction.message.delete()
        info(f"Message {reaction.message.content} ({reaction.message.id}) was deleted by @{user}.")

##################################################################################################################

@bot.tree.command(name='delete_messages', description='Deletes the last selected amount of messages')
async def delete_messages(interaction: discord.Interaction, amount: Optional[int]) -> None:
    if not interaction.user.guild_permissions.manage_messages:  # type: ignore
        embed = discord.Embed(title="Error", description="You do not have permission to delete messages.", color=0xff0000)
        await interaction.response.send_message(embed=embed)
        info(f"User @{interaction.user} tried to delete messages without permission.")
        return

    if amount == 'all':
        amount = None  # type: ignore
    else:
        try:
            amount = int(amount) + 1 #type: ignore
            if amount <= 0:
                raise ValueError
        except ValueError:
            embed = discord.Embed(title="Error", description="The number of messages to be deleted must be greater than 0!", color=0xff0000)
            await interaction.response.send_message(embed=embed)
            info(f"User @{interaction.user} tried to delete an invalid amount of messages.")
            return

    try:
        amount = int(amount) #type: ignore
    except:
        pass

    if isinstance(interaction.channel, discord.TextChannel) and isinstance(amount, int):
        deleted = await interaction.channel.purge(limit=amount)
    else:
        embed = discord.Embed(title="Error", description="This command can only be used in a text channel.", color=0xff0000)
        await interaction.response.send_message(embed=embed)
        info(f"User @{interaction.user} tried to delete messages in a non-text channel.")
        return

    embed = discord.Embed(title="Message Deletion", description=f"{len(deleted)-1} messages have been deleted.", color=0x00ff00)
    await interaction.response.send_message(embed=embed, delete_after=5)  # Send confirmation
    info(f"User @{interaction.user} deleted {len(deleted)-1} messages in #{interaction.channel}.")


@bot.tree.command(name='dm_reminder', description='Send\'s a Reminder to a Person via DM')
async def dm_reminder(interaction: discord.Interaction, target: discord.Member | discord.Role, timer: int, *, message: str) -> None:
    """
    Sends a reminder to a user or a role.
    If the time is 0, the reminder is sent immediately.

    ---
    target: discord.Member -> The target to be reminded.
    timer: int -> Time in minutes until the message is sent.
    message: str -> The message that will appear in the reminder.
    """
    reminder_title: str = "<:reminder_1:1330501855503061042><:reminder_2:1330501857457606757><:reminder_3:1330501859827257406><:reminder_4:1330501861731602562><:reminder_5:1330501863958777997><:reminder_6:1330501865753804873>"

    required_roles = ['Supporter', 'Moderator', 'Admin']
    user_roles = [role.name for role in interaction.user.roles] #type: ignore
    if any(role in required_roles for role in user_roles) or interaction.user.guild_permissions.administrator: #type: ignore
        pass
    else:
        embed = discord.Embed(title="Error", description="You do not have permission to create a reminder.", color=0xff0000)
        await interaction.response.send_message(embed=embed)
        info(f"User @{interaction.user} tried to create a reminder without permission.")
        return

    # Nachricht löschen, die den Reminder erstellt
    await interaction.message.delete() #type: ignore
    info(f"User @{interaction.user} created a reminder with message: '{message}' for {target.name} in {timer} minutes.")

    # Sofortige Erinnerung bei Zeit = 0
    if timer == 0:
        embed_reminder = discord.Embed(
            title=reminder_title,
            description=f"{message.replace('\\n', '\n')}\n\n{target.mention}",
            color=discord.Color.blue(),
            timestamp=datetime.now()
        )
        embed_reminder.set_footer(text=f"Gesendet von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
        if isinstance(target, discord.Member):
            try:
                await target.send(embed=embed_reminder)
            except discord.Forbidden:
                warn(f"Could not send DM to @{target.name}. Their DMs might be closed.")
        else:
            for member in target.members:
                try:
                    await member.send(embed=embed_reminder)
                except discord.Forbidden:
                    warn(f"Could not send DM to @{member.name}. Their DMs might be closed.")
        info(f"Instant reminder sent to {target.name} with message: '{message}'.")
        return

    # Zeit validieren
    if timer < 0:
        await interaction.response.send_message("Die Zeit muss 0 oder größer sein!")
        warn(f"User @{interaction.user} tried to set a reminder with invalid time: {timer}.")
        return

    # Aktuelle Zeit und geplante Zeit berechnen
    remind_time = datetime.now() + timedelta(minutes=timer)

    # Bestätigung senden
    embed_confirm = discord.Embed(
        title="🔔 Reminder gesetzt!",
        description=f"Ich werde {target.mention} erinnern.",
        color=discord.Color.green(),
        timestamp=datetime.now()
    )
    embed_confirm.add_field(name="Nachricht", value=message, inline=False)
    embed_confirm.add_field(name="Erinnerung um", value=remind_time.strftime("%Y-%m-%d %H:%M:%S"), inline=True)
    embed_confirm.set_footer(text=f"Gesetzt von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
    await interaction.response.send_message(embed=embed_confirm, delete_after=10)

    # Warten für die angegebene Zeit
    await discord.utils.sleep_until(remind_time)

    # Reminder senden
    embed_reminder = discord.Embed(
        title=reminder_title,
        description=f"{message.replace('\\n', '\n')}\n\n{target.mention}",
        color=discord.Color.blue(),
        timestamp=datetime.now()
    )
    embed_reminder.set_footer(text=f"Gesendet von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
    if isinstance(target, discord.Member):
        try:
            await target.send(embed=embed_reminder)
        except discord.Forbidden:
            warn(f"Could not send DM to @{target.name}. Their DMs might be closed.")
    else:
        for member in target.members:
            try:
                await member.send(embed=embed_reminder)
            except discord.Forbidden:
                warn(f"Could not send DM to @{member.name}. Their DMs might be closed.")
    info(f"Reminder sent to {target.name} with message: '{message}' after waiting for {timer} minutes.")

@bot.tree.command(name='updateping', description='Toggles @update-ping role')
async def updateping(interaction: discord.Interaction) -> None:
    # Get the update-ping role
    update_ping_role: Optional[discord.Role] = discord.utils.get(interaction.guild.roles, name="update-ping") #type: ignore

    # Check if the user has the update-ping role
    if update_ping_role in interaction.user.roles: #type: ignore
        # If the user has the role, remove it
        await interaction.user.remove_roles(update_ping_role) #type: ignore
        embed = discord.Embed(title="Role Update", description="Update-Ping role removed.", color=0x00ff00)
        await interaction.response.send_message(embed=embed)
        info(f"Update-Ping role removed from @{interaction.user}.")
    else:
        # If the user doesn't have the role, add it
        await interaction.user.add_roles(update_ping_role) #type: ignore
        embed = discord.Embed(title="Role Update", description="Update-Ping role added.", color=0x00ff00)
        await interaction.response.send_message(embed=embed)
        info(f"Update-Ping role added to @{interaction.user}.")

@bot.tree.command()
async def reminder(interaction: discord.Interaction, role: discord.Role, timer: int, *, message: str) -> None:
    """
    Sendet einen Reminder mit einer Rolle und einer Nachricht.
    Wenn die Zeit 0 ist, wird die Rolle sofort erinnert.

    ---
    role: discord.Role -> Die Rolle, die gepingt werden soll.
    timer: int -> Zeit in Minuten, bis die Nachricht gesendet wird.
    message: str -> Die Nachricht, die im Reminder erscheinen soll.
    """
    reminder_title: str = "<:reminder_1:1330501855503061042><:reminder_2:1330501857457606757><:reminder_3:1330501859827257406><:reminder_4:1330501861731602562><:reminder_5:1330501863958777997><:reminder_6:1330501865753804873>"

    required_roles = ['Supporter', 'Moderator', 'Admin']
    user_roles = [role.name for role in interaction.user.roles] #type: ignore
    if any(role in required_roles for role in user_roles) or interaction.user.guild_permissions.administrator: #type: ignore
        pass
    else:
        embed = discord.Embed(title="Error", description="You do not have permission to create a reminder.", color=0xff0000)
        await interaction.response.send_message(embed=embed)
        info(f"User @{interaction.user} tried to create a reminder without permission.")
        return

    # Nachricht löschen, die den Reminder erstellt
    await interaction.message.delete() #type: ignore
    info(f"User @{interaction.user} created a reminder with message: '{message}' for role: @{role.name} in {timer} minutes.")

    # Sofortige Erinnerung bei Zeit = 0
    if timer == 0:
        embed_reminder = discord.Embed(
            title=reminder_title,
            description=f"{message.replace('\\n', '\n')}\n\n{role.mention}",
            color=discord.Color.blue(),
            timestamp=datetime.now()
        )
        embed_reminder.set_footer(text=f"Gesendet von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
        await interaction.response.send_message(embed=embed_reminder)
        info(f"Instant reminder sent to @{role.name} with message: '{message}'.")
        return

    # Zeit validieren
    if timer < 0:
        await interaction.response.send_message("Die Zeit muss 0 oder größer sein!")
        warn(f"User @{interaction.user} tried to set a reminder with invalid time: {timer}.")
        return

    # Aktuelle Zeit und geplante Zeit berechnen
    remind_time = datetime.now() + timedelta(minutes=timer)

    # Bestätigung senden
    embed_confirm = discord.Embed(
        title="🔔 Reminder gesetzt!",
        description=f"Ich werde {role.mention} erinnern.",
        color=discord.Color.green(),
        timestamp=datetime.now()
    )
    embed_confirm.add_field(name="Nachricht", value=message, inline=False)
    embed_confirm.add_field(name="Erinnerung um", value=remind_time.strftime("%Y-%m-%d %H:%M:%S"), inline=True)
    embed_confirm.set_footer(text=f"Gesetzt von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
    await interaction.response.send_message(embed=embed_confirm, delete_after=10)

    # Warten für die angegebene Zeit
    await discord.utils.sleep_until(remind_time)

    # Reminder senden
    embed_reminder = discord.Embed(
        title=reminder_title,
        description=f"{message.replace('\\n', '\n')}\n\n{role.mention}",
        color=discord.Color.blue(),
        timestamp=datetime.now()
    )
    embed_reminder.set_footer(text=f"Gesendet von {interaction.user.display_name}", icon_url=interaction.user.avatar.url) #type: ignore
    await interaction.response.send_message(embed=embed_reminder)
    info(f"Reminder sent to @{role.name} with message: '{message}' after waiting for {timer} minutes.")

@bot.tree.command(name='install', description='Toggle\'s @install role')
async def install(interaction: discord.Interaction) -> None:
    # Get the 'Install Needed' role
    install_needed_role: Optional[discord.Role] = discord.utils.get(interaction.guild.roles, name="Install Needed") #type: ignore

    # Check if the user has the 'Install Needed' role
    if install_needed_role in interaction.user.roles: #type: ignore
        # If the user has the role, remove it
        await interaction.user.remove_roles(install_needed_role) #type: ignore
        embed = discord.Embed(title="Role Update", description="'Install Needed' role removed.", color=0x00ff00)
        await interaction.response.send_message(embed=embed)
        info(f"Install Needed role removed from @{interaction.user}.")
    else:
        # If the user doesn't have the role, add it
        await interaction.user.add_roles(install_needed_role) #type: ignore
        embed = discord.Embed(title="Role Update", description="'Install Needed' role added.", color=0x00ff00)
        await interaction.response.send_message(embed=embed)
        info(f"Install Needed role added to @{interaction.user}.")

@bot.tree.command(name='dm_spam', description='Spams a User\'s Dm with a Message in the selected amount')
async def dm_spam(interaction: discord.Interaction, user: discord.Member, amount: int, message: str) -> None:
    await interaction.message.delete() #type: ignore
    if user == bot.user:
        return

    # Check if the user has the 'Reminder' role
    admin_role = discord.utils.get(interaction.guild.roles, name="Admin") #type: ignore
    moderator_role = discord.utils.get(interaction.guild.roles, name="Moderator") #type: ignore
    supporter_role = discord.utils.get(interaction.guild.roles, name="Supporter") #type: ignore
    premium_role = discord.utils.get(interaction.guild.roles, name="Premium") #type: ignore

    if admin_role not in interaction.user.roles and moderator_role not in interaction.user.roles and supporter_role not in interaction.user.roles and premium_role not in interaction.user.roles: #type: ignore
        return

    for i in range(0, amount):
        try:
            await user.send(content=' '.join(msg for msg in message))
            info(f"DM sent to @{user.name} (Attempt {i+1}/{amount}).")
        except discord.Forbidden:
            warn(f"Could not send DM to @{user.name}. Their DMs might be closed.")

@bot.tree.command(name="dm_warn", description="Warn a user and send them a detailed embed message.")
async def dm_warn(interaction: discord.Interaction, member: discord.Member, reason: str):
    """
    Warn a user and send a detailed embed message to them.

    ---
    arg:
    member: discord.Member - The user to warn.
    reason: str - The reason for the warning.
    """
    # Check if the command user has the necessary permissions
    if not interaction.user.guild_permissions.manage_messages: #type: ignore
        await interaction.response.send_message(
            embed=discord.Embed(
                title="Permission Denied",
                description="You do not have permission to use this command!",
                color=discord.Color.red()
            ),
            ephemeral=True
        )
        return

    # Simulate the Dyno warning command
    try:
        # Send the warning in the current channel
        warn_message = f"/warn {member.mention} {reason}"
        await interaction.channel.send(embed=discord.Embed( #type: ignore
            title="Warning Issued",
            description=f"{warn_message}",
            color=discord.Color.orange()
        ))

        # Create and send an embed message to the warned user
        dm_embed = discord.Embed(
            title="You Have Been Warned",
            description=(
                f"Hello {member.mention},\n\n"
                f"You have been warned in **{interaction.guild.name}** for the following reason:\n" #type: ignore
                f"**{reason}**\n\n"
                "Please adhere to the server rules to avoid further consequences.\n"
                "If you have any questions, contact the server team."
            ),
            color=discord.Color.orange()
        )

        try:
            await member.send(embed=dm_embed)
            confirmation_embed = discord.Embed(
                title="User Warned Successfully",
                description=f"{member.mention} has been warned and informed via DM.",
                color=discord.Color.green()
            )
        except discord.Forbidden:
            confirmation_embed = discord.Embed(
                title="User Warned",
                description=f"{member.mention} has been warned, but the DM could not be delivered.",
                color=discord.Color.yellow()
            )

        # Send confirmation in the channel
        await interaction.response.send_message(embed=confirmation_embed)

    except Exception as e:
        error_embed = discord.Embed(
            title="Error",
            description=f"There was a problem executing the command: {e}",
            color=discord.Color.red()
        )
        await interaction.response.send_message(embed=error_embed, ephemeral=True)

##################################################################################################################

@bot.tree.command(name='help', description='Show\'s a List of Commands and what they do')
async def list_commands(interaction: discord.Interaction) -> None:
    embed = discord.Embed(title="Help", description="A list of available commands.", color=0x00ff00)
    for command in bot.commands:
        embed.add_field(name=f"/{command.name}", value=command.help, inline=False)
    await interaction.response.send_message(embed=embed)
    info(f"User @{interaction.user} requested the list of commands.")

##################################################################################################################

def main() -> None:
    os.system('cls' if os.name == 'nt' else 'clear')
    bot.run(token)

if __name__ == '__main__':
    main()