async def support_msg(self,
ctx: Context,
*,
message: str = "Support Required!") -> None:
"""Send a support message to the developers."""
support_channel = self.bot.get_channel(config.support_channel)
embed = Embed(title="Support!",
description=message,
color=Color.dark_blue())
embed.add_field(name="Author",
value=f"{ctx.author.id} | {ctx.author.mention}")
await support_channel.send(embed=embed)
embed = Embed(
title="Problem's still there?",
description=textwrap.dedent(
"If you still have **problems with the bot**"
", Join the Support Server now and our developers will happily help you"
f"\n❯❯ [Support Server]({config.SUPPORT_SERVER})"
f"\n❯❯ [Invite Link]({config.invite_link})"),
color=Color.dark_green(),
)
embed.set_thumbnail(url=self.bot.user.avatar_url)
await ctx.send(embed=embed)
async def on_member_unban(self, guild: Guild, user: Member) -> None:
if self.bot.log_is_ignored(Event.member_unban, (guild.id, user.id)):
return
ban_log_entry = await last_audit_log_with_fail_embed(
guild,
actions=[AuditLogAction.unban],
send_callback=partial(self.send_log, guild),
target=user)
if ban_log_entry is None:
return
embed = Embed(
title="User unbanned",
description=textwrap.dedent(f"""
**User:** {user.mention}
**Author:** {ban_log_entry.user.mention}
**Reason:** {ban_log_entry.reason if ban_log_entry.reason else "N/A"}
"""),
color=Color.dark_green(),
)
embed.set_thumbnail(url=user.avatar_url)
embed.set_footer(text=f"User ID: {user.id}")
embed.timestamp = ban_log_entry.created_at
await self.send_log(guild, embed=embed)
async def tinfo(self, ctx, *, t_id=None):
result = self.search_tournament(t_id)
embed = Embed(title=result.name, color=Color.dark_green())
try:
embed.description = f"Hosted by {result.host.mention}"
except AttributeError:
embed.description = "The host of this tournament left the server!"
embed.set_footer(text="Tournament ID: " + str(result.id))
if result.time is not None:
countdown = ""
if result.time > datetime.utcnow():
try:
time_left = TimeUntil(result.time)
countdown = f"\nStarting in **{time_left}**"
except ValueError:
pass
embed.add_field(name="Time",
value=strftime(f"%A %d %b %H:%M *GMT*",
result.time.timetuple()) +
countdown)
else:
embed.add_field(name="Time", value="Unknown")
embed.add_field(name="Prize", value=result.prize)
embed.add_field(name="Status", value=Status.KEYS[result.status])
embed.add_field(name="Roles", value=result.roles)
embed.add_field(name="Note", value=result.note)
await ctx.send(embed=embed)
def welcome(message: str) -> Embed:
"""
Constructs welcome embed with fixed title 'Welcome' and green color.
:param message: embed description
:return: Embed object
"""
return simple_embed(message, "Welcome!", color=Color.dark_green())
async def send_wordle_embed(self, ctx, wordle, guesses, header_str):
"""
Generates the wordle image, host it on imgur and send the it as an interaction response
--
input:
ctx: interactions.CommandContext
wordle: wordle.Wordle
guesses: List[str]
header_str: str
"""
img_path = "wordle_tmp.png"
wordle.generate_image(guesses, img_path)
link = utils.upload_image_to_imgur(img_path)
os.remove(img_path)
color = Color.gold()
if len(guesses) > 0 and guesses[-1] == wordle.solution:
color = Color.dark_green()
elif len(guesses
) == wordle.nb_trials and guesses[-1] != wordle.solution:
color = Color.dark_red()
embed = Embed(title="Wordle",
description=header_str,
color=color.value,
image=EmbedImageStruct(url=link)._json)
await ctx.send(embeds=embed, ephemeral=True)
async def stats(self, ctx: commands.Context):
"""Stats of the bot"""
users = len(self.bot.users)
guilds = len(self.bot.guilds)
embed = Embed(color=Color.dark_green())
fields = (
("Guilds", guilds),
("Users", users),
("System", platform.release()),
(
"Memory",
"{:.4} MB".format(psutil.Process().memory_info().rss /
1024**2),
),
("Python version", ".".join([str(v)
for v in sys.version_info[:3]])),
("Discord version", discord_version),
)
for name, value in fields:
embed.add_field(name=name, value=str(value), inline=False)
embed.set_thumbnail(url=str(ctx.guild.me.avatar_url))
await ctx.send(embed=embed)
def random():
# type: () -> Color
chilipepper = Color(0x9B1B30)
tan = Color(0xBEAA3E)
icedcoffee = Color(0xB18F6A)
return choice([
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
icedcoffee,
chilipepper,
])
async def spectate(self, ctx):
await self.CheckRequirements(ctx.author)
if ModifierCheck("SpectatorsAllowed",
self.tournament.modifiers) is False:
raise TournamentJoinException(
"spectators are not allowed for this tournament!")
if ctx.author in self.tournament.spectators:
raise TournamentJoinException("you are already a spectator!")
spec_count = len(self.tournament.spectators)
join_msg = f"{Emote.join} {ctx.author.mention} joined the spectators. **{str(spec_count + 1)}** spectators are now watching the tournament."
if spec_count == 0: # First join, make singular
i = join_msg[-35:].index("s are") + len(join_msg) - 35
join_msg = join_msg[:i] + " is" + join_msg[i + 5:]
await ctx.author.add_roles(self.roles.spectator)
await self.channels.t_chat.send(join_msg)
self.tournament.spectators.append(ctx.author)
Log("Spectator Joined",
description=
f"{ctx.author.mention} joined **{self.tournament.name}**.",
color=Color.dark_green(),
fields=[{
'name': "Spectator Count",
'value': str(spec_count + 1)
}])
embed = UpdatedEmbed(self.tournament)
await self.tournament.msg.edit(embed=embed)
def black_jack_embed(user: User,
player,
outcome: str = None,
hidden: bool = True) -> Embed:
"""
Creates embed based on set of constraints for blackjack
:param user: discord.User
:param player: player object for blackjack
:param outcome: blackjack game outcome
:param hidden: dealer card value
:return: discord.Embed
"""
embed = black_jack_template(user, player, "", Color.gold())
embed.add_field(name="Dealer hand",
value=player.game.get_emote_string(hidden=hidden))
if outcome == "win":
embed.colour = Color.dark_green()
embed.description = "**Outcome:** You won!"
elif outcome == "lose":
embed.colour = Color.dark_red()
embed.description = "**Outcome:** You lost!"
elif outcome == "tie":
embed.colour = Color.dark_grey()
embed.description = "**Outcome:** It's a tie!"
return embed
def __init__(self, client):
self.client = client
self.client_color = Color.red()
self.color_dict = {
1: [Color.teal(), 'teal'],
2: [Color.dark_teal(), 'dark_teal'],
3: [Color.green(), 'green'],
4: [Color.dark_green(), 'dark_green'],
5: [Color.blue(), 'blue'],
6: [Color.dark_blue(), 'dark_blue'],
7: [Color.purple(), 'purple'],
8: [Color.dark_purple(), 'dark_purple'],
9: [Color.magenta(), 'magenta'],
10: [Color.dark_magenta(), 'dark_magenta'],
11: [Color.gold(), 'gold'],
12: [Color.dark_gold(), 'dark_gold'],
13: [Color.orange(), 'orange'],
14: [Color.dark_orange(), 'dark_orange'],
15: [Color.red(), 'red'],
16: [Color.dark_red(), 'dark_red'],
17: [Color.lighter_grey(), 'lighter_grey'],
18: [Color.dark_grey(), 'grey'],
19: [Color.light_grey(), 'light_grey'],
20: [Color.darker_grey(), 'darker_grey']
}
def random():
c = [
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
icedcoffee,
chilipepper
]
return c[randint(0, len(c) - 1)]
def embed_constructor(self, status: Literal["online", "offline"]):
if status == "online":
return Embed(title=f"{self.emojis.power_on} Online!",
color=Color.dark_green())
else:
return Embed(title=f"{self.emojis.power_off} Offline!",
color=Color.from_rgb(91, 10, 0))
def random():
# type: () -> Color
tan = Color(0xBEAA3E)
return choice([
Color.teal(),
Color.dark_teal(),
Color.green(),
Color.dark_green(),
Color.blue(),
Color.dark_blue(),
Color.purple(),
Color.dark_purple(),
Color.magenta(),
Color.dark_magenta(),
Color.gold(),
Color.dark_gold(),
Color.orange(),
Color.dark_orange(),
Color.red(),
Color.dark_red(),
Color.lighter_grey(),
Color.darker_grey(),
Color.blurple(),
tan,
])
async def on_guild_join(self, guild: Guild):
embed = Embed(
title=f"Joined guild: {guild}",
description=f"Members: {guild.member_count}\nID: {guild.id}",
color=Color.dark_green(),
).set_thumbnail(url=guild.icon.url if guild.icon else None)
await self.bot.status_channels.Guilds.send(embed=embed)
async def clyde(self, ctx: Context, *, text: str) -> None:
"""Make clyde say something."""
async with ctx.typing():
async with self.bot.session.get(f"https://nekobot.xyz/api/imagegen?type=clyde&text={text}") as r:
res = await r.json()
embed = discord.Embed(color=Color.dark_green())
embed.set_image(url=res["message"])
await ctx.send(embed=embed)
async def invite(self, ctx: Context) -> None:
"""Invite link for Bot."""
embed = Embed(
title="Inviting me to your Server?",
description=f"❯❯ [Invite Link]({constants.invite_link})" f"\n❯❯ [Secondary Invite Link]({constants.admin_invite_link})",
color=Color.dark_green(),
)
embed.set_thumbnail(url=self.bot.user.avatar_url)
await ctx.send(embed=embed)
async def tweet(self, ctx: Context, username: str, *, text: str) -> None:
"""Tweet as someone."""
async with ctx.typing():
base_url = "https://nekobot.xyz/api/imagegen?type=tweet"
async with self.bot.session.get(f"{base_url}&username={username}&text={text}") as r:
res = await r.json()
embed = Embed(color=Color.dark_green())
embed.set_image(url=res["message"])
await ctx.send(embed=embed)
async def create(cls, ctx):
checklist = cls()
embed = Embed(title="Player Checklist", color=Color.dark_green())
checklist.embed = embed
checklist.checked = {}
checklist.msg = await Channel(ctx.bot).t_chat.send(embed=embed)
checklist.client = ctx.bot
checklist.emote_str = "123456789🇦🇧🇨🇩🇪🇫🇬🇭🇮🇯🇰🇱🇲🇳🇴🇵🇶🇷🇸🇹🇺🇻🇼🇽🇾🇿"
await checklist.msg.pin()
return checklist
def __init__(self, webhook):
self.webhook = webhook
self.level_color = {
"INFO": Color.light_grey(),
"WARNING": Color.gold(),
"ERROR": Color.dark_red(),
"CRITICAL": Color.red(),
"DEBUG": Color.dark_green(),
"NOTSET": Color.dark_grey(),
}
super(DiscordHandler, self).__init__()
async def stats(self, ctx: commands.Context):
"""Stats of the bot"""
users = len(self.bot.users)
guilds = len(self.bot.guilds)
embed = Embed(color=Color.dark_green())
embed.add_field(name="Guilds", value=guilds)
embed.add_field(name="Users", value=users)
embed.set_thumbnail(url=ctx.guild.me.avatar_url)
await ctx.send(embed=embed)
async def support(self, ctx: Context) -> None:
"""Get an invite link to the bots support server."""
embed = Embed(
title="Need Support? OR Want to give Feedback?",
description="If you have any **problems with the bot** or "
"if you have any **suggestions/feedback** be sure to join the Support Server!"
f"❯❯ [Support Server]({constants.discord_server})"
f"❯❯ [Invite Link]({constants.invite_link})",
color=Color.dark_green(),
)
embed.set_thumbnail(url=self.bot.user.avatar_url)
await ctx.send(embed=embed)
class ConnectEmbed(EventEmbed):
color = Color.dark_green()
event = "has connected to a channel"
def __init__(self, member: Member, channel: GroupChannel):
super().__init__(member=member, event=self.event, color=self.color)
self.channel = channel
def build_embed(self, *args, **kwargs):
super().build_embed(*args, **kwargs)
self.embed.add_field(name="Channel:", value=self.channel.name)
async def support(self, ctx: Context) -> None:
"""Get an invite link to the bot's support server."""
embed = Embed(
title="Do you need support or want to give some feedback?",
description=textwrap.dedent(
"If you have any **problems with the bot** or "
"if you have any **suggestions/feedback** be sure to use the support commands or join the Support Server!"
f"\n❯❯ [Support Server]({config.discord_server})"
f"\n❯❯ [Invite Link]({config.invite_link})"),
color=Color.dark_green(),
)
embed.set_thumbnail(url=self.bot.user.avatar_url)
await ctx.send(embed=embed)
async def join(self, ctx):
await self.CheckRequirements(ctx.author)
player_count = len(self.tournament.get_participants())
mod_index = ModifierCheck("MaxParticipants", self.tournament.modifiers)
if mod_index is not False:
max_count = self.tournament.modifiers[mod_index]['value']
else:
max_count = 15 # Default
if player_count >= max_count:
raise TournamentJoinException(
f"the tournament is full! The maximum number of participants is **{str(max_count)}**."
)
join_msg = f"{Emote.join} {ctx.author.mention} joined. **{str(player_count + 1)}** players are now ready."
if player_count == 0: # First join, make singular
i = join_msg[-35:].index("s are") + len(join_msg) - 35
join_msg = join_msg[:i] + " is" + join_msg[i + 5:]
user = User.fetch_by_id(ctx, ctx.author.id)
if user.participations == 0:
join_msg += "\nThis is the first tournament they are participating in. Welcome! 🎉"
await SendFirstTournamentMessage(ctx)
if user.ign is None:
join_msg += "\nThis player does not have an IGN set yet."
else:
join_msg += f"\nIGN: `{user.ign}`"
ign_cache[ctx.author.id] = user.ign
await ctx.author.add_roles(self.roles.participant)
await ctx.author.remove_roles(self.roles.spectator)
await self.channels.t_chat.send(join_msg)
Log("Participant Joined",
description=
f"{ctx.author.mention} joined **{self.tournament.name}**.",
color=Color.dark_green(),
fields=[{
'name': "Player Count",
'value': str(player_count + 1)
}])
self.tournament.add_participant(ctx.author)
if ctx.author in self.tournament.spectators:
self.tournament.spectators.remove(ctx.author)
embed = UpdatedEmbed(self.tournament)
await self.tournament.msg.edit(embed=embed)
await self.checklist.update_text(ctx, self.tournament)
def footer_embed(message: str, title) -> Embed:
"""
Constructs embed with fixed green color and fixed footer showing website, privacy url and rules url.
:param message: embed description
:param title: title of embed
:return: Embed object
"""
content_footer = (f"Links: [Website]({constants.website_url}) | "
f"[Privacy statement]({constants.privacy_url}) | "
f"[Rules]({constants.rules_url})")
message = f"{message}\n\n{content_footer}"
embed = simple_embed(message, title, color=Color.dark_green())
embed.set_image(url=constants.line_img_url)
return embed
def welcome_dm(message: str) -> Embed:
"""
Constructs welcome embed to be sent when user joins,
with fixed green color and fixed footer showing privacy url and rules url.
:param message: embed description
:return: Embed object
"""
content_footer = (f"Links: [Website]({constants.website_url}) | "
f"[Privacy statement]({constants.privacy_url}) | "
f"[Rules]({constants.rules_url})")
message = f"{message}\n\n{content_footer}"
welcome_dm_embed = simple_embed(message,
"Welcome",
color=Color.dark_green())
welcome_dm_embed.set_image(url=constants.line_img_url)
return welcome_dm_embed
async def send_status(self, guess: t.Optional[str] = None, guess_status: t.Optional[t.Literal[0, 1, 2, 3]] = None) -> None:
"""Get current game status as embed."""
embed = Embed(
title="Hangman",
color=Color.dark_green(),
)
embed.add_field(
name="**❯❯ Status**",
value=f"```\n{HangmanGame.stages[self.tries]}```",
inline=False
)
embed.add_field(
name="**❯❯ Word**",
value=f"**{self.display_word}**",
inline=False
)
if guess:
description = f"Letter {guess}"
if guess_status == 0:
description += " isn't in the word"
color = Color.red()
elif guess_status == 1:
description += " is in the word"
color = Color.green()
elif guess_status == 2:
description += " isn't valid"
color = Color.dark_red()
elif guess_status == 3:
description += " was already guessed."
color = Color.dark_red()
guess_embed = Embed(
description=description,
color=color
)
await self.channel.send(embed=guess_embed, delete_after=5)
embed.set_footer(
text=f"{config.COMMAND_PREFIX}hangexit to exit the game! | Powered By HotWired."
)
if hasattr(self, "message"):
await self.message.edit(embed=embed)
else:
self.message = await self.channel.send(embed=embed)
import json
from discord import Color
with open('data/udyr_quotes.json') as f:
QUOTES = json.load(f)
QUOTES_LEN = len(QUOTES)
BOT_NAME = 'Udyr Bot'
COMMAND_PREFIX = '!'
HELP_TEXT = '\n '.join([
'!quote - Random Udyr quote', '!help - This help message',
'!github - Get the GitHub address of the project',
'!summ - Get Ranked Information for a summoner: `!summ Donger Dingo`, `!summ yassuo --region NA`',
'!game - Get Information for a currently playing game: `!game Donger Dingo`, `!game Imaqtpie --region NA`'
])
GITHUB_PROJECT_URL = 'https://github.com/jakubclark/udyr_bot'
BASE_EMBED = {
'color': Color.dark_green().value,
'thumbnail': {
'url':
'https://raw.githubusercontent.com/jakubclark/udyr_bot/master/data/udyr1.png',
'height': 45,
'width': 45
}
}
async def doctor(self, ctx: 'CustomContext'):
waiting_message = await ctx.send(
"<a:loading:393852367751086090> Please wait, running `doctor` checks"
) # <a:loading:393852367751086090> is a loading emoji
t_1 = time.perf_counter()
await ctx.trigger_typing(
) # tell Discord that the bot is "typing", which is a very simple request
t_2 = time.perf_counter()
time_delta = round(
(t_2 - t_1) * 1000) # calculate the time needed to trigger typing
del self.bot.settings.settings_cache[ctx.guild]
messages = {}
message = []
# Permissions
wanted_permissions = discord.permissions.Permissions.none()
wanted_permissions.update(kick_members=True,
ban_members=True,
read_messages=True,
send_messages=True,
manage_messages=True,
embed_links=True,
attach_files=True,
read_message_history=True,
external_emojis=True,
change_nickname=True,
add_reactions=True)
message.append("```diff")
errored_in = []
for channel in ctx.guild.channels:
my_permissions = ctx.message.guild.me.permissions_in(channel)
if not my_permissions.is_strict_superset(wanted_permissions):
errored_in.append(channel)
if len(errored_in) == 0:
message.append("+ Everything checks out! No permissions problems")
else:
message.append(
f"= The following channels have permissions problems, use the {ctx.prefix}bot_permissions_check command in them to see what's missing"
)
message.extend(["- #" + channel.name for channel in errored_in])
top_role = ctx.message.guild.me.top_role
# Position isn't guaranteed to not have gaps
# Discord pls
message.append(
f"= Bot top role is at position {top_role.position}/{ctx.guild.roles[-1].position} [higher is better] - "
f"Any user that have a role equal or higher to <{top_role.name}> can't be kicked/banned"
)
message.append("```")
messages["Bot Permissions"] = discord.Embed(
description="\n".join(message),
color=Color.green() if len(errored_in) == 0 else Color.red())
# Settings
message = [
"If a setting is enabled, the line will be in green. If it's disabled, the line will be red ```diff"
]
settings_char = {True: "+ ", False: "- "}
guild = ctx.guild
settings_to_check = {
"automod_enable": "Automod",
"autotrigger_enable":
"AutoTriggers (special automod rules to fight a specific kind of spam message — Require automod to be enabled too)",
"thresholds_enable":
"Thresholds (automatic action when a users received X strikes)",
"logs_enable": "Logs",
"autoinspect_enable":
"AutoInspect (Verification of new members that join your server)",
"rolepersist_enable": "RolePersist (VIP)"
}
for setting, display_name in settings_to_check.items():
setting_enabled = await self.bot.settings.get(guild, setting)
message.append(settings_char[setting_enabled] + display_name)
message.append(
f"```\n To edit your settings, and see more of them, use the `{ctx.prefix}urls` command to see your server webpage, "
"then edit settings there (You may need to login first)\n")
messages["Bot Settings"] = discord.Embed(
description="\n".join(message), color=Color.dark_green())
# Logs
logs_enabled = await self.bot.settings.get(guild, "logs_enable")
if logs_enabled:
logs = {
"logs_moderation_channel_id": "Moderation acts",
"logs_joins_channel_id": "Users joining/leaving",
"logs_rolepersist_channel_id": "Roles persist",
"logs_member_edits_channel_id": "Users edits",
"logs_edits_channel_id": "Message edits",
"logs_delete_channel_id": "Message deletions",
"logs_autoinspect_channel_id": "AutoInspect logs"
}
everything_good = True
message = [
"Logs are globally enabled on this server. The following specific logs are activated and configured: \n```diff"
]
for setting, display_name in logs.items():
try:
setting_value = int(await
self.bot.settings.get(guild, setting))
except ValueError:
message.append(
f"= {display_name} log (enabled but there is text in the ID field, I can't parse it)"
)
else:
if setting_value == 0:
message.append(f"- {display_name} log")
everything_good = False
else:
channel_logged = discord.utils.get(guild.channels,
id=setting_value)
if channel_logged:
message.append(
f"+ {display_name} log (in #{channel_logged.name})"
)
else:
message.append(
f"= {display_name} log (enabled but couldn't find the channel that goes by ID {setting_value})"
)
everything_good = False
message.append("```")
messages["Logs"] = discord.Embed(
description="\n".join(message),
color=Color.green()
if everything_good else Color.dark_orange())
message = []
# Staff
l = await get_level(ctx, ctx.author)
levels_names = {
10: "Bot owner",
9: "Reserved for future use",
8: "Bot global-moderators",
7: "Reserved for future use",
6: "Reserved for future use",
5: "Server owner",
4: "Server administrator",
3: "Server moderator",
2: "Server trusted user",
1: "Member",
0: "Bot-banned"
}
message.append(
f"Your current access level is `{l}` ({levels_names[l]}).")
embed = discord.Embed(
description="\n".join(message),
color=Color.green() if l >= 3 else Color.orange())
ids = await self.bot.settings.get(guild, 'permissions_admins')
if len(ids) > 0:
message = [
"The following user(s) have been granted server **admin** (4) here "
"(This is not a complete list since it does **not** include people with the `administrator` permission) \n```diff"
]
for admin_id in ids:
admin = discord.utils.get(guild.members, id=admin_id)
if admin:
message.append(
f"+ {admin.name}#{admin.discriminator} ({admin_id})")
else:
role = discord.utils.get(guild.roles, id=admin_id)
if role:
message.append(f"+ (Role) {role.name} ({admin_id})")
else:
message.append(f"- User left the server ({admin_id})")
message.append("```")
embed.add_field(name="Server administrators",
value="\n".join(message),
inline=False)
ids = await self.bot.settings.get(guild, 'permissions_moderators')
if len(ids) > 0:
message = [
"The following user(s) have been granted server **moderator** (3) here "
"(This is not a complete list since it does **not** include people with the `ban_members` permission) \n```diff"
]
for mod_id in ids:
mod = discord.utils.get(guild.members, id=mod_id)
if mod:
message.append(
f"+ {mod.name}#{mod.discriminator} ({mod_id})")
else:
role = discord.utils.get(guild.roles, id=mod_id)
if role:
message.append(f"+ (Role) {role.name} ({mod_id})")
else:
message.append(f"- User left the server ({mod_id})")
message.append("```")
embed.add_field(name="Server moderators",
value="\n".join(message),
inline=False)
ids = await self.bot.settings.get(guild, 'permissions_trusted')
if len(ids) > 0:
message = [
"The following user(s) have been granted server **trusted** (2) here "
"(This is not a complete list since it does **not** include people with the `kick_members` permission) \n```diff"
]
for trusted_id in ids:
trusted = discord.utils.get(guild.members, id=trusted_id)
if trusted:
message.append(
f"+ {trusted.name}#{trusted.discriminator} ({trusted_id})"
)
else:
role = discord.utils.get(guild.roles, id=trusted_id)
if role:
message.append(f"+ (Role) {role.name} ({trusted_id})")
else:
message.append(
f"- User left the server ({trusted_id})")
message.append("```")
embed.add_field(name="Trusted users",
value="\n".join(message),
inline=False)
messages["Staff"] = embed
embed = discord.Embed(
description=
"This is stuff you can't do much about it, but just wait for the problems to go away if there are some. \n"
"You might want to check https://status.discordapp.com for more information",
color=Color.green() if time_delta < 200 else Color.red())
embed.add_field(name="Bot ping", value=f"{time_delta}ms")
embed.add_field(name="Bot latency",
value=f"{round(self.bot.latency * 1000)}ms")
messages["Connexion"] = embed
ok = True
try:
widget = await guild.widget()
except discord.HTTPException:
widget = None
ok = False
invite_code = await self.bot.settings.get(guild, 'invite_code')
invite_error = False
if not invite_code:
ok = False
invite_error = "No invite is set in your server settings. Please add it on the dashboard!"
else:
try:
await self.bot.fetch_invite(invite_code)
except discord.NotFound:
invite_error = "The invite code was provided but is not working correctly. Please check that the invite is valid."
ok = False
except discord.HTTPException:
invite_error = "There was an error reading your invite code. Please check that the invite is valid."
ok = False
embed = discord.Embed(
description="Checking discord server settings since 1990",
color=Color.green() if ok else Color.red())
embed.add_field(
name="Widget enabled",
value=f"Yes" if widget else
"You should enable the server widget for it to show up properly on your server webpage."
)
embed.add_field(name="Invite provided",
value=f"Yes" if not invite_error else invite_error)
messages["Server Settings"] = embed
# Send everything
for message_title, embed in messages.items():
embed.title = message_title
await ctx.send(embed=embed)
# await ctx.trigger_typing()
await asyncio.sleep(.8)
await waiting_message.delete()
class FeatTypes(Enum):
DIVINE = Color.from_rgb(255, 255, 255)
MARTIAL = Color.orange()
SKILL = Color.purple()
WILD = Color.dark_green()
