async def on_message(self, message, **kwargs):
trans = self.trans
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
# !gamedb [name]
if startswith(prefix + "gamedb"):
game_name = message.content[len(prefix + "gamedb "):]
if not game_name:
await message.channel.send(trans.get("MSG_IGDB_NONAME", lang))
return
game = await self.gamedb.get_game_by_name(game_name)
if not game:
await message.channel.send(
trans.get("MSG_IGDB_NO_RESULT", lang))
return
embed = Embed(description=game.summary)
embed.set_image(url=game.cover_image)
embed.set_author(name=game.name, url=game.url)
genres = " ".join(["`{}`".format(a) for a in game.genres])
embed.add_field(name=trans.get("MSG_IGDB_GENRES", lang),
value=genres)
publishers = " ".join(["`{}`".format(a) for a in game.publishers])
embed.add_field(name=trans.get("MSG_IGDB_PUBLISHERS", lang),
value=publishers,
inline=False)
if game.rating:
rating = "{} / 100".format(int(game.rating))
embed.add_field(name=trans.get("MSG_IGDB_RATING", lang),
value=rating,
inline=False)
if game.video:
embed.add_field(name=trans.get("MSG_IGDB_VIDEO", lang),
value=game.video,
inline=False)
embed.set_footer(text="Powered by idgb.com")
await message.channel.send(embed=embed)
async def on_message(self, message, **kwargs):
trans = self.trans
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
# !tf [item name]
if startswith(prefix + "tf"):
if not self.tf.success:
await message.channel.send(
trans.get("MSG_TF_UNAVAILABLE", lang))
return
item_name = message.content[len(prefix + "tf "):]
if not item_name:
await message.channel.send(trans.get("MSG_TF_NO_PARAMS", lang))
return
item = await self.tf.get_item_by_name(str(item_name))
if not item:
await message.channel.send(
trans.get("MSG_TF_NO_SUCH_ITEM", lang).format(item_name))
self.stats.add(WRONG_ARG)
return
ls = []
for qu in item.get_all_qualities():
v_data = qu.get(list(qu.keys())[0])
quality = get_quality_name(list(qu.keys())[0])
currency = "ref" if v_data.get("price").get(
"currency") == "metal" else v_data.get("price").get(
"currency")
ls.append("__**{}**__: `{} {}`".format(
quality,
v_data.get("price").get("value"), currency))
det = trans.get("MSG_TF_LIST",
lang).format(item.name, "\n".join(ls))
await message.channel.send(det)
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)
async def on_message(self, message, **kwargs):
trans = self.trans
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
# !imdb
if startswith(prefix + "imdb"):
# The process can take some time so we show that something is happening
await message.channel.trigger_typing()
cut = message.content[len(prefix + "imdb "):]
try:
subcommand, argument = cut.split(" ", maxsplit=1)
# In case there are no parameters
except ValueError:
# Check if no subcommand - valid
# If there's a subcommand, but no argument, fail
if not cut.strip(" "):
await message.channel.send(trans.get("MSG_IMDB_INVALID_USAGE", lang).format(prefix))
return
else:
subcommand, argument = cut, ""
# !imdb plot
if subcommand == "plot":
data = await self._imdb_search(argument, message, lang)
# Check type
if data.media_type not in ["tv", "movie"]:
await message.channel.send(trans.get("MSG_IMDB_CANTPERSON", lang))
return
# Try to send
try:
info = trans.get("MSG_IMDB_PLOT", lang).format(data.title, data.overview)
await message.channel.send(filter_text(info))
except AttributeError:
await message.channel.send(trans.get("MSG_IMDB_PLOT_MISSING", lang))
# !imdb trailer
elif subcommand == "trailer":
data = await self._imdb_search(argument, message, lang)
try:
title, trailer = filter_text(data.title), filter_text(data.trailer)
await message.channel.send(trans.get("MSG_IMDB_TRAILER", lang).format(title, trailer))
except (AttributeError, KeyError):
await message.channel.send(trans.get("MSG_IMDB_TRAILER_MISSING", lang))
# !imdb rating
elif subcommand == "rating":
data = await self._imdb_search(argument, message, lang)
try:
title, vote_avg = filter_text(data.title), filter_text(data.vote_average)
content = trans.get("MSG_IMDB_RATINGS", lang).format(title, vote_avg)
await message.channel.send(content)
except AttributeError:
await message.channel.send(trans.get("MSG_IMDB_RATINGS_MISSING", lang))
# !imdb help
elif subcommand == "help":
await message.channel.send(trans.get("MSG_IMDB_HELP", lang).replace("_", prefix))
# !imdb search
else:
# Parse arguments
if subcommand == "search":
# !imdb search the hunger games
query = argument
else:
# !imdb the hunger games
query = " ".join((subcommand, argument))
data = await self._imdb_search(query, message, lang)
# Check type
if data.media_type in ["tv", "movie"]:
info = []
# Step-by-step adding - some data might be missing
try:
media_type = trans.get("MSG_IMDB_SERIES", lang) if data.media_type == "tv" else ""
info.append("**{}** {}\n".format(data.title, media_type))
except AttributeError:
pass
try:
genres = "`{}`".format("`, `".join(data.genres))
info.append(trans.get("MSG_IMDB_GENRES", lang).format(genres))
except AttributeError:
pass
try:
info.append(trans.get("MSG_IMDB_AVGRATING", lang).format(data.vote_average))
except AttributeError:
pass
if data.media_type == "tv":
try:
info.append(trans.get("MSG_IMDB_SEASONS", lang).format(len(data.seasons)))
except AttributeError:
pass
try:
info.append(trans.get("MSG_IMDB_SUMMARY", lang).format(data.overview))
except AttributeError:
pass
try:
if data.poster:
info.append(trans.get("MSG_IMDB_POSTER", lang).format(data.poster))
except AttributeError:
pass
# Compile together info that is available
media_info = filter_text("\n".join(info))
else:
await message.channel.send(trans.get("MSG_IMDB_PERSON_NOT_SUPPORTED", lang))
return
# Send the details
try:
await message.channel.send(media_info)
except errors.HTTPException:
await message.channel.send(trans.get("MSG_IMDB_ERROR", lang))
async def on_message(self, message, **kwargs):
client = self.client
trans = self.trans
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
# !status
if startswith(prefix + "status"):
server_count = 0
members = 0
channels = 0
# Iterate though servers and add up things
for guild in client.guilds:
server_count += 1
members += int(guild.member_count)
channels += len(guild.channels)
embed = Embed(name=trans.get("MSG_STATUS_STATS", lang),
colour=Colour.dark_blue())
embed.add_field(name=trans.get("MSG_STATUS_SERVERS", lang),
value=trans.get("MSG_STATUS_SERVERS_L",
lang).format(server_count),
inline=True)
embed.add_field(name=trans.get("MSG_STATUS_USERS", lang),
value=trans.get("MSG_STATUS_USERS_L",
lang).format(members),
inline=True)
embed.add_field(name=trans.get("MSG_STATUS_CHANNELS", lang),
value=trans.get("MSG_STATUS_CHANNELS_L",
lang).format(channels),
inline=True)
await message.channel.send("**Stats**", embed=embed)
# !debug
elif startswith(prefix + "debug", prefix + "stats more"):
# Some more debug data
# Ratelimit every 360 seconds
if ((self.lt - time.time()) <
360) and not self.handler.is_bot_owner(message.author.id):
await message.channel.send(
trans.get("MSG_STATUS_RATELIMIT", lang))
return
self.lt = time.time()
# CPU
cpu = psutil.cpu_percent(interval=0.3)
# RAM
def get_ram_usage():
nano_process = psutil.Process(os.getpid())
return round(nano_process.memory_info()[0] / float(2**20),
1) # Converts to MB
mem_before = get_ram_usage()
# Attempt garbage collection
gc.collect()
mem_after = get_ram_usage()
garbage = round(mem_after - mem_before, 2)
# OTHER
nano_version = self.nano.version
discord_version = d_version
reminders = self.nano.get_plugin(
"reminder").instance.reminder.get_reminder_amount()
polls = self.nano.get_plugin(
"voting").instance.vote.get_vote_amount()
# Redis db stats
redis_mem = self.handler.db_info("memory").get("used_memory_human")
redis_size = self.handler.db_size()
fields = trans.get("MSG_DEBUG_MULTI",
lang).format(nano_version,
discord_version, mem_after,
abs(garbage), cpu, reminders,
polls, redis_mem, redis_size)
total_shards = len(self.client.shards.keys())
current_shard = message.guild.shard_id
additional = trans.get("MSG_DEBUG_MULTI_2",
lang).format(total_shards, current_shard)
await message.channel.send(fields + "\n" + additional)
# !prefix
elif startswith(prefix + "prefix"):
await message.channel.send(trans.get("MSG_PREFIX_OHYEAH", lang))
# nano.prefix
elif startswith("nano.prefix"):
await message.channel.send(
trans.get("MSG_PREFIX", lang).format(prefix))
# !members
elif startswith(prefix + "members"):
ls = [member.name for member in message.guild.members]
amount = len(ls)
members = trans.get("MSG_MEMBERS_LIST", lang).format(", ".join(["`{}`".format(mem) for mem in ls])) + \
trans.get("MSG_MEMBERS_TOTAL", lang).format(amount)
if len(members) > 2000:
# Only send the number if the message is too long.
await message.channel.send(
trans.get("MSG_MEMBERS_AMOUNT", lang).format(amount))
else:
await message.channel.send(members)
# !server
elif startswith(prefix + "server"):
user_count = message.guild.member_count
users_online = len([
user.id for user in message.guild.members
if user.status == user.status.online
])
v_level = message.guild.verification_level
if v_level == v_level.none:
v_level = trans.get("MSG_SERVER_VL_NONE", lang)
elif v_level == v_level.low:
v_level = trans.get("MSG_SERVER_VL_LOW", lang)
elif v_level == v_level.medium:
v_level = trans.get("MSG_SERVER_VL_MEDIUM", lang)
else:
v_level = trans.get("MSG_SERVER_VL_HIGH", lang)
text_chan = len(message.guild.text_channels)
voice_chan = len(message.guild.voice_channels)
channels = text_chan + voice_chan
# Teal Blue
embed = Embed(colour=Colour(0x3F51B5),
description=trans.get("MSG_SERVER_ID",
lang).format(message.guild.id))
if message.guild.icon:
embed.set_author(name=message.guild.name,
icon_url=message.guild.icon_url)
embed.set_thumbnail(url=message.guild.icon_url)
else:
embed.set_author(name=message.guild.name)
embed.set_footer(text=trans.get("MSG_SERVER_DATE_CREATED", lang).
format(message.guild.created_at))
embed.add_field(name=trans.get("MSG_SERVER_MEMBERS",
lang).format(user_count),
value=trans.get("MSG_SERVER_MEMBERS_L",
lang).format(users_online))
embed.add_field(name=trans.get("MSG_SERVER_CHANNELS",
lang).format(channels),
value=trans.get("MSG_SERVER_CHANNELS_L",
lang).format(
voice_chan, text_chan))
embed.add_field(name=trans.get("MSG_SERVER_VL", lang),
value=v_level)
embed.add_field(
name=trans.get("MSG_SERVER_ROLES", lang),
value=trans.get("MSG_SERVER_ROLES_L",
lang).format(len(message.guild.roles) - 1))
owner = message.guild.owner
embed.add_field(name=trans.get("MSG_SERVER_OWNER", lang),
value=trans.get("MSG_SERVER_OWNER_L", lang).format(
owner.name, owner.discriminator, owner.id))
await message.channel.send(trans.get("MSG_SERVER_INFO", lang),
embed=embed)
async def on_message(self, message, **kwargs):
client = self.client
trans = self.trans
prefix = kwargs.get("prefix")
lang = kwargs.get("lang")
# Custom commands registered for the server
server_commands = self.handler.get_custom_commands_keys(
message.guild.id)
if server_commands:
# According to tests, .startswith is faster than slicing, m8pls
for k in server_commands:
k = str(k)
if message.content.startswith(k):
# raw_resp = self.handler.get_custom_command_by_key(message.guild.id, k)
# response = self.parser.parse(raw_resp, message)
response = self.handler.get_custom_command_by_key(
message.guild.id, k)
await message.channel.send(response)
return
# 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
# COMMANDS
# !hello
if startswith(prefix + "hello"):
argument = message.content[len(prefix + "hello "):]
# Parse mentions or name
if argument:
if len(message.mentions) > 0:
mention = message.mentions[0].mention
else:
# Find user
usr = utils.find(lambda a: a.name == argument,
message.guild.members)
if not usr:
mention = message.author.mention
else:
mention = usr.mention
else:
mention = message.author.mention
if len(message.mentions) >= 1:
await message.channel.send(
trans.get("INFO_HI", lang).format(mention))
elif len(message.mentions) == 0:
await message.channel.send(
trans.get("INFO_HI", lang).format(mention))
# !uptime
elif startswith(prefix + "uptime"):
d = datetime(
1, 1, 1) + timedelta(seconds=time.time() - self.nano.boot_time)
uptime = trans.get("MSG_UPTIME",
lang).format(d.day - 1, d.hour, d.minute,
d.second)
await message.channel.send(uptime)
# !nano, nano.info
elif startswith((prefix + "nano", "nano.info")):
await message.channel.send(
trans.get("INFO_GENERAL", lang).format(p=prefix,
ver=self.nano.version))
# !github
elif startswith(prefix + "github"):
await message.channel.send(trans.get("INFO_GITHUB", lang))
# !roll [number]
elif startswith(prefix + "roll", prefix + "rng "):
if startswith(prefix + "roll"):
num = message.content[len(prefix + "roll "):]
else:
num = message.content[len(prefix + "rng "):]
if not num.isnumeric():
await message.channel.send(trans.get("ERROR_NOT_NUMBER", lang))
return
rn = randint(0, int(num))
result = "**{}**. {}".format(rn,
"**GG**" if rn == int(num) else "")
await message.channel.send(
trans.get("MSG_ROLL", lang).format(message.author.mention,
result))
# !dice [dice expression: 5d6 + 1d8]
elif startswith(prefix + "dice"):
cut = message.content[len(prefix + "dice "):]
# Defaults to a normal dice
if not cut:
dice_types = ["1d6"]
else:
dice_types = [a.strip(" ") for a in cut.split("+")]
# To prevent lag
if len(dice_types) > MAX_DICE_EXPR:
await message.channel.send(
trans.get("MSG_DICE_TOO_MANY", lang).format(MAX_DICE_EXPR))
return
results = []
tt = 0
for dice in dice_types:
try:
times, sides = dice.split("d")
times, sides = int(times), int(sides)
if sides <= 0 or times <= 0:
raise ValueError("can't roll 0 sides/times")
except ValueError:
await message.channel.send(
trans.get("MSG_DICE_INVALID",
lang).replace("_", prefix))
return
if times > MAX_DICE or sides > MAX_DICE:
await message.channel.send(
trans.get("MSG_DICE_TOO_BIG", lang).format(MAX_DICE))
return
total = 0
for _ in range(times):
total += randint(1, sides)
tt += total
results.append(
trans.get("MSG_DICE_ENTRY", lang).format(dice, total))
await message.channel.send(
trans.get("MSG_DICE_RESULTS",
lang).format(message.author.mention,
"\n".join(results), tt))
# !ping
elif startswith(prefix + "ping"):
base_time = datetime.now() - message.created_at
base_taken = int(divmod(base_time.total_seconds(), 60)[1] * 1000)
a = await message.channel.send(
trans.get("MSG_PING_MEASURING", lang))
self.pings[a.id] = [time.monotonic(), a, base_taken]
# Thumbs up
await a.add_reaction("\U0001F44D")
self.stats.add(PING)
# !decide [item1]|[item2]|etc...
elif startswith(prefix + "decide"):
cut = str(message.content)[len(prefix + "decide "):].strip(" ")
if not cut:
await message.channel.send(
trans.get("MSG_DECIDE_NO_ARGS", lang))
return
# If | is not used, try spaces
options = cut.split("|")
if len(options) == 1:
options = cut.split(" ")
if len(options) == 1:
await message.channel.send(
trans.get("MSG_DECIDE_SPECIAL", lang).format(cut))
else:
rn = randint(0, len(options) - 1)
await message.channel.send(
trans.get("MSG_DECIDE_NORMAL", lang).format(options[rn]))
# !8ball
elif startswith(prefix + "8ball"):
eight_ball = [
a.strip(" ")
for a in trans.get("MSG_8BALL_STRINGS", lang).split("|")
]
answer = eight_ball[randint(0, len(eight_ball) - 1)]
await message.channel.send(
trans.get("MSG_8BALL", lang).format(answer))
# !quote
elif startswith(prefix + "quote"):
chosen = str(quotes[randint(0, len(quotes) - 1)])
# Find the part where the author is mentioned
place = chosen.rfind("–")
await message.channel.send("{}\n- __{}__".format(
chosen[:place], chosen[place + 1:]))
# !invite
elif startswith(prefix + "invite", "nano.invite"):
# ONLY FOR TESTING - if nano beta is active
if startswith("nano.invite.make_real"):
application = await client.application_info()
# Most of the permissions that Nano uses
perms = "1543765079"
url = "<https://discordapp.com/oauth2/" \
"authorize?client_id={}&scope=bot&permissions={}>".format(application.id, perms)
await message.channel.send(
trans.get("INFO_INVITE", lang).replace("<link>", url))
return
await message.channel.send(
trans.get("INFO_INVITE",
lang).replace("<link>",
"<http://invite.nanobot.pw>"))
# !avatar
elif startswith(prefix + "avatar"):
name = message.content[len(prefix + "avatar "):]
if not name:
member = message.author
else:
member = await self.resolve_user(name, message, lang)
url = member.avatar_url
if url:
await message.channel.send(
trans.get("MSG_AVATAR_OWNERSHIP",
lang).format(member.name, url))
else:
await message.channel.send(
trans.get("MSG_AVATAR_NONE", lang).format(member.name))
# !say (#channel) [message]
elif startswith(prefix + "say"):
if not self.handler.is_mod(message.author, message.guild):
await message.channel.send(trans.get("PERM_MOD", lang))
return "return"
content = str(message.content[len(prefix + "say "):]).strip(" ")
if not content:
await message.channel.send(
trans.get("ERROR_INVALID_CMD_ARGUMENTS", lang))
return
if len(message.channel_mentions) != 0:
channel = message.channel_mentions[0]
content = content.replace(channel.mention, "").strip(" ")
else:
channel = message.channel
content = self.at_everyone_filter(content, message.author)
try:
await channel.send(content)
await self.log_say_command(message, content, prefix, lang)
except Forbidden:
await message.channel.send(
trans.get("MSG_SAY_NOPERM", lang).format(channel.id))
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
prefix = kwargs.get("prefix")
trans = self.trans
lang = kwargs.get("lang")
if not is_valid_command(message.content, commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "wiki", prefix + "define"):
if startswith(prefix + "wiki"):
search = str(message.content)[len(prefix +
"wiki "):].strip(" ")
elif startswith(prefix + "define"):
search = str(message.content)[len(prefix +
"define "):].strip(" ")
else:
# Not possible, but k
return
if not search:
await message.channel.send(trans.get("MSG_WIKI_NO_QUERY",
lang))
return
summary = await self.wiki.get_definition(search)
if not summary:
await message.channel.send(trans.get("MSG_WIKI_NO_DEF", lang))
return
await message.channel.send(
trans.get("MSG_WIKI_DEFINITION", lang).format(
search, add_dots(summary, max_len=MAX_WIKI_LENGTH)))
elif startswith(prefix + "urban"):
search = str(message.content)[len(prefix + "urban "):].strip(" ")
if not search:
await message.channel.send(
trans.get("MSG_URBAN_NO_QUERY", lang))
return
description = await self.urban.urban_dictionary(search)
if not description:
await message.channel.send(trans.get("MSG_URBAN_NO_DEF", lang))
return
await message.channel.send(
trans.get("MSG_URBAN_DEFINITION", lang).format(
search, add_dots(description, max_len=MAX_URBAN_LENGTH)))
async def on_message(self, message, **kwargs):
trans = self.trans
prefix = kwargs.get("prefix")
lang = kwargs.get("lang")
# If any of the commands match, add user to statistics
if message.content.startswith(prefix):
np_text = message.content[len(prefix):]
else:
np_text = message.content
np_text = "_" + np_text.split(" ", maxsplit=1)[0]
if np_text in self.valid_commands:
# Register user to stats
self.adv_stats.track_user(message.author.id, message.guild.id)
# 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
# !stats
if startswith(prefix + "stats"):
stats = self.stats.get_data()
messages = stats.get("msgcount") or 0
wrong_args = stats.get("wrongargcount") or 0
sleeps = stats.get("timesslept") or 0
wrong_permissions = stats.get("wrongpermscount") or 0
helps = stats.get("peoplehelped") or 0
votes = stats.get("votesgot") or 0
pings = stats.get("timespinged") or 0
imgs = stats.get("imagessent") or 0
embed = Embed(colour=Colour.gold())
embed.add_field(name=trans.get("MSG_STATS_MSGS", lang),
value=messages)
embed.add_field(name=trans.get("MSG_STATS_ARGS", lang),
value=wrong_args)
embed.add_field(name=trans.get("MSG_STATS_PERM", lang),
value=wrong_permissions)
embed.add_field(name=trans.get("MSG_STATS_HELP", lang),
value=helps)
embed.add_field(name=trans.get("MSG_STATS_IMG", lang), value=imgs)
embed.add_field(name=trans.get("MSG_STATS_VOTES", lang),
value=votes)
embed.add_field(name=trans.get("MSG_STATS_SLEPT", lang),
value=sleeps)
embed.add_field(name=trans.get("MSG_STATS_PONG", lang),
value=pings)
embed.add_field(name=trans.get("MSG_STATS_IMG", lang), value=imgs)
await message.channel.send(trans.get("MSG_STATS_INFO", lang),
embed=embed)
# !advancedstats
elif startswith(prefix + "advancedstats"):
u_users, u_guilds = self.adv_stats.get_statistics_uniques()
data = self.adv_stats.get_statistics_history()
description = trans.get("MSG_ADVS_DESC", lang).format(u_users, u_guilds) \
+ "\n\n"\
+ trans.get("MSG_ADVS_HISTORY", lang)\
+ trans.get("MSG_ADVS_HISTORY_BODY", lang).format(
day_u=data["day"]["users"],
day_g=data["day"]["guilds"],
week_u=data["week"]["users"],
week_g=data["week"]["guilds"],
month_u=data["month"]["users"],
month_g=data["month"]["guilds"],
)
embed = Embed(title=trans.get("MSG_ADVS_TITLE",
lang).format(NanoPlugin.version),
description=description)
await message.channel.send(embed=embed)
async def on_message(self, message, **kwargs):
trans = self.trans
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
# !poll start
# Arguments: "[title]" [option1]|(option2)|...
# OR : "[title]" [option1],(option2),...
if startswith(prefix + "poll start"):
if not self.handler.is_admin(message.author, message.guild):
await message.channel.send(trans.get("PERM_ADMIN", lang))
self.stats.add(WRONG_PERMS)
return
if self.vote.in_progress(message.guild.id):
await message.channel.send(
trans.get("MSG_VOTING_IN_PROGRESS", lang))
return
arguments = message.content[len(prefix +
"poll start "):].strip(" ")
if not arguments:
await message.channel.send(
trans.get("MSG_VOTING_I_USAGE", lang).format(prefix))
return
# TITLE
# Handle short_title, "longer title", 'also like this'
if arguments[0] == "\"":
_, title, arguments = arguments.split("\"", maxsplit=3)
elif arguments[0] == "'":
_, title, arguments = arguments.split("'", maxsplit=3)
else:
title, arguments = arguments.split(" ", maxsplit=1)
arguments = arguments.lstrip(" ")
# CHOICES
# | as separator
if "|" in arguments:
items = [a.strip(" ") for a in arguments.split("|") if a]
# , used as separator
else:
items = [a.strip(" ") for a in arguments.split(",") if a]
# Send an error if there's only a title
if len(items) < 2:
await message.channel.send(
trans.get("MSG_VOTING_NEED_OPTIONS", lang).format(prefix))
return
# END OF ARGUMENT PARSING
# Check item amount
if len(items) > VOTE_ITEM_LIMIT:
await message.channel.send(
trans.get("MSG_VOTING_OPTIONS_TM",
lang).format(VOTE_ITEM_LIMIT, len(items)))
return
# Check total length
if (len(title) + sum([len(a)
for a in items])) > VOTE_ITEM_MAX_LENGTH:
await message.channel.send(
trans.get("MSG_VOTING_OPTIONS_TL ",
lang).format(VOTE_ITEM_MAX_LENGTH,
sum([len(a) for a in items])))
return
# Check if any option is empty
if any(e == "" for e in items):
await message.channel.send(
trans.get("MSG_VOTING_EMPTY_ITEM", lang))
return
self.vote.start_vote(message.author.id, message.guild.id, title,
items)
# Generates a list of options to show
choices = "\n\n".join([
"[{}]\n{}".format(en + 1, ch) for en, ch in enumerate(
self.vote.get_choices(message.guild.id))
])
await message.channel.send(
trans.get("MSG_VOTING_STARTED", lang).format(title, choices))
# !poll end
elif startswith(prefix + "poll end"):
if not self.handler.is_admin(message.author, message.guild):
await message.channel.send(trans.get("PERM_ADMIN", lang))
self.stats.add(WRONG_PERMS)
return
if not self.vote.in_progress(message.guild.id):
await message.channel.send(
trans.get("MSG_VOTING_NO_PROGRESS", lang))
return
# Wait for confirmation
msg = await message.channel.send(
trans.get("MSG_VOTING_END_CONFIRMATION",
lang).format(OK_EMOJI))
await msg.add_reaction(OK_EMOJI)
def check(reaction, user):
return user == message.author and str(
reaction.emoji) == OK_EMOJI
try:
await self.client.wait_for('reaction_add',
timeout=45,
check=check)
except asyncio.TimeoutError:
await message.channel.send(
trans.get("MSG_VOTING_END_ABORT", lang))
return
await msg.delete()
votes = self.vote.get_votes(message.guild.id)
title = self.vote.get_title(message.guild.id)
total_votes = sum(votes.values())
embed = Embed(title="**{}**".format(title),
colour=Colour(0x303F9F),
description=trans.get("MSG_VOTING_AMOUNT",
lang).format(total_votes))
for name, val in votes.items():
# Zero-width space
dotted = add_dots(name, max_len=240) or "\u200B"
embed.add_field(name=dotted,
value=trans.get("MSG_VOTING_AMOUNT2",
lang).format(val))
# Actually end the voting
self.vote.end_voting(message.guild.id)
try:
await message.channel.send(
trans.get("MSG_VOTING_ENDED", lang) + "\n", embed=embed)
except errors.HTTPException as e:
await message.channel.send(trans.get("MSG_VOTING_ERROR", lang))
log_to_file("VOTING ({}): {}".format(e, embed.to_dict()),
"bug")
# !poll status
elif startswith(prefix + "poll status"):
if not self.vote.in_progress(message.guild.id):
await message.channel.send(
trans.get("MSG_VOTING_NO_PROGRESS", lang))
return
header = self.vote.get_title(message.guild.id)
votes = sum(self.vote.get_votes(message.guild.id).values())
if votes == 0:
vote_disp = trans.get("MSG_VOTING_S_NONE", lang)
elif votes == 1:
vote_disp = trans.get("MSG_VOTING_S_ONE", lang)
else:
vote_disp = trans.get("MSG_VOTING_S_MULTI", lang).format(votes)
await message.channel.send(
trans.get("MSG_VOTING_STATUS", lang).format(header, vote_disp))
# !vote
elif startswith(prefix + "vote"):
# Ignore if there is no vote going on instead of getting an exception
if not self.vote.in_progress(message.guild.id):
await message.add_reaction(X_EMOJI)
msg = await message.channel.send(
trans.get("MSG_VOTING_NO_PROGRESS", lang))
await asyncio.sleep(2)
await msg.delete()
return
# Get the choice, but tell the author if he/she didn't supply a number
try:
choice = int(message.content[len(prefix + "vote "):]) - 1
# Cannot convert to int
except ValueError:
await message.add_reaction(BLOCK_EMOJI)
m = await message.channel.send(
trans.get("MSG_VOTING_NOT_NUMBER", lang))
await asyncio.sleep(2)
await m.delete()
return
res = self.vote.plus_one(choice, message.author.id,
message.guild.id)
# User already voted
if res == -1:
await message.add_reaction(BLOCK_EMOJI)
msg = await message.channel.send(
trans.get("MSG_VOTING_CHEATER", lang))
await asyncio.sleep(2)
await msg.delete()
# No such option
elif not res:
await message.add_reaction(X_EMOJI)
msg = await message.channel.send(
trans.get("MSG_VOTING_INVALID_NUMBER", lang))
await asyncio.sleep(2)
await msg.delete()
# Everything ok, was added
else:
await message.add_reaction(OK_EMOJI)
self.stats.add(VOTE)
async def on_message(self, message, **kwargs):
trans = self.trans
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
# !remind me in [time]:[text] or [time] to [text]
if startswith(prefix + "remind me in"):
try:
r_time, text = await self.parse_parameters(
message,
len(prefix) + 13, lang,
trans.get("MSG_REMINDER_WU_ME",
lang).format(prefix=prefix))
# Raised when reminder content is too long
except ValueError:
await message.channel.send(
trans.get("MSG_REMINDER_TOO_LONG_CONTENT",
lang).format(REM_MAX_CONTENT))
return
resp = self.reminder.set_reminder(message.author, message.author,
text, r_time, lang)
# Too many reminders going on
if resp == -1:
await message.channel.send(
trans.get("MSG_REMINDER_LIMIT_EXCEEDED",
lang).format(DEFAULT_REMINDER_LIMIT))
# Invalid range
elif resp is False:
await message.channel.send(
trans.get("MSG_REMINDER_INVALID_RANGE",
lang).format(REM_MIN_DURATION, REM_MAX_DAYS))
# Everything valid
else:
await message.channel.send(trans.get("MSG_REMINDER_SET", lang))
# !remind here in [time]:[reminder]
elif startswith(prefix + "remind here in"):
try:
r_time, text = await self.parse_parameters(
message,
len(prefix) + 13, lang,
trans.get("MSG_REMINDER_WU_HERE",
lang).format(prefix=prefix))
# Raised when reminder content is too long
except ValueError:
await message.channel.send(
trans.get("MSG_REMINDER_TOO_LONG_CONTENT",
lang).format(REM_MAX_CONTENT))
return
resp = self.reminder.set_reminder(message.channel,
message.author,
text,
r_time,
lang,
reminder_type=REMINDER_CHANNEL)
if resp == -1:
await message.channel.send(
trans.get("MSG_REMINDER_LIMIT_EXCEEDED",
lang).format(DEFAULT_REMINDER_LIMIT))
elif resp is False:
await message.channel.send(
trans.get("MSG_REMINDER_INVALID_RANGE",
lang).format(REM_MIN_DURATION, REM_MAX_DAYS))
else:
await message.channel.send(trans.get("MSG_REMINDER_SET", lang))
# !remind list
elif startswith(prefix + "remind list", prefix + "reminder list"):
reminders = self.reminder.get_reminders(message.author.id)
if not reminders:
await message.channel.send(
trans.get("MSG_REMINDER_LIST_NONE", lang))
return
rem = []
rem_literal = trans.get("MSG_REMINDER_LIST_L", lang)
for reminder in reminders.values():
# Gets the remaining time
ttl = int(reminder["time_target"]) - time.time()
cont = self.filter(reminder.get("raw"), message.author)
# Zero or negative number
if ttl <= 0:
when = trans.get("MSG_REMINDER_SOON", lang)
else:
when = resolve_time(ttl, lang)
rem.append(rem_literal.format(cont, when))
await message.channel.send(
trans.get("MSG_REMINDER_LIST", lang).format("\n\n".join(rem)))
# !remind remove
elif startswith(prefix + "remind remove"):
r_name = message.content[len(prefix + "remind remove "):]
if not r_name:
await message.channel.send(
trans.get("ERROR_INVALID_CMD_ARGUMENTS", lang))
return
if r_name == "all":
self.reminder.remove_all_reminders(message.author.id)
await message.channel.send(
trans.get("MSG_REMINDER_DELETE_ALL", lang))
return
else:
r_id = self.reminder.find_id_from_content(
message.author.id, r_name)
# No reminder with such content
if not r_id:
await message.channel.send(
trans.get("MSG_REMINDER_DELETE_NONE", lang))
else:
self.reminder.remove_reminder(message.author.id, r_id)
await message.channel.send(
trans.get("MSG_REMINDER_DELETE_SUCCESS", lang))
# !remind help
elif startswith(prefix + "remind"):
await message.channel.send(
trans.get("MSG_REMINDER_HELP", lang).format(prefix=prefix))
async def on_message(self, message, **kwargs):
trans = self.trans
mc = self.mc
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
# !mc
if startswith(prefix + "mc"):
argument = message.content[len(prefix + "mc "):].strip(" ").lower()
if not argument:
await message.channel.send(trans.get("MSG_MC_PLSARUGMENTS", lang))
return
# !mc help
if argument == "help":
await message.channel.send(trans.get("MSG_MC_HELP", lang).replace("_", prefix))
return
# Argument is name
if not is_number(argument.split(":")[0]):
# Check for groupings
gr = mc.get_group_by_name(argument)
if gr:
data = gr
# Not a group
else:
data = mc.find_by_name(str(argument))
# Argument is id and meta
else:
try:
i_type, i_meta = argument.split(":")
except ValueError:
i_type, i_meta = argument, 0
data = mc.find_by_id_meta(i_type, i_meta)
if not data:
await message.channel.send(trans.get("MSG_MC_NO_ITEMS", lang))
self.stats.add(WRONG_ARG)
return
# One item, not a group
if not isinstance(data, list):
details = trans.get("MSG_MC_DETAILS", lang).format(data.get("name"), data.get("type"), data.get("meta"))
# Details are uploaded simultaneously with the picture
# No image
path = mc.get_picture_path_by_item(data)
if not path:
await message.channel.send(details)
self.stats.add(IMAGE_SENT)
else:
with open(mc.get_picture_path_by_item(data), "rb") as pic:
await message.channel.send(details, file=File(pic))
self.stats.add(IMAGE_SENT)
# Multiple items, a group
else:
combined = []
for item in data:
details = trans.get("MSG_MC_DETAILS", lang).format(item.get("name"), item.get("type"), item.get("meta"))
combined.append(details)
await message.channel.send("".join(combined))
async def on_message(self, message, **kwargs):
prefix = kwargs.get("prefix")
trans = self.trans
lang = kwargs.get("lang")
if not is_valid_command(message.content, commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "steam"):
await message.channel.trigger_typing()
cut = message.content[len(prefix + "steam "):].strip(" ")
try:
subcommand, argument = cut.split(" ", maxsplit=1)
# In case there are no parameters
except ValueError:
# Check if no subcommand - valid
# If there's a subcommand, but no argument, fail
if not cut.strip(" "):
await message.channel.send(
trans.get("MSG_STEAM_INVALID_PARAMS",
lang).format(prefix))
return
subcommand, argument = cut, ""
# !steam games
if subcommand == "games":
if not argument:
await message.channel.send(
trans.get("MSG_STEAM_NEED_URL", lang))
return
# Game search
try:
username, games = await self.steam.get_owned_games(argument
)
except ValueError:
await message.channel.send(
trans.get("MSG_STEAM_INVALID_URL", lang))
return
except (steamapi.errors.APIFailure,
steamapi.errors.APIException,
steamapi.errors.AccessException):
await message.channel.send(
trans.get("MSG_STEAM_PRIVATE", lang))
raise
if not username:
await message.channel.send(
trans.get("ERROR_NO_USER2", lang))
self.stats.add(WRONG_ARG)
return
if not games:
await message.channel.send(
trans.get("MSG_STEAM_PRIVATE_GAMES", lang))
self.stats.add(WRONG_ARG)
return
games = ["`{}`".format(game) for game in games]
try:
await message.channel.send(
trans.get("MSG_STEAM_GAMES",
lang).format(username,
filter_text(", ".join(games))))
except HTTPException:
await message.channel.send(
trans.get("MSG_STEAM_GAMES_TOO_MANY", lang))
elif subcommand == "user":
if not argument:
await message.channel.send(
trans.get("MSG_STEAM_NEED_URL", lang))
return
# Basic search
try:
steam_user = await self.steam.get_user(argument)
except ValueError:
await message.channel.send(
trans.get("MSG_STEAM_INVALID_URL", lang))
return
except (steamapi.errors.APIFailure,
steamapi.errors.APIException):
await message.channel.send(
trans.get("MSG_STEAM_PRIVATE", lang))
raise
if not steam_user:
await message.channel.send(
trans.get("ERROR_NO_USER2", lang))
self.stats.add(WRONG_ARG)
return
state = trans.get("MSG_STEAM_ONLINE",
lang) if steam_user.state else trans.get(
"MSG_STEAM_OFFLINE", lang)
try:
info = trans.get("MSG_STEAM_USER_INFO",
lang).format(steam_user.name, state,
steam_user.level,
len(steam_user.games),
len(steam_user.friends),
argument)
except AttributeError:
await message.channel.send(
trans.get("MSG_STEAM_PRIVATE", lang))
return
if len(info) > 2000:
await message.channel.send(
trans.get("MSG_STEAM_FRIENDS_TOO_MANY", lang))
else:
await message.channel.send(filter_text(info))
elif subcommand == "help":
await message.channel.send(
trans.get("MSG_STEAM_HELP", lang).replace("!", prefix))
async def on_message(self, message, *_, **kwargs):
trans = self.trans
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
# Bare !help
if message.content.strip(" ") == (prefix + "help"):
await message.channel.send(
trans.get("MSG_HELP", lang).format(prefix=prefix))
self.stats.add(HELP)
# !cmds or !commands
elif startswith(prefix + "cmds", prefix + "commands"):
if startswith(prefix + "cmds"):
arg = message.content[len(prefix + "cmds "):].lower()
else:
arg = message.content[len(prefix + "commands "):].lower()
if not arg or not cmd_links.get(arg):
await message.channel.send(trans.get("MSG_HELP_CMDWEB", lang))
else:
ending = cmd_links.get(arg)
full_link = BASE_CMDS_LINK + ending
await message.channel.send(
trans.get("MSG_HELP_CMD_SPEC", lang).format(full_link))
self.stats.add(HELP)
# !help simple
elif startswith(prefix + "help simple"):
await message.channel.send(
trans.get("MSG_HELP_SIMPLE", lang).format(prefix=prefix))
self.stats.add(HELP)
# !help [command]
elif startswith(prefix + "help"):
search = str(message.content)[len(prefix + "help "):]
# Allows for !help ping AND !help !ping
if search.startswith(prefix) or search.startswith("nano."):
name, embed = self.get_command_info(search, prefix, lang)
if name:
await message.channel.send(name, embed=embed)
else:
await message.channel.send(
trans.get("MSG_HELP_CMDNOTFOUND",
lang).format(prefix=prefix))
else:
name, embed = self.get_command_info(prefix + search, prefix,
lang)
if name:
await message.channel.send(name, embed=embed)
else:
await message.channel.send(
trans.get("MSG_HELP_CMDNOTFOUND",
lang).format(prefix=prefix))
self.stats.add(HELP)
# !notifydev
# Not translated
elif startswith(prefix + "suggest"):
report = message.content[len(prefix + "suggest "):].strip(" ")
# Disallow empty reports
if not report:
await message.channel.send(trans.get("MSG_REPORT_EMPTY", lang))
return
# :P
if report in ("hi", "hello"):
await message.channel.send(trans.get("MSG_REPORT_EE_THX",
lang))
return
# Cooldown implementation
if not self.last_times.get(message.author.id):
self.last_times[message.author.id] = time.time()
else:
# 300 seconds --> 5 minute cooldown
if (time.time() - self.last_times[message.author.id]) < 300:
await message.channel.send(
trans.get("MSG_REPORT_RATELIMIT", lang))
return
else:
self.last_times[message.author.id] = time.time()
dev_server = self.client.get_guild(self.nano.dev_server)
owner = dev_server.get_member(self.nano.owner_id)
# Timestamp
ts = datetime.now().strftime("%d.%m.%Y %H:%M:%S")
# Reused stuff
name = message.author.name
u_id = message.author.id
guild_name = message.guild.name
guild_id = message.guild.id
guild_owner = message.guild.owner
guild_members = message.guild.member_count
owner_info = "Yes" if message.author == guild_owner else "{}:{}".format(
guild_owner.id, guild_owner.id)
# 'Compiled' report
# NOT TRANSLATED!!
comp = "Suggestion from {} ({}):\n```{}```\n**__Timestamp__**: `{}`" \
"\n**__Server__**: `{}` ID:{} ({} members)\n**__Server Owner__**: {}" \
"\n**Language used:** `{}`".format(name, u_id, report, ts, guild_name, guild_id, guild_members, owner_info, lang)
# Saves the submission
to_file = "Suggestion from {0}:{1}\nMessage: {2}\n" \
"Server: {3}:{4} with {5} members\nServer owner: {6}\n" \
"Language used: {7}".format(name, u_id, report, guild_name, guild_id, guild_members, owner_info, lang)
save_submission(to_file)
await owner.send(comp)
await message.channel.send(trans.get("MSG_REPORT_THANKS", lang))
# !bug
elif startswith(prefix + "bug"):
await message.channel.send(trans.get("MSG_BUG", lang))
# !tos
elif startswith(prefix + "tos"):
await message.channel.send(trans.get("MSG_TOS", lang))
async def on_message(self, message, **kwargs):
trans = self.trans
prefix = kwargs.get("prefix")
lang = kwargs.get("lang")
simple_commands = {"( ͡° ͜ʖ ͡°)": trans.get("MSG_WHOKNOWS", lang)}
# Loop over simple commands
for k, v in simple_commands.items():
if message.content.startswith(k):
await message.channel.send(v)
self.stats.add(MESSAGE)
return
# 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
# Other commands
if startswith(prefix + "kappa"):
await message.channel.send(file=File(KAPPA_LOCATION, "kappa.png"))
self.stats.add(IMAGE_SENT)
# !randomgif (optional_tag)
elif startswith(prefix + "randomgif"):
tags = message.content[len(prefix + "randomgif "):]
gif = await self.gif.get_random_gif(tags or None)
nonexistent = False
if gif == -1:
await message.channel.send(trans.get("MSG_GIPHY_TOOFAST",
lang))
return
# Gif with such tag does not exist, fall back to random one
if gif is None:
gif = await self.gif.get_random_gif()
nonexistent = True
embed = Embed(colour=Colour(GIPHY_GREEN))
embed.set_image(url=gif)
if not nonexistent:
embed.set_footer(text=trans.get("MSG_GIPHY_POWEREDBY", lang))
else:
that_text = trans.get(
"MSG_GIPHY_POWEREDBY", lang) + " | " + trans.get(
"MSG_GIPHY_NOSUCHTAG", lang).format(add_dots(tags, 20))
embed.set_footer(text=that_text)
await message.channel.send(embed=embed)
self.stats.add(IMAGE_SENT)
# !meme [meme name]|[top text]|[bottom text]
elif startswith(prefix + "meme"):
query = message.content[len(prefix + "meme "):]
if not query:
await message.channel.send(
trans.get("ERROR_INVALID_CMD_ARGUMENTS", lang))
return
middle = [a.strip(" ") for a in query.split("|")]
# If only two arguments are passed, assume no bottom text
if len(middle) == 2:
name = middle[0]
top = middle[1]
bottom = ""
# 0, 1 or more than 3 arguments - error
elif len(middle) < 2 or len(middle) > 3:
await message.channel.send(
trans.get("MSG_MEME_USAGE", lang).replace("_", prefix))
return
# Normal
else:
name = middle[0]
top = middle[1]
bottom = middle[2]
meme = await self.generator.caption_meme(name, top, bottom)
if not meme:
await message.channel.send(
trans.get("MSG_MEME_NONEXISTENT", lang))
else:
embed = Embed(colour=Colour(0x607D8B))
embed.set_image(url=meme)
embed.set_footer(text=trans.get("MSG_MEME_FOOTER", lang))
await message.channel.send(embed=embed)
elif startswith(prefix + "rip"):
if len(message.mentions) == 1:
ripperoni = " " + message.mentions[0].name
elif len(message.mentions) == 0:
ripperoni = " " + message.content[len(prefix + "rip "):]
else:
ripperoni = ""
ripperoni = self.everyone_filter(ripperoni,
message.author,
force_remove=True)
prays = self.stats.get_amount(PRAYER)
await message.channel.send(
trans.get("MSG_RIP", lang).format(ripperoni, prays))
self.stats.add(PRAYER)
elif startswith(prefix + "achievement"):
text = message.content[len(prefix + "achievement "):].strip(" ")
if not text:
await message.channel.send(
trans.get("MSG_ACHIEVMENT_NOTEXT", lang))
return
img = self.achievement.create_image(text)
img_filename = "Achievement_{}.png".format(gen_id(4))
await message.channel.send(file=File(img, img_filename))
# Just in case GC fails
del img
async def on_message(self, message, **kwargs):
trans = self.trans
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
# !cat gif/jpg/png
if startswith(prefix + "cat"):
fmt = str(message.content[len(prefix + "cat"):]).strip(" ")
# GIF is the default type!
if fmt == "jpg":
type_ = "jpg"
elif fmt == "png":
type_ = "png"
else:
type_ = "gif"
pic = await self.cats.random_cat(type_)
if pic:
# Teal (blue-ish)
embed = Embed(colour=Colour(0x00796b))
embed.set_image(url=pic)
embed.set_footer(text=trans.get("MSG_CAT_FOOTER", lang))
await message.channel.send(embed=embed)
else:
await message.channel.send(trans.get("MSG_CAT_FAILED", lang))
self.stats.add(IMAGE_SENT)
# !xkcd random/number/latest
elif startswith(prefix + "xkcd"):
fmt = str(message.content[len(prefix + "xkcd"):]).strip(" ")
# Decides mode
fetch = "random"
if fmt:
if is_number(fmt):
# Check if number is valid
if int(fmt) > self.xkcd.last_num:
await message.channel.send(
trans.get("MSG_XKCD_NO_SUCH", lang))
return
else:
fetch = "number"
elif fmt == trans.get("INFO_RANDOM", lang) or fmt == "random":
fetch = "random"
# Any other argument means latest
else:
fetch = "latest"
# Default: random
else:
fetch == "random"
if fetch == "random":
xkcd = await self.xkcd.get_random_xkcd()
elif fetch == "number":
xkcd = await self.xkcd.get_xkcd_by_number(fmt)
# Can only mean latest
else:
xkcd = await self.xkcd.get_latest_xkcd()
# In case something went wrong
if not xkcd:
await message.channel.send(trans.get("MSG_XKCD_FAILED", lang))
log_to_file("XKCD: string {}, fetch: {}, got None".format(
fmt, fetch))
xkcd_link = self.xkcd.make_link(xkcd["num"])
embed = Embed(title=trans.get("MSG_XKCD",
lang).format(xkcd["num"]),
description=filter_text(xkcd["safe_title"]))
embed.set_image(url=xkcd["img"])
embed.set_footer(
text=trans.get("MSG_XKCD_SOURCE", lang).format(xkcd_link))
await message.channel.send(embed=embed)
# !joke (yo mama/chuck norris)
elif startswith(prefix + "joke"):
content = filter_text(self.joke.random_joke())
embed = Embed(description=content)
await message.channel.send(embed=embed)
async def on_message(self, message, **kwargs):
assert isinstance(message, Message)
prefix = kwargs.get("prefix")
trans = self.trans
lang = kwargs.get("lang")
if not is_valid_command(message.content, commands, prefix=prefix):
return
else:
self.stats.add(MESSAGE)
def startswith(*msg):
for a in msg:
if message.content.startswith(a):
return True
return False
if startswith(prefix + "wiki", prefix + "define"):
if startswith(prefix + "wiki"):
search = str(message.content)[len(prefix +
"wiki "):].strip(" ")
elif startswith(prefix + "define"):
search = str(message.content)[len(prefix +
"define "):].strip(" ")
else:
# Shouldn't happen, RuntimeError means startswith() is not working properly
raise RuntimeError
# filter mentions
search = filter_text(search)
if not search:
await message.channel.send(trans.get("MSG_WIKI_NO_QUERY",
lang))
return
summary = await self.wiki.get_definition(search)
if not summary:
await message.channel.send(trans.get("MSG_WIKI_NO_DEF", lang))
return
await message.channel.send(
trans.get("MSG_WIKI_DEFINITION", lang).format(
search,
add_dots(filter_text(summary), max_len=MAX_WIKI_LENGTH)))
elif startswith(prefix + "urban"):
search = str(message.content)[len(prefix + "urban "):].strip(" ")
if not search:
await message.channel.send(
trans.get("MSG_URBAN_NO_QUERY", lang))
return
# filter mentions
search = filter_text(search)
description = await self.urban.urban_dictionary(search)
if not description:
await message.channel.send(trans.get("MSG_URBAN_NO_DEF", lang))
return
await message.channel.send(
trans.get("MSG_URBAN_DEFINITION", lang).format(
search,
add_dots(filter_text(description),
max_len=MAX_URBAN_LENGTH)))
