async def on_message(self, message):
if message.author == self.bot.user:
return # Ignore messages sent by the bpt
if isinstance(message.channel, DMChannel):
return # Ignore Private DMs
message_content = message.content
toxicity = predict_toxicity(
message_content) # Predict the toxicity of the message
if toxicity == 0:
return
await message.delete() # Delete the message
await message.channel.send(embed=embedded.info(
REMOVAL_MESSAGE.format(username=message.author.mention)))
await message.author.create_dm()
# Warn the author
await message.author.dm_channel.send(
embed=embedded.info(PERSONAL_MESSAGE_AFTER_REMOVAL))
USER_ID = str(message.author.id)
SERVER_ID = str(message.guild.id)
SERVER_OWNER_ID = str(message.guild.owner_id)
if USER_ID == SERVER_OWNER_ID:
return # Do not add to database if user is the bot owner
try:
toxic_bot_adder.addToxicCount(SERVER_ID,
USER_ID) # Add to the database
except AttributeError: # If an attribute error is thrown, kick out the author
await message.guild.kick(message.author,
reason="Toxic Message Limit Exceeded")
async def on_member_join(self, member):
channel = member.guild.system_channel
if channel is not None:
await channel.send(embed=embedded.info(
WELCOME_MESSAGE.format(member, member.guild)))
if channel is None:
await member.create_dm()
await member.dm_channel.send(embed=embedded.info(
WELCOME_DM_MESSAGE.format(member, member.guild)))
async def on_guild_join(self, guild):
server_config = ServerConfig()
SERVER_ID = str(guild.id)
SERVER_OWNER_ID = str(guild.owner_id)
# Create the configurations for the server
server_config.createServerConfig(SERVER_ID, SERVER_OWNER_ID)
# Doesn't work as it returns None always ( BUG )
owner = self.bot.get_user(int(SERVER_OWNER_ID))
if owner is None:
# Send a message to the general channel
general = find(lambda x: x.name == "general", guild.text_channels)
if general and general.permissions_for(guild.me).send_messages:
await general.send(
embed=embedded.info(ADMIN_MESSAGE_AFTER_BOT_JOIN))
else:
await owner.create_dm()
await owner.dm_channel.send(
embed=embedded.info(ADMIN_MESSAGE_AFTER_BOT_JOIN))
async def askSpecificServer(
self,
ctx,
server_config,
):
def check(m):
return m.author == ctx.author and m.channel == ctx.channel
member = ctx.author
records = server_config.getAllServers(str(
member.id)) # Get a list of servers where user is admin
servers = []
for record in records:
guild = self.bot.get_guild(int(record[0]))
if guild is not None:
guild_name = guild.name # Get the guild name from server id
servers.append(guild_name)
await ctx.send(embed=embedded.info(ADMIN_REQUEST_SERVER_ID))
embed = self.generate_embed("Servers", servers)
await ctx.send(
embed=embed
) # Send a multi-choice option to the user to select a specific server
message = None
try:
# Wait for 5 seconds for response
message = await self.bot.wait_for("message",
timeout=5.0,
check=check)
except asyncio.TimeoutError:
await ctx.send(embed=embedded.error(REQUEST_TIMEOUT)
) # Send a timeout message
return -1
index = None
try:
index = int(message.content) # Convert the string to number
except Exception:
# If non-numeric characters are passed
await ctx.send(embed=embedded.error(
REQUIRE_NUMERICAL_VALUE.format(entity="Server Number")))
return -1
if index > len(records): # Check if index is out of bounds
await ctx.send(embed=embedded.error(BAD_ARGUMENT))
return
return index, records
async def info(self, ctx):
member = ctx.author
await ctx.send(embed=embedded.info(INFO_MESSAGE.format(username=member.name)))