hammy
/
Enso-Bot
mirror of https://github.com/sgoudham/Enso-Bot.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Making the checks into functions to decrease repeated lines of code

Browse Source 
Moving starboard commands into here
Adding starboard status into the modstatus command
Making modmail/starboard into classes
pull/9/head
sgoudham 4 years ago
parent 986b65cbc1
commit 92bf0415b8
1 changed files with 319 additions and 487 deletions
Show Stats Download Patch File Download Diff File

618
cogs/guild.py
Unescape Escape View File

@ -14,151 +14,111 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
import asyncio
import datetime
import io
import random
import asyncpg
import discord
from discord import Embed, TextChannel
from discord import File
from discord.ext.commands import has_permissions, Cog, group, bot_has_permissions, BadArgument, MissingRequiredArgument, \
command
from cogs.libs.modmail import Modmail
from cogs.libs.starboard import Starboard
def anon_or_not(self, author):
"""Method to ask the user if they want to be anonymous or not"""
# Set up embed to let the user how to start sending modmail
AnonModMailEmbed = Embed(title="**Want to send it Anonymously?**",
colour=self.bot.admin_colour,
timestamp=datetime.datetime.utcnow())
AnonModMailEmbed.set_thumbnail(url=author.avatar_url)
AnonModMailEmbed.set_footer(text=f"Sent by {author}")
fields = [(self.bot.blank_space, "**We understand that for some things,"
"you may want to remain Anonymous."
"\nUse the reactions below to choose!**", False),
(self.bot.blank_space, "**Use :white_check_mark: for** `Yes`", True),
(self.bot.blank_space, "**Use :x: for** `No`", True),
(self.bot.blank_space, self.bot.blank_space, True),
(self.bot.blank_space,
"The Staff will not know who is sending this"
"\nPurely negative feedback will not be considered.", True)]
for name, value, inline in fields:
AnonModMailEmbed.add_field(name=name, value=value, inline=inline)
return AnonModMailEmbed
def send_instructions(self, author):
"""Method to send an embed to to let the user know to type into chat"""
SendModMailEmbed = Embed(title="**Please enter a message for it to be sent to the staff!**",
colour=self.bot.admin_colour,
timestamp=datetime.datetime.utcnow())
SendModMailEmbed.set_thumbnail(url=author.avatar_url)
SendModMailEmbed.set_footer(text=f"Sent by {author}")
fields = [("**Make sure that the message is above **50** and below **1024** characters!**",
"**Include as much detail as possible :P**",
False)]
for name, value, inline in fields:
SendModMailEmbed.add_field(name=name, value=value, inline=inline)
return SendModMailEmbed
async def get_starboard_from_db(self, ctx, action):
"""Get the starboard record from DB"""
def error_handling(self, author):
"""Method to let the user know that the message must be above 50 characters"""
ErrorHandlingEmbed = Embed(
title="Uh Oh! Please make sure the message is above **50** and below **1024** characters!",
colour=self.bot.admin_colour,
timestamp=datetime.datetime.utcnow())
ErrorHandlingEmbed.set_thumbnail(url=author.avatar_url)
ErrorHandlingEmbed.set_footer(text=f"Sent by {author}")
fields = [("Please enter in a message which is above **50** and below **1024** characters!",
"**This helps us reduce spam and allows you to include more detail in your mail!**",
False)]
for name, value, inline in fields:
ErrorHandlingEmbed.add_field(name=name, value=value, inline=inline)
return ErrorHandlingEmbed
def message_sent_confirmation(self, author):
"""Method to send an embed into chat to let the user know that their mail has been sent successfully"""
ConfirmationEmbed = Embed(title="**Message relayed to Staff!!**",
colour=self.bot.admin_colour,
timestamp=datetime.datetime.utcnow())
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
ConfirmationEmbed.set_thumbnail(url=author.avatar_url)
ConfirmationEmbed.set_footer(text=f"Sent by {author}")
# Get the row of the guild from the starboard table
try:
select_query = """SELECT * FROM starboard WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
fields = [("Thank you for your input! The staff team appreciate it very much!",
f"\n As mentioned previously, please don't be hesistant to DM the Staff for anything! :P",
False)]
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Starboard Record Could Not Be Retrieved For Starboard", e)
for name, value, inline in fields:
ConfirmationEmbed.add_field(name=name, value=value, inline=inline)
# Throw error if the guild already exists
else:
if action == "setup" and result:
text = "**Starboard** Already Setup!" \
f"\nDo **{ctx.prefix}help starboard** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
elif (action == "update" or action == "delete") and not result:
text = "**Starboard** Not Setup!" \
f"\nDo **{ctx.prefix}help starboard** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
return ConfirmationEmbed
return not None
def send_modmail(self, msg, author):
"""Method to actually allow the message to be sent to modmail logging channel"""
async def get_modlogs_from_db(self, ctx, action):
"""Get the starboard record from DB"""
embed = Embed(title="Modmail",
colour=self.bot.admin_colour,
timestamp=datetime.datetime.utcnow())
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
if self.anon:
# Get the entire row of the guild from the guilds table
try:
select_query = """SELECT * FROM guilds WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
embed.set_thumbnail(url=random.choice(self.avatars))
embed.set_footer(text=f"Sent By Anon Member")
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Modlog Record Could Not Be Retrieved For Modlogs", e)
fields = [("Member", "Anon Member", False),
("Message", msg.content, False)]
# Throw error if the modlogs already exists
else:
if action == "setup" and result["modlogs"]:
text = "**Modlogs** Already Setup!" \
f"\nDo **{ctx.prefix}help modlogs** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
elif (action == "update" or action == "delete") and not result["modlogs"]:
text = "**Modlogs** Not Setup!" \
f"\nDo **{ctx.prefix}help modlogs** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
embed.set_thumbnail(url=author.avatar_url)
embed.set_footer(text=f"Sent By {author}")
fields = [("Member", author, False),
("Message", msg.content, False)]
for name, value, inline in fields:
embed.add_field(name=name, value=value, inline=inline)
return not None
return embed
async def get_modmail_from_db(self, ctx, action):
"""Get the starboard record from DB"""
async def wait_for_msg(self, check, user_channel):
"""
Method to check if the user actually types in a message
If not, delete the channel
"""
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the entire row of the guild from the guilds table
try:
# Wait for the message from the author
mod_message = await self.bot.wait_for('message', check=check, timeout=300.0)
select_query = """SELECT * FROM moderatormail WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
# Delete channel if user does not send a message within 5 minutes
except asyncio.TimeoutError:
await user_channel.delete()
return None
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Modlog Record Could Not Be Retrieved For Modlogs", e)
# Throw error if the modlogs already exists
else:
return mod_message
if action == "setup" and result:
text = "**Modmail** Already Setup!" \
f"\nDo **{ctx.prefix}help modmail** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
elif (action == "update" or action == "delete") and not result:
text = "**Modmail** Not Setup!" \
f"\nDo **{ctx.prefix}help modmail** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return None
return not None
# Set up the Cog
@ -167,12 +127,8 @@ class Guild(Cog):
def __init__(self, bot):
self.bot = bot
self.anon = None
self.avatars = ["https://cdn.discordapp.com/embed/avatars/0.png",
"https://cdn.discordapp.com/embed/avatars/1.png",
"https://cdn.discordapp.com/embed/avatars/2.png",
"https://cdn.discordapp.com/embed/avatars/3.png",
"https://cdn.discordapp.com/embed/avatars/4.png"]
self.modmail = Modmail(self.bot)
self.starboard = Starboard(self.bot)
@Cog.listener()
async def on_ready(self):
@ -192,17 +148,14 @@ class Guild(Cog):
desc += f"**{self.bot.tick} Role Persist**\n"
# Get status of modlogs
ml_channel = self.bot.get_modlog_for_guild(ctx.guild.id)
if ml_channel:
if ml_channel := self.bot.get_modlog_for_guild(ctx.guild.id):
channel = ctx.guild.get_channel(ml_channel)
desc += f"**{self.bot.tick} Modlogs | {channel.mention}**\n"
else:
desc += f"**{self.bot.cross} Modlogs**\n"
# Get status of modmail
modmail = self.bot.get_modmail(ctx.guild.id)
if modmail:
if modmail := self.bot.get_modmail(ctx.guild.id):
modmail_channel = ctx.guild.get_channel(modmail["modmail_channel_id"])
modmail_logging = ctx.guild.get_channel(modmail["modmail_logging_channel_id"])
@ -210,6 +163,13 @@ class Guild(Cog):
else:
desc += f"**{self.bot.cross} Modmail**\n"
if starboard := self.bot.get_starboard_channel(ctx.guild.id):
channel = self.bot.get_channel(starboard)
min_stars = self.bot.get_starboard_min_stars(ctx.guild.id)
desc += f"**{self.bot.tick} Starboard | Channel: {channel.mention} | Minimum Stars: {min_stars} :star:**\n"
else:
desc += f"**{self.bot.cross} Starboard**\n"
embed = Embed(title="Moderation Systems",
description=desc,
colour=self.bot.random_colour(),
@ -224,15 +184,6 @@ class Guild(Cog):
async def roles_persist(self, ctx):
"""Role Persist! Keep user roles when they leave/join!"""
@roles_persist.command(name="status")
async def rp_status(self, ctx):
"""Showing the status of the role persist within the guild"""
if self.bot.get_roles_persist(ctx.guild.id) == 0:
await self.bot.generate_embed(ctx, desc=f"**Role Persist is currently disabled within {ctx.guild}**")
else:
await self.bot.generate_embed(ctx, desc=f"**Role Persist is currently enabled within {ctx.guild}**")
@roles_persist.command(name="enable")
async def rp_enable(self, ctx):
"""Enabling role persist within the guild"""
@ -253,96 +204,171 @@ class Guild(Cog):
else:
await self.bot.generate_embed(ctx, desc=f"**Role Persist is already disabled within {ctx.guild}!**")
@group(name="modlogs", case_insensitive=True, usage="`<setup|update|delete>`")
@has_permissions(manage_guild=True)
@group(name="starboarde", case_insensitive=True, usage="`<setup|update|delete|stars>`")
@bot_has_permissions(embed_links=True)
async def modlogs(self, ctx):
@has_permissions(manage_guild=True)
async def starboard(self, ctx):
"""
Log updates in your server! (Nicknames/Deleted Msgs/etc!)
Starboard! Let the community star messages!
"""
@modlogs.command(name="setup")
async def mlsetup(self, ctx, user_channel: TextChannel):
"""Setup a channel for Kick/Ban/Mute actions to be logged"""
@starboard.command(name="stars")
@bot_has_permissions(embed_links=True)
async def sb_min_stars(self, ctx, stars: int):
"""Update the minimum amount of stars needed for the message to appear on the starboard"""
# Setup pool connection
if await get_starboard_from_db(self, ctx, "update") and stars > 0:
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the row of the guild from database
# Update the starboard min_stars in the database
try:
select_query = """SELECT * FROM guilds WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
update_query = """UPDATE starboard SET min_stars = $1 WHERE guild_id = $2"""
await conn.execute(update_query, stars, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Guild Record Could Not Be Retrieved For Modlog Setup", e)
print(f"PostGres Error: Starboard Record Could Not Be Updated For Guild {ctx.guild.id}", e)
# Throw error if the modlog channel already exists
# Send confirmation that the channel has been updated
else:
if result["modlogs"]:
text = "**Modlogs Channel** already set up!" \
f"\nDo **{ctx.prefix}help modlogs** to find out more!"
star_channel = self.bot.get_starboard_channel(ctx.guild.id)
channel = self.bot.get_channel(star_channel)
text = "**Minimum Stars Updated!**" \
f"\nMessages will now need {stars} :star: to appear in {channel.mention}"
await self.bot.generate_embed(ctx, desc=text)
# Set up the modlogs channel within the guild
else:
mod_log_setup = True
await self.bot.storage_modlog_for_guild(ctx, user_channel.id, mod_log_setup)
# Update cache
self.bot.update_starboard_min_stars(ctx.guild.id, stars)
@modlogs.command(name="update")
async def mlupdate(self, ctx, user_channel: TextChannel):
"""Change the channel that your modlogs are sent to"""
elif stars <= 0:
await self.bot.generate_embed(ctx, desc="Minimum Stars Must Be Over or Equal to 1!")
@starboard.command(name="setup", usage="`<#channel>`")
@bot_has_permissions(embed_links=True)
async def sb_setup(self, ctx, starboard_channel: TextChannel):
"""
Setup Starboard
First Argument: Input Channel(Mention or ID) where starred messages will be sent
"""
if await get_starboard_from_db(self, ctx, "setup"):
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the guilds row from the guilds table
# Insert the information about the starboard into database
try:
select_query = """SELECT * FROM guilds WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
insert_query = """INSERT INTO starboard (guild_id, channel_id) VALUES ($1, $2)"""
await conn.execute(insert_query, ctx.guild.id, starboard_channel.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Guild Record Could Not Be Retrieved For Modlog Update", e)
print(f"PostGres Error: Starboard Record Could Not Be Inserted For Guild {ctx.guild.id}", e)
# Throw error if the modlog channel already exists
# Send confirmation message
else:
if not result["modlogs"]:
text = "**Modlogs Channel** not set up!" \
f"\nDo **{ctx.prefix}help modlogs** to find out more!"
text = "**Starboard** is successfully set up!" \
f"\nRefer to **{ctx.prefix}help starboard** for more information"
await self.bot.generate_embed(ctx, desc=text)
# Update the modlog channel within the database and cache
# Store into cache
self.bot.cache_store_starboard(ctx.guild.id, starboard_channel.id, 1)
@starboard.command(name="update", usage="`<channel>`")
@bot_has_permissions(embed_links=True)
async def sb_update(self, ctx, starboard_channel: TextChannel):
"""
Update the channel that the starred messages are sent to
You can Mention or use the Channel ID
"""
if await get_starboard_from_db(self, ctx, "update"):
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Update the starboard channel in the database
try:
update_query = """UPDATE starboard SET channel_id = $1 WHERE guild_id = $2"""
await conn.execute(update_query, starboard_channel.id, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print(f"PostGres Error: Starboard Record Could Not Be Updated For Guild {ctx.guild.id}", e)
# Send confirmation that the channel has been updated
else:
mod_log_setup = False
await self.bot.storage_modlog_for_guild(ctx, user_channel.id, mod_log_setup)
text = "**Channel Updated**" \
f"\nNew Starred Messages will be sent to {starboard_channel.mention}"
await self.bot.generate_embed(ctx, desc=text)
@modlogs.command("delete")
async def mldelete(self, ctx):
"""Delete the existing modlogs channel"""
# Update cache
self.bot.update_starboard_channel(ctx.guild.id, starboard_channel.id)
@starboard.command(name="delete")
@bot_has_permissions(embed_links=True)
async def sb_delete(self, ctx):
"""Delete the starboard from the guild"""
if await get_starboard_from_db(self, ctx, "delete"):
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the guilds row from the guilds table
# Remove the starboard record from the database
try:
select_query = """SELECT * FROM guilds WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
delete_query = """DELETE FROM starboard WHERE guild_id = $1"""
await conn.execute(delete_query, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: Guild Record Could Not Be Retrieved For Modlog Delete", e)
print(f"PostGres Error: Starboard Record Could Not Be Deleted for Guild {ctx.guild.id}", e)
# Throw error that modlogs have not been setup
# Sending confirmation message that the starboard has been deleted
else:
if not result["modlogs"]:
text = "**Modlogs Channel** not set up!" \
f"\nDo **{ctx.prefix}help modlogs** to find out more!"
text = "**Starboard** successfully deleted!" \
f"\nDo **{ctx.prefix}help starboard** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return
# Delete from cache
self.bot.delete_starboard(ctx.guild.id)
@group(name="modlogs", case_insensitive=True, usage="`<setup|update|delete>`")
@has_permissions(manage_guild=True)
@bot_has_permissions(embed_links=True)
async def modlogs(self, ctx):
"""
Log updates in your server! (Nicknames/Deleted Msgs/etc!)
"""
@modlogs.command(name="setup", usage="`<#channel>`")
async def mlsetup(self, ctx, user_channel: TextChannel):
"""Setup a channel for Kick/Ban/Mute actions to be logged"""
if await get_modlogs_from_db(self, ctx, "setup"):
# Set up the modlogs channel within the guild
mod_log_setup = True
await self.bot.storage_modlog_for_guild(ctx, user_channel.id, mod_log_setup)
@modlogs.command(name="update", usage="`<#channel>`")
async def mlupdate(self, ctx, user_channel: TextChannel):
"""Change the channel that your modlogs are sent to"""
if await get_modlogs_from_db(self, ctx, "update"):
# Update the modlog channel within the database and cache
mod_log_setup = False
await self.bot.storage_modlog_for_guild(ctx, user_channel.id, mod_log_setup)
@modlogs.command("delete")
async def mldelete(self, ctx):
"""Delete the existing modlogs channel"""
if await get_modlogs_from_db(self, ctx, "delete"):
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Update the existing modlogs for guild
try:
@ -355,15 +381,12 @@ class Guild(Cog):
# Delete channel from cache
else:
self.bot.remove_modlog_channel(ctx.guild.id)
# Release the connection back to the pool
await pool.release(conn)
text = "**Modlogs System** successfully deleted!" \
f"\nDo **{ctx.prefix}help modlogs** to setup Modlogs again!"
await self.bot.generate_embed(ctx, desc=text)
self.bot.remove_modlog_channel(ctx.guild.id)
@group(name="modmail", case_insensitive=True, usage="`<setup|update|delete>`")
@bot_has_permissions(manage_channels=True, embed_links=True, add_reactions=True, manage_messages=True,
attach_files=True, read_message_history=True, manage_roles=True)
@ -381,26 +404,7 @@ class Guild(Cog):
Second Argument: Input Channel(Mention or ID) where the members mail should be sent
"""
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the author's row from the members table
try:
select_query = """SELECT * FROM moderatormail WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: ModeratorMail Record Could Not Be Retrieved For Modmail Setup", e)
# Throw error if the guild already exists
else:
if result:
text = "**Modmail System** already set up!" \
f"\nDo **{ctx.prefix}help modmail** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return
if await get_modmail_from_db(self, ctx, "setup"):
# Set up embed to let the user how to start sending modmail
desc = "React to this message if you want to send a message to the Staff Team!" \
@ -417,12 +421,10 @@ class Guild(Cog):
# Send modmail embed to the specified channel and auto add the ✅ reaction
modmail_message = await modmail.send(embed=ModMail)
try:
await modmail_message.add_reaction('✅')
except Exception as e:
print(e)
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Insert the information about the modmail system into database
@ -451,30 +453,10 @@ class Guild(Cog):
You can Mention or use the Channel ID
"""
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the moderatormail record from the guilds table
try:
select_query = """SELECT * FROM moderatormail WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: ModeratorMail Record Could Not Be Retrieved For Modmail Update", e)
# Throw error if the guild already exists
else:
if not result:
text = "**Modmail System** not set up!" \
f"\nDo **{ctx.prefix}help modmail** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return
if await get_modmail_from_db(self, ctx, "update"):
# Setup up pool connection and cursor
pool = self.bot.db
async with pool.acquire() as conn:
# Update the modmail channel in the database
try:
update_query = """UPDATE moderatormail SET modmail_logging_channel_id = $1 WHERE guild_id = $2"""
@ -489,7 +471,6 @@ class Guild(Cog):
text = "**Channel Updated**" \
f"\nNew Modmail will be sent to {modmail_logging_channel.mention}"
await self.bot.generate_embed(ctx, desc=text)
# Update cache
self.bot.update_modmail(ctx.guild.id, modmail_logging_channel.id)
@ -497,28 +478,10 @@ class Guild(Cog):
async def mmdelete(self, ctx):
"""Delete the entire modmail system from the guild"""
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Get the moderatormail record from the guilds table
try:
select_query = """SELECT * FROM moderatormail WHERE guild_id = $1"""
result = await conn.fetchrow(select_query, ctx.guild.id)
# Catch errors
except asyncpg.PostgresError as e:
print("PostGres Error: ModeratorMail Record Could Not Be Retrieved For Modmail Delete", e)
else:
# Throw error if modmail system does not exist already
if not result:
text = "**Modmail System** not set up!" \
f"\nDo **{ctx.prefix}help modmail** to find out more!"
await self.bot.generate_embed(ctx, desc=text)
return
if await get_modmail_from_db(self, ctx, "delete"):
# Setup up pool connection
pool = self.bot.db
async with pool.acquire() as conn:
# Remove the moderatormail record from the database
@ -541,154 +504,23 @@ class Guild(Cog):
@Cog.listener()
async def on_raw_reaction_add(self, payload):
"""Listen for reactions for modmail channel"""
# Don't count reactions that are made by the bot
# Don't count other reactions other than ✅ and ❌
if payload.member.bot or str(payload.emoji) not in ['✅', '❌']:
return
# Get the modmail information from cache
modmail = self.bot.get_modmail(payload.guild_id)
if modmail:
channel_id = modmail["modmail_channel_id"]
message_id = modmail["message_id"]
modmail_channel_id = modmail["modmail_logging_channel_id"]
else:
return
# Bunch of checks to make sure it has the right guild, channel, message and reaction
if payload.channel_id == channel_id and payload.message_id == message_id and payload.emoji.name == "✅":
# Get the guild
guild = self.bot.get_guild(payload.guild_id)
# Get the member
member = guild.get_member(payload.user_id)
# Get the setup modmail channel
channel = guild.get_channel(payload.channel_id)
# Get the modmail logging channel
modmail_channel = guild.get_channel(modmail_channel_id)
# Fetch the message and remove the reaction
reaction = await channel.fetch_message(message_id)
await reaction.remove_reaction('✅', member)
# Setting up the channel permissions for the new channel that will be created
overwrites = {
guild.default_role: discord.PermissionOverwrite(read_messages=False, send_messages=False),
guild.me: discord.PermissionOverwrite(read_messages=True, send_messages=True, embed_links=True,
add_reactions=True, manage_messages=True),
member: discord.PermissionOverwrite(read_messages=True, send_messages=True)
}
# Saving this for later within when discord.py 1.4 comes out
# user_channel = await guild.create_category_channel("Member", overwrites=overwrites, position=7)
# Create the text channel
user_channel = await guild.create_text_channel("Member", overwrites=overwrites,
position=0)
# Mention the user to make sure that they get pinged
mention = await user_channel.send(member.mention)
await mention.delete()
try:
# Send the embed if they want to remain anonymous or not
Anon_or_Not = await user_channel.send(embed=anon_or_not(self, member))
# Add reactions to the message
await Anon_or_Not.add_reaction('✅')
await Anon_or_Not.add_reaction('❌')
# Checking if the user reacted with ✅ with response to sending staff a message
def emoji_check(reaction, user):
return user == member and str(reaction.emoji) in ['✅', '❌']
try:
# Wait for the user to add a reaction
reaction, user = await self.bot.wait_for('reaction_add', check=emoji_check, timeout=60.0)
# Delete channel if user does not react within 60 seconds
except asyncio.TimeoutError as ex:
print(ex)
await user_channel.delete()
else:
# Making sure that the reply is from the author
def check(m):
return m.author == payload.member and user_channel.id == instructions.channel.id
# Checking if user wants to be Anonymous or not
if str(reaction.emoji) == "✅":
self.anon = True
"""Listening for reactions relating to modmail/starboard"""
if str(reaction.emoji) == "❌":
self.anon = False
await self.modmail.modmail(payload)
await self.starboard.send_starboard_and_update_db(payload, action="added")
# Delete the old embed
await Anon_or_Not.delete()
# Tell the user to type their mail into the chat
instructions = await user_channel.send(embed=send_instructions(self, member))
# Wait for the message from the author
msg = await wait_for_msg(self, check, user_channel)
if not msg: return
# Making sure that the message is below 50 characters and the message was sent in the channel
while len(msg.content) <= 50 and msg.channel == user_channel:
await user_channel.send(embed=error_handling(self, member))
# Wait for the message from the author
msg = await wait_for_msg(self, check, user_channel)
if not msg: return
# As long as the message is above 50 characters and in the correct channel
if len(msg.content) > 50 and msg.channel == user_channel:
# Delete the previous embed
await instructions.delete()
# Store all text in the channel in a bytesio object
text = ""
async for message in user_channel.history(limit=300):
text += "".join(f"{message.created_at} : {message.content}\n")
text_bytes = str.encode(text)
file = io.BytesIO(text_bytes)
file_name = "Anon.txt" if self.anon else f"{member.name}.txt"
# Send the message to the modmail channel
await modmail_channel.send(embed=send_modmail(self, msg, member),
file=File(file, file_name))
# Make sure the user knows that their message has been sent
await user_channel.send(embed=message_sent_confirmation(self, member))
# Let the user read the message for 5 seconds
await asyncio.sleep(5)
# Delete the channel and then stop the function
await user_channel.delete()
# If the user types anywhere else, delete the channel
else:
await user_channel.delete()
except Exception as ex:
print(ex)
# Send out an error message if the user waited too long
await user_channel.send(
"Sorry! Something seems to have gone wrong and the modmail will be aborting."
"\nRemember to make sure it's under **1024** characters!!")
@Cog.listener()
async def on_raw_reaction_remove(self, payload):
"""Editing the message if a star reaction was removed"""
await asyncio.sleep(5)
await user_channel.delete()
await self.starboard.send_starboard_and_update_db(payload, action="removed")
@mlsetup.error
@mlupdate.error
@mmsetup.error
@mmupdate.error
@sb_setup.error
@sb_update.error
async def mlsetup_command_error(self, ctx, exc):
"""Catching error if channel is not recognised"""

Write Preview
Loading…
Cancel
Save