async def admin_log(self,
ctx: Context,
enabled: bool,
channel: TextChannel = None):
"""Enable/disable to-channel logging and set the log channel.
MUST HAVE SERVER ADMINISTRATOR PERMISSION
"""
sid = str(ctx.guild.id)
# Initialize the server in the database if required
if sid not in db:
db[sid] = {}
# Set the config values based on user input (or lack thereof for log channel)
db[sid]["log"] = enabled
if channel is not None:
db[sid]["log_channel"] = str(channel.id)
else:
if "log_channel" not in db[sid]:
db[sid]["log_channel"] = str(ctx.message.channel.id)
channel = ctx.message.channel
update_db(sql_db, db, "admin")
embed = Embed(title="Log Settings", color=0xff0000)
embed.add_field(name="Enabled", value=str(enabled))
embed.add_field(name="Log Channel", value=channel.mention)
await ctx.send(embed=embed)
async def unmute(self, ctx: Context, target: Member):
"""Unmute a member early.
Level 4 required
"""
sid = str(ctx.guild.id)
uid = str(target.id)
mute_role = None
# Try to get the mute role from the server
try:
mute_role = ctx.guild.get_role(int(db[sid]["mute_role"]))
except KeyError:
await ctx.send(":anger: This server has no mute role set.")
return
if sid not in mute_db:
await ctx.send(":anger: This server has no mutes.")
return
if uid not in mute_db[sid]:
await ctx.send(":anger: This member is not muted.")
return
await target.send(
f":speaking_head: You have been unmuted in {ctx.guild.name}.")
await ctx.send(f":speaking_head: Unmuted {target.name}.")
# Remove the mute role and delete the entry from the database
await target.remove_roles(mute_role)
del mute_db[sid][uid]
update_db(sql_db, mute_db, "mutes")
async def role_add(self, ctx, *, role_name: Role):
"""Add an assignable role."""
s_id = ctx.message.server.id
if s_id not in roles:
roles[s_id] = []
roles[s_id].append(role_name.name)
update_db(roles, "roles")
await self.bot.say("\U00002705")
async def account_remove(self, uid: str):
"""Remove an acconut."""
if uid not in accounts:
await self.bot.say(f"\U00002754 No account with ID {uid} exists.")
return
del accounts[uid]
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def account_update(self, uid: str, level: int):
"""Change an account's level."""
if uid not in accounts:
await self.bot.say(f"\U00002754 No accounts with ID {uid} exists.")
return
accounts[uid]["level"] = level
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def account_update(self, uid: str, level: int):
"""Change an account's level."""
if uid not in accounts:
await self.bot.say(f"\U00002754 No accounts with ID {uid} exists.")
return
accounts[uid]["level"] = level
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def account_remove(self, uid: str):
"""Remove an acconut."""
if uid not in accounts:
await self.bot.say(f"\U00002754 No account with ID {uid} exists.")
return
del accounts[uid]
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def role_add(self, ctx, *, role_name: Role):
"""Add an assignable role."""
s_id = ctx.message.server.id
if s_id not in roles:
roles[s_id] = []
roles[s_id].append(role_name.name)
update_db(roles, "roles")
await self.bot.say("\U00002705")
async def account_add(self, uid: str, level: int):
"""Add an account."""
if uid in accounts:
await self.bot.say("\U00002754 Account already exists.")
return
accounts[uid] = {}
accounts[uid]["level"] = level
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def account_add(self, uid: str, level: int):
"""Add an account."""
if uid in accounts:
await self.bot.say("\U00002754 Account already exists.")
return
accounts[uid] = {}
accounts[uid]["level"] = level
update_db(accounts, "accounts")
await self.bot.say("\U00002705")
async def admin_set(self, ctx):
"""Set the logging channel for admin commands.
The channel this command is invoked in will become the channel that all
bot administration actions (kicks, bans, softbans, and unbans) are logged
to.
"""
admin["servers"][ctx.message.server.id] = ctx.message.channel.id
update_db(admin, "admin")
await self.bot.say("\U00002705")
async def role_remove(self, ctx, *, role_name: Role):
"""Remove an assignable role."""
s_id = ctx.message.server.id
if s_id not in roles:
await self.bot.say("\U00002757 This server has no assignable roles.")
return
roles[s_id].remove(role_name.name)
if len(roles[s_id]) == 0:
del roles[s_id]
update_db(roles, "roles")
await self.bot.say("\U00002705")
async def role_remove(self, ctx, *, role_name: Role):
"""Remove an assignable role."""
s_id = ctx.message.server.id
if s_id not in roles:
await self.bot.say(
"\U00002757 This server has no assignable roles.")
return
roles[s_id].remove(role_name.name)
if len(roles[s_id]) == 0:
del roles[s_id]
update_db(roles, "roles")
await self.bot.say("\U00002705")
async def groups_create(self, ctx: Context, name: str, *,
description: str):
"""Create a group for you and your friends!
Name must NOT include spaces!
"""
sid = str(ctx.guild.id)
if sid not in db:
db[sid] = {}
# Try to make a role, text, and voice channel for the group
try:
role = await ctx.guild.create_role(name=name, reason=GP)
# Set overwrites for the category
ow = {
ctx.guild.default_role:
PermissionOverwrite(read_messages=False),
role: PermissionOverwrite(read_messages=True)
}
category = await ctx.guild.create_category(name=name,
reason=GP,
overwrites=ow)
text = await ctx.guild.create_text_channel(name=name.lower(),
reason=GP,
category=category,
topic=description)
voice = await ctx.guild.create_voice_channel(name=name,
reason=GP,
category=category)
db[sid] = {
name: {
"info": {
"description": description,
"category": str(category.id),
"text_channel": str(text.id),
"voice_channel": str(voice.id),
"role": str(role.id)
}
}
}
update_db(sql_db, db, "servers")
await ctx.author.add_roles(role, reason="Group created.")
except Exception as e:
await ctx.send(f":anger: Something went wrong: `{e}`")
return
await ctx.send(":white_check_mark: Group created!")
await text.send(
f"Welcome to your group {ctx.author.mention}! Try the `group invite` command!"
)
async def mute(self, ctx: Context, target: Member, length: int, span: str,
*, reason: str):
"""Set a member to the mute role.
For timing, plural and non-plural spans are accepted (Day, days, minutes, etc).
Use "max" as the span for psuedo-permanence (10 years).
Level 4 required
"""
sid = str(ctx.guild.id)
uid = str(target.id)
mute_role = None
# Try to get the mute role from the server
try:
mute_role = ctx.guild.get_role(int(db[sid]["mute_role"]))
except KeyError:
await ctx.send(":anger: Server has no mute role set.")
return
# Initialize the server in the mute database if required
if sid not in mute_db:
mute_db[sid] = {}
# Get the current UTC time, a future time from time_parser, and the difference
now = datetime.now(tz=timezone.utc)
future = await time_parser(span, length, now)
length = future - now
time = pretty_timedelta(length)
embed = await embed_builder("Muted", target, reason, length)
await target.send(embed=embed)
await ctx.send(
f":white_check_mark: {target.name} muted for {reason}, expires in {time}"
)
# Set the user to the muted role
await target.add_roles(mute_role)
# Add the mute to the database
mute = {
"issued_by": str(ctx.author.id),
"reason": reason,
"expires": str(future.timestamp())
}
mute_db[sid][uid] = mute
update_db(sql_db, mute_db, "mutes")
await self.log_to_channel(ctx, target, reason)
async def admin_role(self, ctx: Context, role: Role):
"""Set the mute role for the server.
MUST HAVE SERVER ADMINISTRATOR PERMISSION
"""
sid = str(ctx.guild.id)
# Initialize the server in the database if required
if sid not in db:
db[sid] = {}
# Set the mute role
db[sid]["mute_role"] = str(role.id)
update_db(sql_db, db, "admin")
await ctx.send(f":white_check_mark: Mute role set to: {role.name}.")
async def clear_channels(bot, location = None):
for chan in groups["channels"][:]:
channel = bot.get_channel(chan)
if len(channel.voice_members) == 0:
try:
await bot.delete_channel(channel)
await asyncio.sleep(0.25)
except:
if location is None:
continue
await bot.send_message(location,
f"\U00002757 Unable to delete channel {channel.name}")
finally:
groups["channels"].remove(chan)
if location is None:
return
update_db(groups, "groups")
async def warn(self, ctx: Context, target: Member, length: int, span: str,
*, reason: str):
"""Warn a member.
For timing, plural and non-plural spans are accepted (Day, days, minutes, etc).
Use "max" as the span for psuedo-permanence (10 years).
Level 4 required
"""
sid = str(ctx.guild.id)
uid = str(target.id)
warn_count = 1
# Initialize the server in the warn database if required
if sid not in warn_db:
warn_db[sid] = {}
# Add 1 to the amount of warns the user may already have
if uid in warn_db[sid]:
for _ in warn_db[sid][uid]:
warn_count += 1
# Get the current UTC time, a future time from time_parser, and the difference
now = datetime.now(tz=timezone.utc)
future = await time_parser(span, length, now)
length = future - now
embed = await embed_builder("Warned", target, reason, length)
await target.send(embed=embed)
await target.send(f":warning: This is warning #{warn_count}.")
await ctx.send(
f":warning: Warning {warn_count} issued to {target.name} for {reason}"
)
# Add the warn to the database
if uid not in warn_db[sid]:
warn_db[sid][uid] = {}
warning = {
"issued_by": str(ctx.author.id),
"reason": reason,
"expires": str(future.timestamp())
}
warn_db[sid][uid][str(warn_count)] = warning
update_db(sql_db, warn_db, "warns")
await self.log_to_channel(ctx, target, reason)
async def group_create(self, ctx, *, name: str = None):
"""Create a group channel.
If a name is passed as an argument the channel will be set to that name
with the prefix and suffix added. Otherwise the user's discriminator will
be used as the channel name.
"""
if name is None:
name = ctx.message.author.discriminator
name = f"{self.prefix}{name}{self.suffix}"
try:
channel = await self.bot.create_channel(ctx.message.server, name,
type=ChannelType.voice)
await self.bot.say("\U00002705 Channel created.")
groups["channels"].append(channel.id)
update_db(groups, "groups")
except:
await self.bot.say("\U00002757")
async def clear_channels(bot, location=None):
for chan in groups["channels"][:]:
channel = bot.get_channel(chan)
if len(channel.voice_members) == 0:
try:
await bot.delete_channel(channel)
await asyncio.sleep(0.25)
except:
if location is None:
continue
await bot.send_message(
location,
f"\U00002757 Unable to delete channel {channel.name}")
finally:
groups["channels"].remove(chan)
if location is None:
return
update_db(groups, "groups")
async def group_create(self, ctx, *, name: str = None):
"""Create a group channel.
If a name is passed as an argument the channel will be set to that name
with the prefix and suffix added. Otherwise the user's discriminator will
be used as the channel name.
"""
if name is None:
name = ctx.message.author.discriminator
name = f"{self.prefix}{name}{self.suffix}"
try:
channel = await self.bot.create_channel(ctx.message.server,
name,
type=ChannelType.voice)
await self.bot.say("\U00002705 Channel created.")
groups["channels"].append(channel.id)
update_db(groups, "groups")
except:
await self.bot.say("\U00002757")
async def warn_check(bot: commands.Bot):
ts = datetime.now(tz=timezone.utc).timestamp()
# No servers registered
if len(warn_db) <= 0:
return
for sid in warn_db:
# No warns in the server
if len(warn_db[sid]) <= 0:
continue
guild = bot.get_guild(int(sid))
# Each warn in the server
for uid in warn_db[sid]:
for i, w in warn_db[sid][uid].items():
if ts >= float(w["expires"]):
del warn_db[sid][uid][i]
update_db(sql_db, warn_db, "warns")
print(f"[ADMIN][WARN][REMOVE] {uid}.{i} in <{guild.name}>")
async def role_remove(self, ctx: Context, *, role_get: Role):
"""Remove a role from the assignable roles list.
Level 10 required
"""
sid = str(ctx.guild.id)
if sid not in db:
await ctx.send(":anger: There are no assignable roles on this server.")
return
if role_get.name not in db[sid]:
await ctx.send(":anger: That is not an assignable role on this server.")
else:
try:
del db[sid][role_get.name]
await ctx.send(
f":white_check_mark: Removed {role_get.name} from assignable roles."
)
update_db(sql_db, db, "servers")
except Exception as e:
await ctx.send(f":anger: Error removing role: {e}")
async def role_add(self, ctx: Context, role_get: Role, *,
description: str):
"""Add/update a role on the assignable roles list.
Level 10 required
"""
sid = str(ctx.guild.id)
rid = str(role_get.id)
name = role_get.name
if sid not in db:
db[sid] = {}
try:
role_info = {"id": rid, "description": description}
db[sid][name] = role_info
await ctx.send(
f":white_check_mark: Added {name} to assignable roles.")
update_db(sql_db, db, "servers")
except Exception as e:
await ctx.send(f":anger: Error adding role: {e}")
async def mute_check(bot: commands.Bot):
ts = datetime.now(tz=timezone.utc).timestamp()
# No servers registered
if len(mute_db) <= 0:
return
for sid in mute_db:
# No mutes in this server
if len(mute_db[sid]) <= 0:
continue
# Each mute in the server
for uid, info in mute_db[sid].items():
if ts >= float(info["expires"]):
guild = bot.get_guild(int(sid))
# Get the mute role
try:
role = guild.get_role(int(db[sid]["mute_role"]))
# Delete the mute from the database if we're unable to get the mute role
except KeyError:
del mute_db[sid][uid]
break
# Else get the member and remove the mute role
target = guild.get_member(int(uid))
if role in target.roles:
await target.remove_roles(role, reason="Auto mute remove.")
await target.send(
f":speaking_head: Your mute in {guild.name} has expired.")
else:
del mute_db[sid][uid]
break
del mute_db[sid][uid]
update_db(sql_db, mute_db, "mutes")
print(f"[ADMIN][MUTE][REMOVE] {target.id} in <{guild.name}>")
async def tempban(self,
ctx: Context,
target: Member,
length: int,
span: str,
*,
reason: str = None):
"""Temporarily ban a member from the server.
For timing, plural and non-plural spans are accepted (Day, days, minutes, etc).
Use "max" as the span for psuedo-permanence (10 years).
Level 8 required
"""
sid = str(ctx.guild.id)
# Initialize the server in the tempban database if required
if sid not in tempban_db:
tempban_db[sid] = {}
# Get the current UTC time, a future time from time_parser, and the difference
now = datetime.now(tz=timezone.utc)
future = await time_parser(span, length, now)
length = future - now
embed = await embed_builder("Temporarily Banned", target, reason,
length)
await target.send(embed=embed)
await target.ban(reason=reason, delete_message_days=0)
# Add the tempban to the database
tempban_db[sid][target.id] = {
"issued_by": str(ctx.author.id),
"reason": reason,
"expires": str(future.timestamp())
}
update_db(sql_db, tempban_db, "temp_bans")
await self.log_to_channel(ctx, target, reason)
async def tempban_check(bot: commands.Bot):
ts = datetime.now(tz=timezone.utc).timestamp()
# No servers registered
if len(tempban_db) <= 0:
return
for sid in tempban_db:
# No tempbans in this server
if len(tempban_db[sid]) <= 0:
continue
# Each tempban in the server
for uid in tempban_db[sid]:
info = tempban_db[sid][uid]
if ts >= float(info["expires"]):
guild = bot.get_guild(int(sid))
await guild.unban(bot.get_user(uid))
del tempban_db[sid][uid]
update_db(sql_db, tempban_db, "temp_bans")
print(
f"[ADMIN][TEMPBAN][REMOVE] {target.id} in <{guild.name}>")
