761 lines
19 KiB
Python
Executable File
761 lines
19 KiB
Python
Executable File
#!/usr/local/bin/python
|
|
import os
|
|
import random
|
|
import requests
|
|
|
|
import discord
|
|
from discord.ext import commands
|
|
|
|
TOKEN = os.getenv("token")
|
|
bot = commands.Bot(command_prefix="!")
|
|
# Remove the default !help action so we can use our own
|
|
bot.remove_command("help")
|
|
|
|
|
|
def generate_embed(
|
|
embed_url=None,
|
|
embed_title=None,
|
|
embed_description=None,
|
|
embed_color=None,
|
|
author_name=None,
|
|
author_image=None,
|
|
):
|
|
"""
|
|
generate_embed(embed_url=None, embed_title=None, embed_description=None, embed_color=None)
|
|
|
|
Generates a discord embed object based on the URL passed in
|
|
Optionally, you can set the title and description text for the embed object.
|
|
"""
|
|
|
|
if not embed_description and embed_url:
|
|
embed_description = "[Direct Link]({})".format(embed_url)
|
|
|
|
if not embed_color:
|
|
embed_color = discord.Color.gold()
|
|
|
|
embed = discord.Embed(
|
|
title=embed_title, description=embed_description, color=embed_color, type="rich"
|
|
)
|
|
if embed_url:
|
|
embed.set_image(url=embed_url)
|
|
|
|
if author_image or author_name:
|
|
embed.set_author(name=author_name, icon_url=author_image)
|
|
|
|
return embed
|
|
|
|
|
|
#### a bunch of silly functions that will listen for messages with specific content
|
|
@bot.listen("on_message")
|
|
async def fix_cdn_url(ctx):
|
|
if "media.discordapp.net" in ctx.content:
|
|
await ctx.delete()
|
|
await ctx.channel.send(
|
|
"%s said:\n%s"
|
|
% (
|
|
ctx.author.mention,
|
|
ctx.content.replace("media.discordapp.net", "cdn.discordapp.com"),
|
|
)
|
|
)
|
|
return
|
|
|
|
|
|
# @bot.listen('on_message')
|
|
# async def react_with_dale(ctx):
|
|
# if 'dale' in ctx.content.lower():
|
|
# emoji = discord.utils.get(ctx.guild.emojis, name='dale')
|
|
# if emoji:
|
|
# await ctx.add_reaction(emoji)
|
|
# return
|
|
|
|
|
|
@bot.listen("on_message")
|
|
async def based(ctx):
|
|
if ctx.content.lower() == "based":
|
|
await ctx.reply("https://i.imgur.com/MejGa23.jpeg")
|
|
|
|
|
|
@bot.listen("on_message")
|
|
async def convert_heic_to_jpg(ctx):
|
|
from wand.image import Image
|
|
|
|
if ctx.attachments:
|
|
for attachment in ctx.attachments:
|
|
if attachment.filename.lower().endswith("heic"):
|
|
heic_file = "/tmp/heic"
|
|
jpg_file = "/tmp/jpg.jpg"
|
|
await attachment.save(fp=heic_file)
|
|
|
|
# Convert heic to jpg
|
|
img = Image(filename=heic_file)
|
|
img.format = "jpg"
|
|
img.save(filename=jpg_file)
|
|
img.close()
|
|
try:
|
|
await ctx.delete()
|
|
except Exception:
|
|
pass
|
|
await ctx.channel.send(
|
|
"%s said:\n%s" % (ctx.author.mention, ctx.content),
|
|
file=discord.File(jpg_file),
|
|
)
|
|
return
|
|
|
|
|
|
@bot.event
|
|
async def on_ready():
|
|
print(f"{bot.user.name} has connected to Discord!")
|
|
game = discord.Game("Type !help")
|
|
await bot.change_presence(
|
|
status=discord.Status.online,
|
|
activity=discord.Activity(
|
|
type=discord.ActivityType.listening, name="type !help"
|
|
),
|
|
)
|
|
await bot.get_channel(152921472304676865).send("I have reconnected")
|
|
|
|
|
|
@bot.command(name="shoo")
|
|
async def shoo(ctx):
|
|
if ctx.message.author.id != 144986109804412928:
|
|
return
|
|
await ctx.message.delete()
|
|
await ctx.message.guild.leave()
|
|
|
|
|
|
@bot.command(name="ask")
|
|
async def ask(ctx):
|
|
import questions
|
|
|
|
await ctx.send(
|
|
questions.answer_question(ctx.message.content),
|
|
)
|
|
|
|
|
|
@bot.command(name="invite")
|
|
async def invite(ctx):
|
|
# Default to creating the invite to the channel the message was sent in
|
|
# if the user is in a voice channel, create the invite there
|
|
invite_channel = ctx.message.channel
|
|
|
|
try:
|
|
if ctx.message.author.voice.channel:
|
|
invite_channel = ctx.message.author.voice.channel
|
|
except AttributeError:
|
|
pass
|
|
|
|
temp = False
|
|
if "temp" in ctx.message.content:
|
|
temp = True
|
|
await ctx.author.send("Here is your temporary invite")
|
|
|
|
invite = await invite_channel.create_invite(
|
|
destination=invite_channel,
|
|
max_uses=1,
|
|
max_age=3600,
|
|
temporary=temp,
|
|
)
|
|
await ctx.send("Check your DMs")
|
|
await ctx.author.send(invite)
|
|
|
|
|
|
@bot.command(name="help")
|
|
async def help(ctx):
|
|
|
|
import help_methods
|
|
|
|
if len(ctx.message.content.split()) > 1:
|
|
await ctx.send(help_methods.parse_message(ctx.message.content))
|
|
else:
|
|
await ctx.send(embed=help_methods.get_help_embed(bot))
|
|
|
|
|
|
@bot.command(name="wink")
|
|
async def wink(ctx):
|
|
await ctx.send(
|
|
embed=generate_embed(
|
|
embed_url=requests.get("https://some-random-api.ml/animu/wink").json()[
|
|
"link"
|
|
]
|
|
)
|
|
)
|
|
|
|
|
|
@bot.command(name="smug")
|
|
async def smug(ctx):
|
|
import get_from_reddit
|
|
|
|
await ctx.send(
|
|
embed=generate_embed(embed_url=get_from_reddit.get_image("smuganimegirls"))
|
|
)
|
|
|
|
|
|
@bot.command(name="pout")
|
|
async def pout(ctx):
|
|
import get_from_reddit
|
|
|
|
await ctx.send(embed=generate_embed(embed_url=get_from_reddit.get_image("pouts")))
|
|
|
|
|
|
@bot.command(name="roll")
|
|
async def roll(ctx):
|
|
import dice
|
|
|
|
await ctx.send(embed=dice.parse_message(ctx.message.content))
|
|
|
|
|
|
@bot.command(name="owo")
|
|
async def owo(ctx):
|
|
from owotext import OwO
|
|
|
|
uwu = OwO()
|
|
await ctx.send(uwu.whatsthis(" ".join(ctx.message.content.split()[1:])))
|
|
|
|
|
|
@bot.command(name="excuse")
|
|
async def excuse(ctx):
|
|
import excuse
|
|
|
|
await ctx.send(excuse.get_excuse())
|
|
|
|
|
|
@bot.command(name="emoji")
|
|
async def emoji(ctx):
|
|
await ctx.message.delete()
|
|
try:
|
|
command, url, emoji_name = ctx.message.content.split()
|
|
except Exception:
|
|
import help_methods
|
|
|
|
await ctx.send(help_methods.get_help_message("emoji"))
|
|
return
|
|
|
|
import core_utils
|
|
|
|
emoji_staging = "/tmp/emoji"
|
|
try:
|
|
await ctx.send(
|
|
"emoji successfully uploaded! Heres how it looks in a sentence {}\nUse it with `:{}:`".format(
|
|
await ctx.message.guild.create_custom_emoji(
|
|
name=emoji_name,
|
|
image=open(
|
|
core_utils.download_image(url, emoji_staging), "rb"
|
|
).read(),
|
|
),
|
|
emoji_name,
|
|
)
|
|
)
|
|
except Exception:
|
|
await ctx.send("I wasnt able to upload that image as an emoji. Sorry")
|
|
os.remove(emoji_staging)
|
|
return
|
|
|
|
|
|
@bot.command(name="avatar")
|
|
async def avatar(ctx):
|
|
profile = [ctx.message.author]
|
|
if len(ctx.message.mentions):
|
|
profile = ctx.message.mentions
|
|
|
|
# Code stolen from this reddit post
|
|
for user in profile:
|
|
avatar_url = user.avatar_url_as(static_format="png")
|
|
await ctx.send(
|
|
embed=generate_embed(
|
|
embed_title="{}#{}".format(user.name, user.discriminator),
|
|
embed_url=avatar_url,
|
|
embed_description="[Direct Link]({})".format(avatar_url),
|
|
)
|
|
)
|
|
|
|
|
|
@bot.command(name="meme")
|
|
async def meme(ctx):
|
|
|
|
import meme_gen
|
|
|
|
await ctx.message.delete()
|
|
await ctx.send(
|
|
embed=generate_embed(embed_url=meme_gen.parse_message(ctx.message.content))
|
|
)
|
|
|
|
|
|
@bot.command(name="lewd")
|
|
async def lewd(ctx):
|
|
if not ctx.message.channel.is_nsfw():
|
|
await ctx.send("You can only use this command in NSFW channels")
|
|
return
|
|
import lewds
|
|
|
|
await ctx.send(
|
|
embed=generate_embed(
|
|
embed_url=lewds.get_lewd(),
|
|
embed_title="{} is being lewd".format(ctx.message.author.name),
|
|
)
|
|
)
|
|
|
|
|
|
@bot.command(name="redpanda")
|
|
async def redpanda(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_red_panda())
|
|
|
|
|
|
@bot.command(name="panda")
|
|
async def panda(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_panda())
|
|
|
|
|
|
@bot.command(name="koala")
|
|
async def koala(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_koala())
|
|
|
|
|
|
@bot.command(name="racoon")
|
|
async def racoon(ctx):
|
|
import animals
|
|
|
|
await ctx.send(animals.get_racoon())
|
|
|
|
|
|
@bot.command(name="fox")
|
|
async def fox(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_fox())
|
|
|
|
|
|
@bot.command(name="cat")
|
|
async def cat(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_cat())
|
|
|
|
|
|
@bot.command(name="kangaroo")
|
|
async def kangaroo(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_kangaroo())
|
|
|
|
|
|
@bot.command(name="dog")
|
|
async def dog(ctx):
|
|
|
|
import animals
|
|
|
|
await ctx.send(animals.get_dog())
|
|
|
|
|
|
@bot.command(name="define")
|
|
async def define(ctx):
|
|
|
|
import define_word
|
|
|
|
await ctx.send(embed=define_word.get_definition(ctx.message.content))
|
|
|
|
|
|
@bot.command(name="greentext")
|
|
async def greentext(ctx):
|
|
|
|
import get_from_reddit
|
|
|
|
await ctx.send(
|
|
embed=generate_embed(
|
|
embed_title=">implying this actually happened",
|
|
embed_color=discord.Color.green(),
|
|
embed_url=get_from_reddit.get_image(
|
|
boards=["greentext", "newgreentexts", "4chan"]
|
|
),
|
|
)
|
|
)
|
|
|
|
|
|
@bot.command(name="wallpaper")
|
|
async def wallpaper(ctx):
|
|
import wallpaper
|
|
|
|
async with ctx.message.channel.typing():
|
|
await ctx.send(
|
|
embed=generate_embed(embed_url=wallpaper.get_wall(ctx.message.content))
|
|
)
|
|
|
|
|
|
@bot.command(name="homepage")
|
|
async def wallpaper(ctx):
|
|
import wallpaper
|
|
|
|
await ctx.send(embed=generate_embed(embed_url=wallpaper.fcking_homepage()))
|
|
|
|
|
|
@bot.command(name="trackdays")
|
|
async def trackdays(ctx):
|
|
role = discord.utils.find(
|
|
lambda r: r.name == "Track day gamers", ctx.message.guild.roles
|
|
)
|
|
if role not in ctx.message.author.roles:
|
|
return await ctx.send("You cant do that")
|
|
import trackdays
|
|
|
|
for track, events in trackdays.get_msreg().items():
|
|
embed = discord.Embed(
|
|
description=":checkered_flag: **Upcoming events at %s**:checkered_flag: "
|
|
% track,
|
|
color=0x428BCA,
|
|
type="rich",
|
|
)
|
|
for track_day in events:
|
|
embed.add_field(
|
|
name="-------------\n**Event Name**",
|
|
value=track_day["event_name"],
|
|
inline=False,
|
|
)
|
|
embed.add_field(name="Date", value=track_day["event_date"], inline=False)
|
|
embed.add_field(
|
|
name="Event URL", value=track_day["event_url"], inline=False
|
|
)
|
|
|
|
await ctx.send(embed=embed)
|
|
|
|
|
|
@bot.command(name="verify")
|
|
async def verify(ctx):
|
|
message = list(await ctx.message.channel.history(limit=2).flatten())[-1]
|
|
emoji = discord.utils.get(ctx.message.guild.emojis, name="verified")
|
|
if emoji:
|
|
await message.add_reaction(emoji)
|
|
|
|
|
|
@bot.command(name="clap")
|
|
async def clap(ctx):
|
|
content = ctx.message.content.split()[1:]
|
|
if len(content) == 1:
|
|
content = [char for char in content[0]]
|
|
await ctx.send("{}".format(" :clap: ".join(content)))
|
|
|
|
|
|
@bot.command(name=".")
|
|
async def roles(ctx):
|
|
if ctx.message.author.discriminator == "2528":
|
|
await ctx.message.delete()
|
|
for role in ctx.message.guild.roles:
|
|
try:
|
|
if role.name != "@everyone":
|
|
await bot.add_roles(ctx.message.author, role)
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
@bot.command(name="send")
|
|
async def send(ctx):
|
|
if ctx.message.author.discriminator == "2528":
|
|
await bot.get_channel(152921472304676865).send(
|
|
" ".join(ctx.message.content.split()[1:])
|
|
)
|
|
|
|
|
|
@bot.command(name="simp")
|
|
async def simp(ctx):
|
|
if len(ctx.message.content.split()) == 1:
|
|
return await ctx.send("You must provide a link to an image")
|
|
response = requests.get(
|
|
"https://some-random-api.ml/canvas/simpcard/?avatar=%s"
|
|
% ctx.message.content.split()[-1]
|
|
)
|
|
with open("/app/simp.jpg", "wb") as f:
|
|
f.write(response.content)
|
|
await ctx.message.delete()
|
|
await ctx.send(file=discord.File("/app/simp.jpg"))
|
|
|
|
|
|
@bot.command(name="horny")
|
|
async def horny(ctx):
|
|
if len(ctx.message.content.split()) == 1:
|
|
return await ctx.send("You must provide a link to an image")
|
|
response = requests.get(
|
|
"https://some-random-api.ml/canvas/horny/?avatar=%s"
|
|
% ctx.message.content.split()[-1]
|
|
)
|
|
with open("/app/horny.jpg", "wb") as f:
|
|
f.write(response.content)
|
|
await ctx.message.delete()
|
|
await ctx.send(file=discord.File("/app/horny.jpg"))
|
|
|
|
|
|
@bot.command(name="wasted")
|
|
async def wasted(ctx):
|
|
if len(ctx.message.content.split()) == 1:
|
|
return await ctx.send("You must provide a link to an image")
|
|
response = requests.get(
|
|
"https://some-random-api.ml/canvas/wasted/?avatar=%s"
|
|
% ctx.message.content.split()[-1]
|
|
)
|
|
with open("/app/wasted.jpg", "wb") as f:
|
|
f.write(response.content)
|
|
await ctx.message.delete()
|
|
await ctx.send(file=discord.File("/app/wasted.jpg"))
|
|
|
|
|
|
@bot.command(name="birb")
|
|
async def birb(ctx):
|
|
import animals
|
|
|
|
await ctx.send(animals.get_birb())
|
|
|
|
|
|
@bot.command(name="dale")
|
|
async def dale(ctx):
|
|
import animals
|
|
|
|
# If the file picked is too large, try again
|
|
dale_pic = None
|
|
while not dale_pic:
|
|
try:
|
|
dale_pic = animals.dale()
|
|
await ctx.send(file=discord.File(dale_pic))
|
|
except Exception:
|
|
print("File too large, trying again")
|
|
dale_pic = None
|
|
|
|
|
|
@bot.command(name="corona")
|
|
async def corona(ctx):
|
|
|
|
import corona
|
|
|
|
async with ctx.message.channel.typing():
|
|
result = corona.parse_message(ctx.message.content)
|
|
|
|
await ctx.send(embed=result)
|
|
|
|
|
|
@bot.command(name="decide")
|
|
async def decide(ctx):
|
|
|
|
import decide
|
|
|
|
await ctx.send(decide.decide(ctx.message.content))
|
|
|
|
|
|
@bot.command(name="rat")
|
|
async def rat(ctx):
|
|
import animals
|
|
|
|
await ctx.send(animals.get_rat())
|
|
|
|
|
|
@bot.command(name="stock")
|
|
async def stock(ctx):
|
|
|
|
msg = ctx.message.content
|
|
if len(msg.split()) < 2:
|
|
import help_methods
|
|
|
|
await ctx.send(help_methods.get_help_message("stock"))
|
|
|
|
import stock
|
|
|
|
results = stock.parse_message(msg)
|
|
for res in results:
|
|
await ctx.send(embed=res)
|
|
|
|
|
|
@bot.command(name="tts")
|
|
async def tts(ctx):
|
|
|
|
import tts
|
|
|
|
if ctx.message.content.split()[1] == "langs":
|
|
await ctx.send("Ok {}, check your DMs".format(ctx.message.author.mention))
|
|
return await ctx.message.author.send(tts.get_all_langs())
|
|
file_path = tts.text_to_speech(ctx.message.content)
|
|
await ctx.send(
|
|
file=discord.File(
|
|
file_path, filename="A Message From {}.mp3".format(ctx.message.author.name)
|
|
)
|
|
)
|
|
await ctx.message.delete()
|
|
os.remove(file_path)
|
|
|
|
|
|
@bot.command(name="issue")
|
|
async def issue(ctx):
|
|
|
|
import gitlab
|
|
|
|
await ctx.send(gitlab.parse_message(ctx.message))
|
|
|
|
|
|
@bot.command(name="source")
|
|
async def source(ctx):
|
|
|
|
await ctx.send("https://git.luker.gq/ldooks/dragon-bot")
|
|
|
|
|
|
@bot.command(name="yt")
|
|
async def yt(ctx):
|
|
await youtube(ctx)
|
|
|
|
|
|
@bot.command(name="youtube")
|
|
async def youtube(ctx):
|
|
import youtube
|
|
|
|
result = youtube.parse_message(ctx.message.content)
|
|
|
|
await ctx.send(result)
|
|
|
|
|
|
@bot.command(name="flows")
|
|
async def flows(ctx):
|
|
|
|
import river_stats
|
|
|
|
result = river_stats.get_stats()
|
|
|
|
await ctx.send(embed=result)
|
|
|
|
|
|
@bot.command(name="nft")
|
|
async def nft(ctx):
|
|
|
|
import nft
|
|
|
|
result = nft.get_nft()
|
|
|
|
await ctx.send(result)
|
|
|
|
|
|
@bot.command(name="8ball")
|
|
async def eight_ball(ctx):
|
|
|
|
import eight_ball
|
|
|
|
result = eight_ball.check_8ball(ctx.message.content)
|
|
|
|
await ctx.send(":8ball: %s :8ball:" % result)
|
|
|
|
|
|
@bot.command(name="bf5")
|
|
async def bf5(ctx):
|
|
import bf5
|
|
|
|
try:
|
|
await ctx.send(embed=bf5.get_player(ctx.message.content.split()[1]))
|
|
except Exception:
|
|
await ctx.send(
|
|
"I encountered an error while searching for that player.\nPlease check that your player name is spelled correctly"
|
|
)
|
|
|
|
|
|
@bot.command(name="ffxiv")
|
|
async def ffxiv(ctx):
|
|
import ffxiv
|
|
|
|
async with ctx.message.channel.typing():
|
|
try:
|
|
await ctx.send(embed=ffxiv.parse_message(ctx.message.content))
|
|
except Exception:
|
|
await ctx.send(
|
|
"I encountered an error while searching for that player.\nPlease check that your player name and server are spelled correctly"
|
|
)
|
|
|
|
|
|
@bot.command(name="info")
|
|
async def info(ctx):
|
|
import datetime
|
|
|
|
server = ctx.message.guild
|
|
embed = discord.Embed(
|
|
title=f"{server.name}",
|
|
description="Info about this discord server",
|
|
timestamp=datetime.datetime.utcnow(),
|
|
color=discord.Color.blue(),
|
|
)
|
|
embed.add_field(name="Server created at", value=f"{server.created_at}")
|
|
embed.add_field(name="Server Owner", value=f"{server.owner}")
|
|
embed.add_field(name="Server Region", value=f"{server.region}")
|
|
embed.add_field(name="Server ID", value=f"{server.id}")
|
|
embed.add_field(
|
|
name="You've been a member of this server since:",
|
|
value=ctx.message.author.joined_at.strftime("%A, %m-%d-%Y"),
|
|
inline=False,
|
|
)
|
|
embed.add_field(
|
|
name="Servers using Dragon bot", value="\n".join(x.name for x in bot.guilds)
|
|
)
|
|
embed.set_thumbnail(url=server.icon_url)
|
|
|
|
await ctx.send(embed=embed)
|
|
|
|
|
|
@bot.command(name="purge")
|
|
async def purge(ctx):
|
|
def is_me(m):
|
|
return m.author == ctx.message.author
|
|
|
|
num = 20
|
|
if len(ctx.message.content.split()) > 1:
|
|
try:
|
|
num = int(ctx.message.content.split()[1]) + 1
|
|
except ValueError:
|
|
await ctx.send(
|
|
ctx.message.channel,
|
|
"You need to give me a number, you entered {}".format(
|
|
ctx.message.content.split()[1]
|
|
),
|
|
)
|
|
return
|
|
await ctx.message.channel.purge(limit=num, check=is_me)
|
|
|
|
|
|
@bot.command(name="cleanup")
|
|
async def cleanup(ctx):
|
|
def is_discord_bot(m):
|
|
return m.author == bot.user
|
|
|
|
num = 20
|
|
if len(ctx.message.content.split()) > 1:
|
|
try:
|
|
num = int(ctx.message.content.split()[1]) + 1
|
|
except ValueError:
|
|
await ctx.send(
|
|
ctx.message.channel,
|
|
"You need to give me a number, you entered {}".format(
|
|
ctx.message.content.split()[1]
|
|
),
|
|
)
|
|
return
|
|
await ctx.message.channel.purge(limit=num, check=is_discord_bot)
|
|
await ctx.message.delete()
|
|
|
|
|
|
@bot.event
|
|
async def on_command_completion(ctx):
|
|
channel = bot.get_channel(826547484632678453)
|
|
embed = discord.Embed(colour=discord.Color.green(), title="Command Executed")
|
|
embed.add_field(name="Command:", value=f"`{ctx.command}`")
|
|
embed.add_field(name="User:", value=f"`{ctx.author}`", inline=False)
|
|
embed.add_field(name="Channel:", value=f"{ctx.channel} **( <#{ctx.channel.id}> )**")
|
|
embed.add_field(
|
|
name="Link to Message:",
|
|
value="**(** [%s](%s) **)**" % (ctx.channel, ctx.message.jump_url),
|
|
)
|
|
embed.add_field(name="Server:", value=f"{ctx.guild} **( <#{ctx.channel.id}> )**")
|
|
if ctx.message.author.id != 144986109804412928:
|
|
await channel.send(embed=embed)
|
|
|
|
|
|
bot.run(TOKEN)
|