async def ask(self, ctx, member: discord.Member):
user: User = UserDB.get_one(ctx.author.id)
lover: User = UserDB.get_one(member.id)
def check(m):
return m.author == member and m.channel == ctx.channel
if user.married:
em = await Embeds.already_married(ctx.author)
await ctx.send(embed=em)
elif lover.married:
em = await Embeds.is_married(member)
await ctx.send(embed=em)
else:
em = await Embeds.ask_to_marry(ctx.author, member)
await ctx.send(embed=em)
try:
message = await self.bot.wait_for('message',
check=check,
timeout=300)
except asyncio.TimeoutError:
await ctx.send(
"{}, you did not answer quickly enough, if it is an error, repeat the procedure."
.format(member.name),
delete_after=5)
else:
if message.content.lower() == "yes":
UserDB.set_lover(ctx.author.id, member.id)
em = await Embeds.said_yes(ctx.author, member)
await ctx.send(embed=em)
else:
em = await Embeds.said_no(ctx.author, member)
await ctx.send(embed=em)
async def divorce(self, ctx):
user: User = UserDB.get_one(ctx.author.id)
if not user.married:
em = await Embeds.is_not_married(ctx.author)
await ctx.send(embed=em)
else:
UserDB.unset_lover(ctx.author.id, user.lover)
lover: discord.User = self.bot.get_user(user.lover)
if not lover:
return await ctx.send("You're now divorced !")
em = await Embeds.divorce(ctx.author, lover)
await ctx.send(embed=em)
async def update_names(self, ctx):
for guild in self.bot.guilds:
G = GuildDB.get_one(guild_id=guild.id)
GuildDB.update_name(guild.id, guild.name)
if guild.id in [
488765635439099914, 631811291568144384, 618414922556112916,
740622438282428416
]:
for user in guild.members:
if not user.bot:
U = UserDB.get_one(user.id)
UserDB.update_name(
user.id, "{}#{}".format(user.name.lower(),
user.discriminator))
async def on_member_join(self, member):
"""
:param member: The member who joined the guild
"""
guild = GuildDB.get_one(member.guild.id)
user = UserDB.get_one(member.id)
# Check if the user has already been muted to avoid any sanctions bypass
if UserDB.is_muted(guild, user):
# Mute him again
role = discord.utils.get(member.guild.roles, name="Muted")
if not role:
role = await member.guild.create_role(
name="Muted",
permissions=discord.Permissions.none(),
reason="Mute Role")
for chan in member.guild.text_channels:
await chan.set_permissions(role, send_messages=False)
await member.add_roles(role)
# Check if the user is in the blacklist
if BlacklistDB.is_blacklist(user):
if GuildDB.has_blacklist(guild):
# Ban the member
await member.guild.ban(member, reason="Blacklist")
try:
await member.send(
"you're in the blacklist ! If you think it's an error, ask here --> "
"*****@*****.**")
except discord.Forbidden:
return
if GuildDB.has_logging(guild):
sanctions, time = await Checks().member_check(member)
em = await Mod().check_embed(member, member.guild, sanctions, time)
if guild.log_chan:
channel = self.bot.get_channel(int(guild.log_chan))
if isinstance(channel, discord.TextChannel):
try:
await channel.send(embed=em)
except discord.Forbidden:
return
async def on_vip_message(message):
user = UserDB.get_one(message.author.id)
if not user.user_name or "{}#{}".format(
message.author.name.lower(),
message.author.discriminator) != user.user_name.lower():
UserDB.update_name(
message.author.id,
"{}#{}".format(message.author.name.lower(),
message.author.discriminator))
dt = message.created_at
time = str(dt.year) + ("0" + str(dt.month) if dt.month < 10 else str(
dt.month)) + ("0" + str(dt.day) if dt.day < 10 else str(dt.day))
m = Message(guild_id=message.guild.id,
message_id=message.id,
user_id=message.author.id,
channel_id=message.channel.id,
time_id=int(time))
MessageDB.insert_message(m)
async def get(self, ctx, member: discord.Member = None):
if not member:
member: discord.Member = ctx.author
user: User = UserDB.get_one(member.id)
if user.married:
lover: discord.User = self.bot.get_user(int(user.lover))
if lover:
em = await Embeds.get_lover(member, lover)
await ctx.send(embed=em)
else:
em = await Embeds.is_married(member)
await ctx.send(embed=em)
else:
em = await Embeds.is_not_married(member)
await ctx.send(embed=em)
async def rank(self, ctx, user: discord.Member = None):
if user is None:
user = ctx.message.author
userY = UserDB.get_one(user.id)
guildY = GuildDB.get_one(ctx.message.guild.id)
rankings = RankingsDB.get_user(userY, guildY)
if not rankings:
RankingsDB.create_ranking(userY, guildY)
rankings = RankingsDB.get_user(user, guildY)
rank = RankingsDB.get_rank(userY, guildY)
em = discord.Embed()
em.set_author(name=user.name, icon_url=user.avatar_url)
em.add_field(name="**Rank**", value=f"{rank}", inline=False)
em.add_field(name="**Level**", value=rankings["level"])
em.add_field(name="**Progress**",
value="{} / {}".format(rankings['xp'], rankings['reach']))
await ctx.send(embed=em)
async def leaderboard(self, ctx):
guildY = GuildDB.get_one(ctx.message.guild.id)
scoreboard = RankingsDB.get_scoreboard(guildY)
em = discord.Embed(description="ScoreBoard",
color=discord.Colour.magenta())
x = 0
for user in scoreboard:
member = discord.utils.get(ctx.guild.members, id=int(user))
userY = UserDB.get_one(user)
member_ranking = RankingsDB.get_user(userY, guildY)
if member is None:
RankingsDB.reset_user(userY, guildY)
else:
x += 1
level = member_ranking['level']
total = member_ranking['total']
em.add_field(name=f"**{x} - {member.name}**",
value=f"Level : {level} \nTotal xp : {total}",
inline=False)
await ctx.send(embed=em)
async def unmute(self, ctx, user: discord.Member, auto: bool = False):
if not auto:
mod = ctx.message.author
else:
mod = "auto"
role = discord.utils.get(ctx.guild.roles, name="Muted")
guild = ctx.message.guild
guildY = GuildDB.get_one(guild.id)
userY = UserDB.get_one(user.id)
if not MuteDB.is_muted(userY, guildY) or not role:
return
MuteDB.unset_mute(userY, guildY)
try:
await user.remove_roles(role)
except discord.HTTPException:
return
em = await Embeds().format_mod_embed(ctx, user, mod, None, 'unmute')
await self.log_send(ctx, ctx.message.guild.id, em)
async def remove(self, ctx, id: int):
await ctx.message.delete()
user = UserDB.get_one(id)
UserDB.unset_vip(id)
await ctx.send(f"{id} has been remove from VIP")
async def add(self, ctx, id: int):
await ctx.message.delete()
user = UserDB.get_one(id)
UserDB.set_vip(id)
await ctx.send(f"{id} is now VIP")
async def is_vip_check(ctx):
vips = UserDB.get_vips()
if str(ctx.message.author.id) in vips:
return True
else:
return False
async def on_message(self, message: discord.Message):
"""
:param message: The message that has been sent
"""
user = message.author
if user.bot is True or message.guild is None:
return
if message.guild.id == '264445053596991498':
return
bucket = self._cd.get_bucket(message)
retry_after = bucket.update_rate_limit()
if retry_after:
return
userY = UserDB.get_one(user.id)
guildY = GuildDB.get_one(message.guild.id)
rankings = RankingsDB.get_user(userY, guildY)
if not rankings:
RankingsDB.create_ranking(userY, guildY)
rankings = RankingsDB.get_user(userY, guildY)
if rankings['level'] < 3:
gain = randint(2, 12)
elif 3 <= rankings['level'] < 6:
gain = randint(8, 20)
elif 6 <= rankings['level'] < 10:
gain = randint(12, 20)
elif 10 <= rankings['level'] < 20:
gain = randint(12, 22)
else:
gain = randint(15, 25)
rankings['xp'] += gain
rankings['total'] += gain
if rankings['xp'] >= rankings['reach']:
rankings['level'] += 1
if rankings["level"] > 39:
rankings['reach'] = round(rankings['reach'] * 1.02)
if 39 >= rankings["level"] > 21:
rankings['reach'] = round(rankings['reach'] * 1.05)
elif 21 >= rankings["level"] > 10:
rankings['reach'] = round(rankings['reach'] * 1.1)
elif 10 >= rankings["level"] > 6:
rankings['reach'] = round(rankings['reach'] * 1.3)
else:
rankings['reach'] = round(rankings['reach'] * 1.6)
rankings['xp'] = 0
try:
await message.channel.send("{} is now level {}.".format(
user.name, rankings['level']),
delete_after=2)
except discord.HTTPException:
pass
RankingsDB.update_user(userY, guildY, rankings)
row = RoleDB.get_one_from_level(rankings['level'], guildY)
if row:
try:
role = discord.utils.get(message.guild.roles,
id=int(row["role_id"]))
await user.add_roles(role)
except discord.HTTPException:
pass
RankingsDB.update_user(userY, guildY, rankings)
async def mute(self,
ctx,
user: discord.Member,
duration: str,
*,
reason: ModReason = None):
"""
:param ctx: Command context
:param user: The member to mute
:param duration: The duration of the mute
:param reason: the reason of the mute
"""
perm = await Check().check(ctx, user)
if perm is False:
return
guild = ctx.message.guild
guildY = GuildDB.get_one(guild.id)
userY = UserDB.get_one(user.id)
unit = duration[-1]
if unit == 's':
time = int(duration[:-1])
elif unit == 'm':
time = int(duration[:-1]) * 60
elif unit == 'h':
time = int(duration[:-1]) * 3600
elif unit == 'd':
time = int(duration[:-1]) * 86400
else:
return await ctx.send('Invalid Unit! Use `s`, `m`, `h` or `d`.')
if MuteDB.is_muted(userY, guildY):
return await ctx.send('This user is already muted, you should '
'unmute him first.')
role = discord.utils.get(ctx.guild.roles, name="Muted")
if not role:
role = await ctx.guild.create_role(
name="Muted",
permissions=discord.Permissions.none(),
reason="Mute Role")
for chan in ctx.guild.text_channels:
await chan.set_permissions(role, send_messages=False)
await user.add_roles(role)
MuteDB.set_mute(userY, guildY)
id = await SanctionMethod().create_sanction(user, 'Mute',
ctx.message.author, guild,
reason, time)
em = await Embeds().format_mod_embed(ctx, user, ctx.message.author,
reason, 'mute', id, duration)
await self.log_send(ctx, ctx.message.guild.id, em)
await asyncio.sleep(time)
if MuteDB.is_muted(userY, guildY):
await ctx.invoke(self.unmute, user, True)
async def on_user_update(self, before, after):
if before.name != after.name:
name = "{}#{}".format(after.name.lower(), after.discriminator)
UserDB.update_name(after.id, name)