def set_embed_color(embed, card_details):
faction = card_details['faction']['name']
if faction == 'Monster':
embed.color = Colour.red()
elif faction == 'Neutral':
embed.color = Colour.dark_orange()
elif faction == 'Nilfgaard':
embed.color = Colour.darker_grey()
elif faction == 'Northern Realms':
embed.color = Colour.blue()
elif faction == "Scoia'tael":
embed.color = Colour.green()
elif faction == 'Skellige':
embed.color = Colour.purple()
return embed
async def on_message(self, message, **kwargs):
client = self.client
prefix = kwargs.get("prefix")
lang = kwargs.get("lang")
# Check if this is a valid command
if not is_valid_command(message.content, commands, prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*matches):
for match in matches:
if message.content.startswith(match):
return True
return False
# Global owner filter
if not self.handler.is_bot_owner(message.author.id):
await message.channel.send(self.trans.get("PERM_OWNER", lang))
return
# nano.dev.server_info [id]
elif startswith("nano.dev.server_info"):
s_id = message.content[len("nano.dev.server_info "):]
srv = utils.find(lambda b: b.id == s_id, client.guilds)
if not srv:
await message.channel.send("No such guild. " + StandardEmoji.CROSS)
return
nano_data = self.handler.get_server_data(srv)
to_send = "{}\n```css\nMember count: {}\nChannels: {}\nOwner: {}```\n" \
"*Settings*: ```{}```".format(srv.name, srv.member_count, ",".join([ch.name for ch in srv.channels]), srv.owner.name, nano_data)
await message.channel.send(to_send)
# nano.dev.test_exception
elif startswith("nano.dev.test_exception"):
int("abcdef")
# nano.dev.embed_test
elif startswith("nano.dev.embed_test"):
emb = Embed(title="Stats", colour=Colour.darker_grey())
emb.add_field(name="Messages Sent", value="sample messages")
await message.channel.send("Stats", embed=emb)
# nano.dev.backup
elif startswith("nano.dev.backup"):
self.backup.manual_backup()
await message.channel.send("Backup completed " + StandardEmoji.PERFECT)
# nano.dev.leave_server
elif startswith("nano.dev.leave_server"):
try:
sid = int(message.content[len("nano.dev.leave_server "):])
except ValueError:
await message.channel.send("Not a number.")
return
srv = await self.client.get_guild(sid)
await srv.leave()
await message.channel.send("Left {}".format(srv.id))
# nano.dev.tf.reload
elif startswith("nano.dev.tf.clean"):
self.nano.get_plugin("tf2").instance.tf.request()
await message.channel.send("Re-downloaded data...")
# nano.dev.plugin.reload
elif startswith("nano.dev.plugin.reload"):
name = message.content[len("nano.dev.plugin.reload "):]
v_old = self.nano.get_plugin(name).plugin.NanoPlugin.version
s = await self.nano.reload_plugin(name)
v_new = self.nano.get_plugin(name).plugin.NanoPlugin.version
if s:
await message.channel.send("Successfully reloaded **{}**\nFrom version *{}* to *{}*.".format(name, v_old, v_new))
else:
await message.channel.send("Something went wrong, check the logs.")
# nano.dev.servers.clean
elif startswith("nano.dev.servers.tidy"):
self.handler.delete_server_by_list([s.id for s in self.client.guilds])
# nano.restart
elif startswith("nano.restart"):
await message.channel.send("**DED, but gonna come back**")
await client.logout()
self.shutdown_mode = "restart"
return "shutdown"
# nano.kill
elif startswith("nano.kill"):
await message.channel.send("**DED**")
await client.logout()
self.shutdown_mode = "exit"
return "shutdown"
# nano.playing
elif startswith("nano.playing"):
status = message.content[len("nano.playing "):]
await client.change_presence(activity=Game(name=str(status)))
await message.channel.send("Status changed " + StandardEmoji.THUMBS_UP)
# nano.dev.translations.reload
elif startswith("nano.dev.translations.reload"):
self.trans.reload_translations()
await message.channel.send(StandardEmoji.PERFECT)
# nano.dev.test_default_channel
elif startswith("nano.dev.test_default_channel"):
df = await self.default_channel(message.guild)
if not df:
await message.channel.send("No default channel? w a t")
return
await message.channel.send("Default channel is {}, sending test message".format(df.mention))
await df.send("This is a test message. Apparently everything is ok.")
# nano.dev.announce
elif startswith("nano.dev.announce"):
await message.channel.send("Sending... ")
ann = message.content[len("nano.dev.announce "):]
s = []
for g in self.client.guilds:
try:
d_chan = await self.default_channel(g)
await d_chan.send(ann)
log_to_file("Sent announcement for {}".format(g.name))
s.append(g.name)
except DiscordException:
log_to_file("Couldn't send announcement for {}".format(g.name))
await message.channel.send("Sent to {} servers".format(len(s)))
# nano.dev.userdetective
elif startswith("nano.dev.userdetective"):
param = str(message.content[len(prefix + "nano.dev.userdetective"):])
# Number
if param.isdigit():
user = self.client.get_user(int(param))
if not user:
await message.channel.send("No user with such ID.")
return
elif len(message.mentions) > 0:
user = message.mentions[0]
else:
members = [user for user in self.client.get_all_members()
if user.name == param]
if not members:
await message.channel.send("No users with that name.")
return
user = members[0]
srv_in_common = 0
server_table_temp = []
# Loop though servers and find ones the user is in
for srv in self.client.guilds:
mem = srv.get_member(user.id)
if mem:
srv_in_common += 1
server_table_temp.append("{}: {}".format(srv.name, mem.display_name))
join_time_ago = int((datetime.now() - user.created_at).total_seconds())
join_time_ago = resolve_time(join_time_ago, "en")
embed = Embed(title="{}#{}{}".format(user.name, user.discriminator, ":robot:" if user.bot else ""), description="ID: {}".format(user.id))
embed.add_field(name="Joined Discord", value="**{}** ago\nISO time: {}".format(join_time_ago, user.created_at))
embed.add_field(name="Avatar url", value=user.avatar_url_as(format="png"))
embed.add_field(name="Servers in common", value="**{}** on this shard:\n```http\n{}```".format(srv_in_common, "\n".join(server_table_temp)))
await message.channel.send(embed=embed)
from random import seed, randint
from datetime import datetime
seed(datetime.now())
colours = [
Colour.teal(),
Colour.dark_teal(),
Colour.green(),
Colour.dark_green(),
Colour.blue(),
Colour.dark_blue(),
Colour.purple(),
Colour.dark_purple(),
Colour.magenta(),
Colour.dark_magenta(),
Colour.gold(),
Colour.dark_gold(),
Colour.orange(),
Colour.dark_orange(),
Colour.red(),
Colour.dark_red(),
Colour.lighter_grey(),
Colour.light_grey(),
Colour.dark_grey(),
Colour.darker_grey(),
Colour.blurple(),
Colour.greyple(),
Colour.from_rgb(randint(0, 255), randint(0, 255), randint(0, 255))
]
async def on_message(self, message, **kwargs):
if not is_valid_command(message.content, valid_commands, prefix=kwargs.get("prefix")):
return
else:
self.stats.add(MESSAGE)
assert isinstance(message, Message)
client = self.client
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
# Global owner filter
assert isinstance(self.handler, (RedisServerHandler, LegacyServerHandler))
if not self.handler.is_bot_owner(message.author.id):
await client.send_message(message.channel, StandardEmoji.WARNING + "You are not permitted to use this feature. (must be bot owner)")
return
# nano.dev.get_servers
if startswith("nano.dev.get_servers"):
# fixme message is still too long
servers = ["{} ({} u) - `{}`".format(srv.name, srv.member_count, srv.id) for srv in client.servers]
final = ["\n".join(a) for a in [servers[i:i+1000] for i in range(0, len(servers), 1000)]]
for chunk in final:
await client.send_message(message.channel, chunk)
# nano.dev.server_info [id]
elif startswith("nano.dev.server_info"):
s_id = message.content[len("nano.dev.server_info "):]
srv = utils.find(lambda s: s.id == s_id, client.servers)
if not srv:
await client.send_message(message.channel, "Error. " + StandardEmoji.CROSS)
return
nano_data = self.handler.get_server_data(srv)
to_send = "{}\n```css\nMember count: {}\nChannels: {}\nOwner: {}```\n" \
"*Settings*: ```{}```".format(srv.name, srv.member_count, ",".join([ch.name for ch in srv.channels]), srv.owner.name, nano_data)
await client.send_message(message.channel, to_send)
# nano.dev.test_error
elif startswith("nano.dev.test_exception"):
int("abcdef")
# nano.dev.embed_test
elif startswith("nano.dev.embed_test"):
emb = Embed(title="Stats", colour=Colour.darker_grey())
emb.add_field(name="Messages Sent", value="sample messages")
await client.send_message(message.channel, "Stats", embed=emb)
# nano.dev.backup
elif startswith("nano.dev.backup"):
self.backup.manual_backup()
await client.send_message(message.channel, "Backup completed " + StandardEmoji.PERFECT)
# nano.dev.leave_server
elif startswith("nano.dev.leave_server"):
sid = int(message.content[len("nano.dev.leave_server "):])
srv = utils.find(lambda a: a.id == sid, client.servers)
await client.leave_server(srv)
await client.send_message(message.channel, "Left {}".format(srv.name))
# nano.dev.tf.reload
elif startswith("nano.dev.tf.clean"):
self.nano.get_plugin("tf2").get("instance").tf.request()
await client.send_message(message.channel, "Re-downloaded data...")
# nano.dev.plugin.reload
elif startswith("nano.dev.plugin.reload"):
name = str(message.content)[len("nano.dev.plugin.reload "):]
v_old = self.nano.get_plugin(name).get("plugin").NanoPlugin.version
s = await self.nano.reload_plugin(name)
v_new = self.nano.get_plugin(name).get("plugin").NanoPlugin.version
if s:
await client.send_message(message.channel, "Successfully reloaded **{}**\n"
"From version *{}* to *{}*.".format(name, v_old, v_new))
else:
await client.send_message(message.channel, "Something went wrong, check the logs.")
# nano.dev.servers.clean
elif startswith("nano.dev.servers.clean"):
self.handler.delete_server_by_list([s.id for s in self.client.servers])
elif startswith("nano.dev.server.leave"):
s_id = int(str(message.content)[len("nano.dev.server.leave "):])
serv = Object(id=s_id)
if not serv:
await client.send_messsage(message.channel, "Could not leave server: does not exist")
else:
await client.leave_server(serv)
await client.send_message(message.channel, StandardEmoji.PERFECT + " Left {}".format(serv.id))
# nano.reload
elif startswith("nano.reload"):
self.handler.reload()
await client.send_message(message.channel, "Refreshed server data {} {}".format(StandardEmoji.MUSCLE, StandardEmoji.SMILE))
# nano.restart
elif startswith("nano.restart"):
m = await client.send_message(message.channel, "Restarting...")
await client.send_message(message.channel, "**DED**")
await client.delete_message(m)
await client.logout()
self.mode = "restart"
return "shutdown"
# nano.kill
elif startswith("nano.kill"):
await client.send_message(message.channel, "**DED**")
await client.logout()
self.mode = "exit"
return "shutdown"
# nano.playing
elif startswith("nano.playing"):
status = message.content[len("nano.playing "):]
await client.change_presence(game=Game(name=str(status)))
await client.send_message(message.channel, "Status changed " + StandardEmoji.THUMBS_UP)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
client = self.client
prefix = kwargs.get("prefix")
if not is_valid_command(message.content, valid_commands,
prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*args):
for a in args:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "osu"):
username = message.content[len(prefix + "osu "):]
t_start = time.time()
user = self.osu.get_user(username)
if not user:
await client.send_message(message.channel,
"User does not exist.")
return
# About inverting: this inverts the number before and after the splitting
def prepare(this):
if not type(this) in (float, int):
return None
return invert_str(",".join(
split_every(str(invert_num(this)), 3)))
global_rank = prepare(user.world_rank)
country_rank = prepare(user.country_rank)
total_score = prepare(user.total_score)
ranked_score = prepare(user.ranked_score)
try:
acc = str(round(float(user.accuracy), 2)) + " %"
except TypeError:
await client.send_message(message.channel,
":warning: Something went wrong...")
return
pp_amount = str(int(float(user.pp)))
osu_level = int(float(user.level))
avatar_url = "http://a.ppy.sh/{}".format(user.id)
# Color is determined by the level range
if osu_level < 10:
color = Colour.darker_grey()
elif osu_level < 25:
color = Colour.light_grey()
elif osu_level < 40:
color = Colour.dark_teal()
elif osu_level < 50:
color = Colour.teal()
elif osu_level < 75:
color = Colour.dark_purple()
elif osu_level < 100:
color = Colour.purple()
# Only the masters get the gold ;)
else:
color = Colour.gold()
desc = "**Level**: {}\n**Rank**: \n\t" \
"**Global**: #{}\n\t" \
"**Country** (**{}**): #{}\n" \
"Total PP: **{}**".format(osu_level, global_rank, user.country, country_rank, pp_amount)
embed = Embed(url=user.profile_url, description=desc, colour=color)
embed.set_author(name=user.name)
embed.set_thumbnail(url=avatar_url)
embed.add_field(name="Total score", value=total_score)
embed.add_field(name="Ranked score", value=ranked_score)
embed.add_field(name="Average accuracy", value=acc)
delta = int((time.time() - t_start) * 1000)
embed.set_footer(text="Search took {} ms".format(delta))
try:
await client.send_message(message.channel, embed=embed)
except errors.HTTPException:
await client.send_message(
message.channel,
"Something went wrong " + StandardEmoji.THINKING)
