async def avatar(self, ctx, *, person: discord.User = None):
"""Get someone's avatar."""
if person is None:
person = ctx.author
url = person.avatar_url_as(static_format='png')
await ctx.send(url)
async def robohash(self,ctx,user:discord.User):
"""Robot pics."""
if not user.nick == None:
user = user.nick
else:
user = user.name
await self.bot.say("https://robohash.org/{}.png".format(user.replace(" ","%20")))
async def rip(self,ctx,user:discord.User):
"""RIP."""
if not user.nick == None:
user = user.nick
else:
user = user.name
await self.bot.say("<http://ripme.xyz/{}>".format(user.replace(" ","%20")))
async def on_member_unban(self, guild: Guild, member: User):
if guild.id != GuildConstant.id:
return
if member.id in self._ignored[Event.member_unban]:
self._ignored[Event.member_unban].remove(member.id)
return
await self.send_log_message(
Icons.user_unban,
Colour.blurple(),
"User unbanned",
f"{member.name}#{member.discriminator} (`{member.id}`)",
thumbnail=member.avatar_url_as(static_format="png"),
channel_id=Channels.modlog)
async def info(self, ctx, user: discord.User = None):
"""Gets information about a Discord user."""
if user is None:
user = ctx.author
shared = str(len([i for i in ctx.bot.guilds if i.get_member(user.id)]))
em = discord.Embed(title=f'Information for {user.display_name}:')
em.add_field(name='Name:', value=user.name)
em.add_field(name='Discriminator:', value=user.discriminator)
em.add_field(name='ID:', value=user.id)
em.add_field(name='Bot:', value=user.bot)
em.add_field(name='Created At:', value=user.created_at)
em.add_field(name='Shared Servers:', value=shared)
em.add_field(name='Avatar URL:', value=user.avatar_url)
em.set_thumbnail(url=user.avatar_url_as(static_format='png'))
await ctx.send(embed=em)
async def create(cls, *, creator: discord.User, bot, session, duration):
creator_avatar = creator.avatar_url_as(format="png")
async with session.get(str(creator_avatar)) as avatar:
avatar = await avatar.read()
guild = await bot.create_guild(
name=f"{creator.name}'s {choice(ADJECTIVES)} party", icon=avatar)
await asyncio.sleep(2)
# refresh from cache
guild = bot.get_guild(guild.id)
return cls(bot, creator, guild, duration)
async def on_member_unban(self, guild: discord.Guild, member: discord.User) -> None:
"""Log member unban event to mod log."""
if guild.id != GuildConstant.id:
return
if member.id in self._ignored[Event.member_unban]:
self._ignored[Event.member_unban].remove(member.id)
return
member_str = escape_markdown(str(member))
await self.send_log_message(
Icons.user_unban, Colour.blurple(),
"User unbanned", f"{member_str} (`{member.id}`)",
thumbnail=member.avatar_url_as(static_format="png"),
channel_id=Channels.mod_log
)
async def triggered(self, ctx, member: discord.User = None):
"""Make your or someone else's avatar triggered."""
if "dagpi_token" not in self.bot.config:
return
if not member:
member = ctx.author
url = "https://api.dagpi.xyz/image/triggered/?url=" + str(
member.avatar_url_as(format="png", size=1024))
async with self.bot.session.get(url=url,
headers={
"Authorization":
self.bot.config["dagpi_token"]
}) as res:
image = io.BytesIO(await res.read())
img = discord.File(fp=image, filename="triggered.gif")
await ctx.send(file=img)
async def level(self, ctx, user: discord.User = None):
if not user: user = ctx.author
db = leveldb(user.id)
profile = db.get()
return await ctx.send(embed=discord.Embed(
title=f"{user.name} | Level Info",
description=dedent(f"""◽ **Level ➜** {profile['level']}
◽ **Experience ➜** {profile['xp']}
◽ **Needed ➜** {profile['level']*3-profile['xp']}
*Check out the **[Dashboard]({files.Data('config').yaml_read()['dashURL']})** for all the global leaderboard!*"""
),
color=discord.Color.red()).set_thumbnail(url=user.avatar_url_as(
static_format="png")))
async def avatar_static(self,
ctx: cmd.Context,
*,
user: discord.User = None):
"""Gives the URL to a user's non-animated avatar"""
if not user:
user = ctx.author
url = str(user.avatar_url_as(format="png", size=4096))
embed = discord.Embed(title=f"Avatar URL for @{user}", description=url)
embed.set_image(url=url)
embed.set_footer(text=f"ID: {user.id}")
await ctx.prompt(embed=embed)
async def stat(self, ctx, *, user: discord.User = None):
if not user:
user = ctx.author
with open("data/cookie.json", "r") as f:
l = json.load(f)
cookies = l[str(user.id)]
emb = discord.Embed(description = f"**{cookies}** Cookies 🍪!", colour = 0xa8603d)
emb.set_author(name = user.name, icon_url = user.avatar_url_as(static_format="png"))
await ctx.send(embed = emb)
async def user_info(self, ctx, user: discord.User = None):
"""Returns information about the given user"""
if not user:
user = ctx.message.author
member = ctx.message.guild.get_member(user.id)
em = discord.Embed(colour=discord.Colour.gold())
inlineFields = [{
"name": "ID",
"value": member.id
}, {
"name": "Nickname",
"value": member.nick if not None else "None"
}, {
"name": "Status",
"value": member.status
}, {
"name": member.activity.state,
"value": member.activity.name
} if member.activity else {
"name": "Activity",
"value": "None"
}, {
"name": "Mention",
"value": member.mention
}]
for field in inlineFields:
em.add_field(**field, inline=True)
avatar = user.avatar_url_as(
size=64) # if not None else discord.Embed.Empty
registeredAt = pytz.utc.localize(member.created_at)
joinedAt = pytz.utc.localize(member.joined_at)
em.add_field(
name="Joined",
value=
f"{human(joinedAt, precision=4)} ({joinedAt.strftime('%d-%m-%Y %H:%M:%s %Z')})"
)
em.add_field(name="Roles",
value=", ".join([role.name for role in member.roles
]).replace("@everyone",
"@\u200beveryone"))
em.set_author(name=member.name, icon_url=avatar)
em.set_thumbnail(url=avatar)
em.set_footer(
text=
f"Created: {human(registeredAt, precision=4)} ({registeredAt.strftime('%d-%m-%Y %H:%M:%s %Z')})"
)
await ctx.send(embed=em)
async def enable_command(self, server_id, command, user_id=None):
log.debug(f'enabling {command} command for server {server_id}')
plugin_name = self._plugin_for_cmd(command)
if not plugin_name:
return False
if not self.mbot.perms_check(User(id=user_id), su=True):
# Skip Core plugin.
if plugin_name == 'Core':
return False
# Skip 'su' commands if not superuser
if self.commands[command][2].info['perms'][0]:
return False
doc = await self.mbot.mongo.config.find_one({
'server_id': server_id,
'plugins': {
'$elemMatch': {
'name': plugin_name
}
}
})
commands = await self.commands_for_server(server_id)
# Command is already enabled.
if command in commands:
return False
if doc is not None:
ret = await self.mbot.mongo.config.update_one(
{
'server_id': server_id,
'plugins': {
'$elemMatch': {
'name': plugin_name
}
}
}, {'$push': {
'plugins.$.commands': command
}})
return bool(ret)
async def dmhistory(self, ctx: utils.TypedContext, user: discord.User, amount: int = 10):
messages: list[str] = []
async for message in user.history(limit=amount):
if message.embeds:
if message.embeds[0].author:
messages.append(f"`{message.embeds[0].author.name} ⚙️`: {message.embeds[0].description}")
else:
messages.append(f"`{message.author} ⚙️`: {message.embeds[0].description}")
else:
messages.append(f"`{message.author}`: {message.content}")
messages.reverse()
embed = discord.Embed(
title=f"Message history of {user.name}",
description="\n".join(messages)
)
await ctx.send(embed=embed)
async def kick(self, ctx, user: discord.User, *, reason: str = None):
admin = ctx.author
if user == admin:
await ctx.send("You can't unban yourself.")
return
await ctx.guild.kick(
user,
reason=
f"Kicked by {longform_username(admin)}: {reason if reason else 'No reason specified'}"
)
embed = discord.Embed(
title=f"Kicked",
description=
f"{longform_username(user)} kicked by {longform_username(admin)}: {reason if reason else 'No reason specified'}"
)
embed.set_author(name=longform_username(user),
icon_url=user.avatar_url_as(format="png"))
await ctx.send(embed=embed)
def __init__(self, data: Dict[str, Any], state: ConnectionState) -> None:
self._state = state
self.responded = False
self.id = int(data["id"])
self.application_id = int(data["application_id"])
self.type = InteractionType(int(data["type"]))
self.guild_id = int(data["guild_id"]) if "guild_id" in data else None
self.channel_id = int(
data["channel_id"]) if "channel_id" in data else None
self.member = (InteractionMember(
data=data["member"], state=state, guild=self.guild)
if "member" else None)
self.user = (
User(data=data["user"], state=self._state)
if "user" in data else None # type: ignore
)
self.token = data["token"]
self.version = int(data["version"])
async def avatar(self, ctx, user: discord.User = None):
""" Displays what avatar user is using """
user = user or ctx.author
Zenpa = self.bot.get_user(373863656607318018)
if user is self.bot.user:
embed = discord.Embed(color=self.bot.embed_color,
title=f'{self.bot.user}\'s Profile Picture!')
embed.set_image(url=self.bot.user.avatar_url_as(static_format='png'))
embed.set_footer(text=f'Huge thanks to {Zenpa} for this avatar')
await ctx.send(embed=embed)
else:
embed = discord.Embed(color=self.bot.embed_color,
title=f'{user}\'s Profile Picture!')
embed.set_image(url=user.avatar_url_as(static_format='png'))
# embed.set_footer(text=f'© {self.bot.user}')
await ctx.send(embed=embed)
async def avatar(self, ctx: SlashContext, user: discord.User = None):
'''
Displays the avatar of a target user, or yourself by default
Made by Slyflare, PhtephenLuu
'''
if not user:
user = ctx.author
# col = user.colour if type(user) == discord.Member \
# else discord.Color.dark_blue() TODO
col = discord.Color.dark_blue()
a = discord.Embed(color=col,
title=f"{user.display_name}'s Avatar",
url=str(user.avatar_url_as(static_format="png")))
a.set_image(url=user.avatar_url)
await ctx.send(embed=a)
async def avatar(self, ctx, *, user: discord.User = None):
"""
Returns a mentioned users avatar
Example:
{command_prefix}avatar @RoxBot#4170
{command_prefix}avatar RoxBot
"""
if not user:
user = ctx.author
url = user.avatar_url_as(static_format="png")
if url.split(".")[-1] == "gif":
avaimg = '{0.name}.gif'.format(user)
else:
avaimg = '{0.name}.png'.format(user)
await roxbot.http.download_file(url, avaimg)
await ctx.send(file=discord.File(avaimg))
os.remove(avaimg)
async def annoy_reminder(ctx, user: User, reminder: str):
counter = 0
print("Reminding user: "******"User: "******" has responded to the reminders")
await user.send("Quota satisfied, committing sepuku")
await user.send(file=File('bonk.wav'))
return
await user.send(
"Oi remember to " + reminder + "!\n" +
"This will repeat every minute until I detect three or more messages from you!\n"
"(I will check every minute)")
await asyncio.sleep(60)
async def inventory(self, ctx, u: discord.User = None):
if u is None:
u = ctx.author
if u.bot:
await self.send(ctx, "Remember, bots don't have any rights, and as a result can't possess currency.")
return
pick = await self.db.get_pickaxe(u.id)
contents = f"**{pick} pickaxe**\n"
bal = await self.db.get_balance(u.id)
if not bal <= 0:
s = "s"
if bal == 1:
s = ""
contents += f"{bal} emerald{s}{self.emerald}\n"
inv = discord.Embed(color=discord.Color.green(), description=contents)
contents = ""
i = 0
rows = 10
items = await self.db.get_items(u.id)
for item in items:
i += 1
m = await self.db.get_item(u.id, item[0])
contents += f"{m[1]}x **{m[0]}** ({m[2]}{self.emerald})\n"
if i % rows == 0:
if i <= rows:
inv.add_field(name="Sellable Items", value=contents, inline=False)
else:
inv.add_field(name="More Sellable Items", value=contents, inline=False)
contents = ""
if contents is not "":
if i <= rows:
inv.add_field(name="Sellable Items", value=contents, inline=False)
else:
inv.add_field(name="More Sellable Items", value=contents, inline=False)
if not u.avatar_url:
inv.set_author(name=f"{u.display_name}'s Inventory", url=discord.Embed.Empty)
else:
inv.set_author(name=f"{u.display_name}'s Inventory", icon_url=str(u.avatar_url_as(static_format="png")))
await ctx.send(embed=inv)
async def userinfo(self, ctx, user: discord.User = None):
temp = ''
if user is None:
await ctx.send('Please provide a user to get info')
return
temp = ((f'- User\'s ID: {user.id}\n') +
(f'- User\'s discrim: {user.discriminator}\n') +
('- Is User a bot?: '))
temp = temp + ('YES' if user.bot else 'NO')
embed = discord.Embed(title='Userinfo',
description=f'misc. info about {user.name}',
colour=discord.Colour.blue())
embed.add_field(name=user, value=temp)
if user.avatar is not None:
embed.set_thumbnail(url=user.avatar_url_as(size=64))
await ctx.send(':mag:', embed=embed)
async def post_modlog_entry(self, guild_id: int, action: str, target: discord.User, moderator: discord.User,
reason: str, time: str='', color=0xbe2f2f):
config = await self.bot.db.get_config(guild_id)
log = interaction.get_channel(self.bot, config['logChannel'])
if log:
permissions = log.permissions_for(log.guild.me)
if permissions.send_messages and permissions.embed_links:
embed = discord.Embed(color=color,
title=f'**User {action}**',
description=f'**Target:** {target} ({target.id})\n'
f'**Reason:** {reason}',
timestamp=datetime.utcnow())
embed.set_footer(text=f'Performed by {moderator}', icon_url=moderator.avatar_url_as(format='png'))
if time:
embed.description += f'\n**Duration:** {time}'
await log.send(embed=embed)
async def unban(self, ctx, *, member: discord.User = None):
if member == None:
embed = discord.Embed(color=0xc80afc,
title="Unban Error",
description="Please mention a user to unban")
await ctx.send(embed=embed, delete_after=5.0)
else:
banned_users = await ctx.guild.bans()
member_name, member_discriminator = member.split('#')
for ban_entry in banned_users:
user = ban_entry.user
if (user.name, user.discriminator) == (member.name,
member.discriminator):
embed = discord.Embed(
color=0x62ff00,
title="Unban",
description=f"{user.mention} has been unbanned")
await ctx.guild.unban(user)
await ctx.send(embed=embed, delete_after=2.0)
def from_payload(payload):
"""Creates a Message from a Payload by extracting relevant items.
Args:
payload: A MESSAGE_CREATE payload.
Returns:
A message.
"""
data = payload.data
return Message(content=data["content"],
channel_id=data["channel_id"],
author_id=data["author"]["id"],
username=data["author"]["username"] + "#" +
data["author"]["discriminator"],
timestamp=data["timestamp"],
mentions=[
User.from_json(user_data)
for user_data in data["mentions"]
])
async def balance(self, ctx, *, user: discord.User = None):
"""Shows the balance of a user or the message sender"""
if user is None:
user = ctx.author
if user.bot:
if user.id == self.bot.user.id:
await self.bot.send(ctx, ctx.l.econ.bal.bot_1)
else:
await self.bot.send(ctx, ctx.l.econ.bal.bot_2)
return
db_user = await self.db.fetch_user(user.id)
u_items = await self.db.fetch_items(user.id)
vault_bal = db_user['vault_bal']
total_wealth = db_user['emeralds'] + (
(0 if vault_bal is None else vault_bal) * 9)
total_wealth += sum(
[u_it['sell_price'] * u_it.get('amount', 0) for u_it in u_items])
embed = discord.Embed(color=self.d.cc)
embed.set_author(name=ctx.l.econ.bal.s_emeralds.format(
user.display_name),
icon_url=user.avatar_url_as())
embed.description = ctx.l.econ.bal.total_wealth.format(
total_wealth, self.d.emojis.emerald)
embed.add_field(name=ctx.l.econ.bal.pocket,
value=f'{db_user["emeralds"]}{self.d.emojis.emerald}')
embed.add_field(
name=ctx.l.econ.bal.vault,
value=
f'{db_user["vault_bal"]}{self.d.emojis.emerald_block}/{db_user["vault_max"]}'
)
await ctx.send(embed=embed)
async def userinfo(self, ctx, user: discord.User = None):
'''Gets info about a user.'''
async with ctx.typing():
if user is None:
user = ctx.author
e = discord.Embed(color=0x43b2c2)
username = f'{user.name}#{user.discriminator}'
join_date = user.created_at
e.set_image(url=user.avatar_url)
e.add_field(name='Name', value=username)
e.add_field(name='Account Created', value=join_date)
if ctx.guild:
join_guild_date = ctx.guild.get_member(user.id).joined_at
e.add_field(name='Joined Guild',
value=join_guild_date,
inline=False)
e.add_field(name='ID', value=user.id, inline=False)
e.add_field(name='Bot Account', value=user.bot)
e.add_field(name='Animated Avatar',
value=user.is_avatar_animated())
await ctx.send(embed=e)
async def wait_for_button_click(self,
message: Message,
check=None,
timeout: float = None):
while True:
res = await self.bot.wait_for("socket_response",
check=check,
timeout=timeout)
if res["t"] != "INTERACTION_CREATE":
continue
if message.id != int(res["d"]["message"]["id"]):
continue
break
button_id = res["d"]["data"]["custom_id"]
resbutton = None
for buttons in res["d"]["message"]["components"]:
for button in buttons["components"]:
if button["style"] == 5:
continue
if button["custom_id"] == button_id:
resbutton = button
ctx = Context(
bot=self.bot,
client=self,
user=User(state=self.bot._get_state(),
data=res["d"]["member"]["user"]),
button=Button(
style=resbutton["style"],
label=resbutton["label"],
id=resbutton["custom_id"],
),
raw_data=res,
message=message,
)
return ctx
async def dmhistory(self, ctx, user: discord.User, amount=10):
messages = []
async for message in user.history(limit=amount):
if message.embeds:
if message.embeds[0].author:
messages.append(
f"``{message.embeds[0].author.name}⚙️``:{message.embeds[0].description}"
)
else:
messages.append(
f"``{message.author}⚙️``:{message.embeds[0].description}"
)
else:
messages.append(f"``{message.author}``:{message.content}")
tosend = ""
messages.reverse()
for message in messages:
tosend += f"\n{message}"
embed = discord.Embed(title=f"Message history of {user.name}",
description=tosend)
await ctx.send(embed=embed)
async def inventory(self, ctx, u: discord.User):
pick = await self.db.getPick(u.id)
contents = pick + " pickaxe\n"
bal = await self.db.getBal(u.id)
if bal == 1:
contents += "1x emerald\n"
else:
contents += str(bal) + "x emeralds\n"
beecount = await self.db.getBees(u.id)
if beecount > 1:
contents += str(beecount) + "x jars of bees (" + str(
beecount * 3) + " bees)\n"
if beecount == 1:
contents += str(beecount) + "x jar of bees (" + str(
beecount * 3) + " bees)\n"
netheritescrapcount = await self.db.getScrap(u.id)
if netheritescrapcount > 1:
contents += str(
netheritescrapcount) + "x chunks of netherite scrap\n"
if netheritescrapcount == 1:
contents += str(
netheritescrapcount) + "x chunk of netherite scrap\n"
items = await self.db.getItems(u.id)
for item in items:
m = await self.db.getItem(u.id, item[0])
contents += f"{m[1]}x {m[0]} (sells for {m[2]}<:emerald:653729877698150405>)\n"
inv = discord.Embed(color=discord.Color.green(), description=contents)
if not u.avatar_url:
inv.set_author(name=f"{u.display_name}'s Inventory",
url=discord.Embed.Empty)
else:
inv.set_author(name=f"{u.display_name}'s Inventory",
icon_url=str(u.avatar_url_as(static_format="png")))
await ctx.send(embed=inv)
async def head_pat(self,ctx,user: discord.User):
# profile_pic = user.avatar_url
profile_pic = user.avatar_url_as(format='png')
response = requests.get(profile_pic, stream = True)
if response.status_code == 200:
response.raw.decode_content = True
os.chdir('pet')
try:
os.remove('profile.png')
except:
pass
with open('profile.png', 'wb') as f:
shutil.copyfileobj(response.raw, f)
import pet.head_pats
pet.head_pats.main()
await ctx.send(file=discord.File('output.gif'))
os.chdir('..')
else:
await ctx.send("A ocurrido un error :cry:")
async def ban(ctx, member:discord.User, *, reason=None):
if ctx.message.author.permissions_in(ctx.channel).administrator:
if member != ctx.author:
if not member.permissions_in(ctx.channel).administrator:
if member is None:
await ctx.send('<a:redtick:712789179372798037> ***User not defined***')
return
else:
try:
await member.ban(reason=reason, delete_message_days = 0)
await ctx.send(f'<a:greentick:712789179595227256> {member.mention} ***has been banned***')
except:
await ctx.send (f'<a:redtick:712789179372798037> ***Invalid user***')
try:
await member.send(f'***You have been banned from {ctx.guild.name}.*** \n``Reason:``\n **{reason}**')
except:
await ctx.send ("<a:redtick:712789179372798037> **Unable to DM this user**")
else:
await ctx.send(f"<a:redtick:712789179372798037> ***Can't ban this user!***")
else:
await ctx.send(f"<a:redtick:712789179372798037> ***You can't ban yourself!***")
else:
await ctx.send('<a:redtick:712789179372798037> ***Missing Permissions***')
async def createdm(self, ctx, user: discord.User):
"""Create a DM with a user with the bot as a middle man. One user per mod channel.
[Format: %createdm (user id)]"""
try:
dm_channel = await ex.get_dm_channel(user=user)
if dm_channel:
user = await ex.get_user(user.id)
user.mod_mail_channel_id = ctx.channel.id
ex.cache.mod_mail[user.id] = ctx.channel.id # full list
await ex.conn.execute(
"INSERT INTO general.modmail(userid, channelid) VALUES ($1, $2)",
user.id, ctx.channel.id)
await dm_channel.send(
f"> {ctx.author.display_name} ({ctx.author.id}) has created a DM with you. All messages sent here will be sent to them."
)
await ctx.send(
f"> A DM has been created with {user.id}. All messages you type in this channel will be sent to the user."
)
else:
await ctx.send(
"> I was not able to create a DM with that user.")
except Exception as e:
await ctx.send(f"ERROR - {e}")
log.console(e)
async def au(self, ctx, user: discord.User = None, *, impostor: bool):
async with ctx.channel.typing():
uname = urllib.parse.quote(
(str(ctx.author) if not user else str(user)))
av = (ctx.author.avatar_url_as(format='png')
if not user else user.avatar_url_as(format='png'))
impostor = ('true' if impostor else 'false')
rand = random.randint(0, 10000)
async with aiohttp.ClientSession() as session:
url = f"https://some-random-api.ml/premium/amongus?avatar={av}&username={uname}&impostor={impostor}&key={self.bot.sra_api}"
async with session.get(url) as resp:
if resp.status == 200:
f = await aiofiles.open(f'data/amongus.{rand}.gif',
mode='wb')
await f.write(await resp.read())
await f.close()
else:
await ctx.reply(
f"There was an error with the api! ```json \n{await resp.json()}\n```"
)
return
file = discord.File(open(f'data/amongus.{rand}.gif', 'rb'))
await ctx.reply(file=file)
async def meme_user(self, ctx, user: discord.User, line1: URLString, line2: URLString):
"""Generates a meme on a users avatar."""
await ctx.invoke(self.meme_custom, link=user.avatar_url_as(format="png"), line1=line1, line2=line2)
