async def mute(message: discord.Message, parameters: str,
client: discord.Client) -> None:
member_reason = await util.split_into_member_and_reason(
message, parameters)
if member_reason == (None, None):
raise CommandSyntaxError('You must specify a valid user/duration.')
try:
time_reason = member_reason[1].split(maxsplit=1)
multiplier = configuration.TIME_MULTIPLIER[time_reason[0][-1]]
mute_time = int(time_reason[0][:-1]) * multiplier
except:
raise CommandSyntaxError('You must specify a valid duration.')
# Give mute
try:
await member_reason[0].add_roles(
message.guild.get_role(configuration.MUTED_ROLE))
except discord.errors.Forbidden:
await message.channel.send("I don't have perms to give mute role")
return
roles = member_reason[0].roles
# Remove @everyone role
roles = roles[1:]
try:
database_handle.cursor.execute(
'''INSERT INTO MUTES (ID, TIMESTAMP, ROLES) \
VALUES(:member_id, :timestamp, :roles) ''', {
'member_id': member_reason[0].id,
'timestamp': round(time()) + mute_time,
'roles': str([role.id for role in roles])
})
except sqlite3.IntegrityError:
await message.channel.send('User is already muted')
return
database_handle.client.commit()
# Remove all roles
forbidden_role_list = []
for role in roles:
if role.id != configuration.MUTED_ROLE:
try:
await member_reason[0].remove_roles(role)
except discord.errors.Forbidden:
forbidden_role_list.append(role)
if forbidden_role_list:
await message.channel.send(
f"Unable to remove roles: {forbidden_role_list}")
await warn(message,
f'{member_reason[0].id} MUTE - {member_reason[1]}',
client,
action_name="muted")
await asyncio.sleep(mute_time)
await unmute(message, str(member_reason[0].id), client, silenced=True)
async def hug(message: discord.Message, parameters: str, client: discord.Client) -> None:
# Make sure someone was specified
if parameters == "":
raise CommandSyntaxError("You must specify someone to hug.")
# Get users
hugger = message.author.mention
target = parameters
if str(message.author.id) in target:
#reply message should be a pun
reply = util.choose_random(configuration.STRINGS_PUN).format(hugger=hugger)
else:
# Get a random message and fill it in
choice = util.choose_random(configuration.STRINGS_HUG)
reply = choice.format(hugger=hugger, target=target)
# Make a fancy embed so people don't complain about getting pinged twice
R, G, B = 256 * 256, 256, 1
embed = discord.Embed(
description=reply,
colour=(46*R + 204*G + 113*B)
)
# Done
await message.channel.send(embed=embed)
if str(client.user.id) in target:
await message.channel.send('Thanks for hugging me; I love that!')
async def kick(message: discord.Message, parameters: str,
client: discord.Client) -> None:
member_reason = await util.split_into_member_and_reason(
message, parameters)
if member_reason[0] is None:
raise CommandSyntaxError('You must specify a valid user.')
if not message.guild.me.guild_permissions.kick_members:
await message.channel.send("I don't have permissions to kick.")
return
if message.guild.me.top_role <= member_reason[0].top_role:
await message.channel.send("I am not high enough in the role hierarchy"
)
return
# if message.author.top_role <= member_reason[0].top_role:
# await message.channel.send("You are not high enough in the role hierarchy.")
# return
await warn(message,
f"{member_reason[0].id} KICK - {member_reason[1]}",
client,
action_name="kicked")
await message.guild.kick(member_reason[0], reason=member_reason[1])
async def warn(message: discord.Message,
parameters: str,
client: discord.Client,
action_name="warned") -> None:
member_reason = await util.split_into_member_and_reason(
message, parameters)
if member_reason[0] == None:
raise CommandSyntaxError('You must specify a valid user.')
database_handle.cursor.execute(
'''INSERT INTO WARNS (ID, REASON, TIMESTAMP) \
VALUES(:member_id, :reason, :time)''', {
'member_id': member_reason[0].id,
'reason': str(member_reason[1]),
'time': round(time())
})
database_handle.client.commit()
# Send a message to the channel that the command was used in
warn_embed = discord.Embed(title=action_name.title(),
description=member_reason[0].mention) \
.add_field(name="Reason", value=member_reason[1])
await message.channel.send(embed=warn_embed)
await logger.log_moderation(message, warn_embed, client)
try:
# DM user
await member_reason[0].send(
content=f"You have been **{action_name}** in {message.guild.name}!",
embed=warn_embed)
except Exception:
await message.channel.send("Unable to DM user")
async def delwarn(message: discord.Message, parameters: str,
client: discord.Client) -> None:
member_reason = await util.split_into_member_and_reason(
message, parameters)
if member_reason == (None, None):
raise CommandSyntaxError('You must specify a valid user')
warn = database_handle.cursor.execute(
'''SELECT REASON FROM WARNS WHERE TIMESTAMP=:timestamp AND ID=:id''', {
"timestamp": member_reason[1],
"id": member_reason[0].id
}).fetchone()
if warn is not None:
await message.channel.send(
f"Deleting warn from {member_reason[0].name}#{member_reason[0].discriminator} ({member_reason[0].id}) about {warn[0]}"
)
else:
await message.channel.send("No warn found")
return
database_handle.cursor.execute(
'''DELETE FROM WARNS WHERE TIMESTAMP=:timestamp AND ID=:id''', {
"timestamp": member_reason[1],
"id": member_reason[0].id
})
database_handle.client.commit()
async def pad(message: discord.Message, parameters: str, client: discord.Client) -> None:
"""Spaces out your text"""
if parameters == "":
raise CommandSyntaxError("You must specify text to space out.")
elif len(parameters) > 1000:
await message.channel.send("Message must not surpass 1000 characters")
else:
await message.channel.send(" ".join(parameters))
async def _mimic(message, parameters, client):
member_command = await util.split_into_member_and_reason(
message, parameters)
if member_command == (None, None):
raise CommandSyntaxError('You must specify a valid user')
new_message = copy.copy(message)
new_message.author = member_command[0]
new_message.content = configuration.PREFIX + member_command[1]
await client.on_message(new_message)
async def warns(message: discord.Message, parameters: str,
client: discord.Client) -> None:
member = util.get_member_by_id_or_name(message, parameters)
if member is None:
user_id = util.try_get_valid_user_id(parameters)
if not user_id:
raise CommandSyntaxError("You must specify a valid user!")
else:
user_id = member.id
def warn_embed_generator(page: int, total_pages: int):
warn_list = database_handle.cursor.execute(
'''SELECT REASON, TIMESTAMP FROM WARNS WHERE ID = :member_id LIMIT 10 OFFSET :offset''',
{
'member_id': user_id,
"offset": page * 10
}).fetchall()
warn_text = timestamp_text = ''
for warn in warn_list:
warn_text += f"{warn[0]}\n"
timestamp_text += f"<t:{warn[1]}:d> <t:{warn[1]}:T>\n"
return discord.Embed(title=f"Warns. Total of {total_warns}", description=f"<@{user_id}>") \
.add_field(name="Reason", value=warn_text) \
.add_field(name="Timestamp", value=timestamp_text) \
.set_footer(text=f"Page: {page+1}/{total_pages+1}")
total_warns = database_handle.cursor.execute(
'''SELECT COUNT(*) FROM WARNS WHERE ID=:member_id''', {
"member_id": user_id
}).fetchone()[0]
if total_warns == 0:
await message.channel.send("User has no warns.")
elif total_warns <= 10:
await message.channel.send(embed=warn_embed_generator(0, 0))
else:
response = await message.channel.send(embed=discord.Embed(
title="Loading"))
reaction_handler = util.ReactionPageHandle(client, response,
message.author,
warn_embed_generator, 0,
(total_warns - 1) // 10)
await reaction_handler.start()
async def rank(message: discord.Message, parameters: str,
client: discord.Client) -> None:
if parameters != "":
member = util.get_member_by_id_or_name(message, parameters)
if member is None:
raise CommandSyntaxError('You must specify a valid user.')
else:
member = message.author
user_xp = database_handle.cursor.execute(
'''SELECT XP, LEVEL FROM LEVELS WHERE ID=:user_id''', {
'user_id': member.id
}).fetchone()
if user_xp is None:
await message.channel.send("The user isn't ranked yet.")
return
user_rank = database_handle.cursor.execute(
'''SELECT COUNT(*)+1 FROM LEVELS WHERE XP > :user_xp''', {
'user_xp': user_xp[0]
}).fetchone()
avatar = member.avatar_url_as(format=None, static_format='png', size=1024)
ranks = dict(
filter(lambda elem: user_xp[1] < elem[1][1],
configuration.LEVEL_ROLES.items()))
if len(ranks) > 0:
rank = list(ranks.items())[-1][1]
next_rank = f"<@&{rank[0]}> | Level: {str(rank[1])}"
else:
next_rank = "Maximum rank reached."
rank_embed = discord.Embed(description=f"Rank for <@{member.id}>") \
.add_field(name="Total XP:", value=user_xp[0]) \
.add_field(name="Level:", value=(user_xp[1])) \
.add_field(name="Rank:", value="#" + str(user_rank[0])) \
.add_field(name="XP until level up:", value=levels.xp_needed_for_level(user_xp[1] + 1) - user_xp[0]) \
.add_field(name="Next rank:", value=next_rank) \
.set_author(name=f"{member.name}#{member.discriminator}", icon_url=avatar.__str__())
await message.channel.send(embed=rank_embed)
async def ban(message: discord.Message, parameters: str,
client: discord.Client) -> None:
member_reason = await util.split_into_member_and_reason(
message, parameters)
if member_reason[0] is None:
raise CommandSyntaxError('You must specify a valid user.')
if not message.guild.me.guild_permissions.ban_members:
await message.channel.send("I don't have permissions to ban.")
return
if message.guild.me.top_role <= member_reason[0].top_role:
await message.channel.send(
"I am not high enough in the role hierarchy.")
return
# if message.author.top_role <= member_reason[0].top_role:
# await message.channel.send("You are not high enough in the role hierarchy.")
# return
if message.guild.me.guild_permissions.manage_guild:
invites = await message.guild.invites()
for invite in invites:
if invite.inviter == member_reason[0]:
await invite.delete()
else:
await message.channel.send(
"I need the `manage_guild` permission to view and delete their invites."
)
await warn(message,
f"{member_reason[0].id} BAN - {member_reason[1]}",
client,
action_name="banned")
await message.guild.ban(member_reason[0],
reason=member_reason[1],
delete_message_days=0)
async def unmute(message: discord.Message,
parameters: str,
client: discord.Client,
guild=False,
silenced=False) -> None:
"""
Unmutes member
Params:
message: discord.message/guild object
parameters: Parameters
guild: if the message parameter is a guild object"""
if guild:
member = message.get_member(int(parameters))
else:
member = util.get_member_by_id_or_name(message, parameters)
if member is None:
user_id = util.try_get_valid_user_id(parameters)
if not user_id:
raise CommandSyntaxError("You must specify a valid user!")
else:
user_id = member.id
roles = database_handle.cursor.execute(
'''SELECT ROLES FROM MUTES WHERE ID=:member_id''', {
'member_id': user_id
}).fetchone()
database_handle.cursor.execute('''DELETE FROM MUTES WHERE ID=:member_id''',
{'member_id': user_id})
database_handle.client.commit()
if roles is None:
# If it's an empty array, they're in the database, elif None, they're not
await message.channel.send("User is not muted")
return
if not member:
# No need to re give roles or anything, they left
if not silenced:
await message.channel.send(f"Unmuted {user_id}")
return
# Re give roles
roles = literal_eval(roles[0])
forbidden_roles_list = []
for role in roles:
if guild:
role = message.get_role(role)
else:
role = message.guild.get_role(role)
try:
await member.add_roles(role)
except:
forbidden_roles_list.append(role)
if not silenced and forbidden_roles_list:
await message.channel.send(
f"Unable to re-give roles: {forbidden_roles_list}")
# Remove muted role
if guild:
await member.remove_roles(message.get_role(configuration.MUTED_ROLE))
else:
await member.remove_roles(
message.guild.get_role(configuration.MUTED_ROLE))
# Inform user we're done
if not silenced:
await message.channel.send(
f'Unmuted {member.name}#{member.discriminator} ({member.id})')