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
# !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))