async def do(self, client: discord.Client, message: discord.Message, args: list, cfg={}):
if len(args) < 1:
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_unmute_help"))
return
if not config.get_key(message.server.id, "mute_role"):
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "bot_config_error", {"cmd": self.command(),
"key": "mute_role"}))
return
if not config.get_key(message.server.id, "admin_roles"):
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "bot_config_error", {"cmd": self.command(),
"key": "admin_roles"}))
return
nameToMute = " ".join(args)
for member in message.server.members:
if nameToMute.lower().strip() == member.name.lower():
for role in member.roles:
for check_role in config.get_key(message.server.id, "admin_roles"):
if role.name == check_role:
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_mute_admin"))
return
elif role.name == config.get_key(message.server.id, "mute_role"):
await client.remove_roles(member, role)
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_unmute", {
"mention": member.mention
}))
return
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_mute_notfound", {"name": nameToMute}))
def help(self, server_id: str):
_hlp = i18n.get_localized_str(server_id, "help_" + self.command())
if _hlp == "STRING NOT FOUND: help_" + self.command():
return "```" + config.get_key(server_id, "cmd_prefix") + \
self.command() + " " + i18n.get_localized_str(
server_id, "help_notfound"
) + "```"
return "```" + config.get_key(server_id, "cmd_prefix") + \
self.command() + " " + _hlp + "```"
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
from bot.stuff import commands, bot_version, find_cmd_class
if len(args) >= 1:
_cmd = find_cmd_class(args[0])
if _cmd.command() != "_____________nonecommandsrsly":
await client.send_message(message.author,
_cmd.help(message.server.id))
return
cmd = ""
for command in commands:
cmd_c = (command[1])()
if cmd_c.command() != "_____________nonecommandsrsly":
if not self._command_is_disabled(message.server.id,
cmd_c.command()):
if cmd_c.requiresAdmin():
acmd_fnd = False
if message.author.permissions_in(
message.channel).administrator:
cmd = cmd + " - " + config.get_key(
message.server.id,
"cmd_prefix") + cmd_c.command() + "\n"
else:
for role in message.author.roles:
if acmd_fnd: break
for check_role in config.get_key(
message.server.id, "admin_roles"):
if role.name == check_role:
cmd = cmd + " - " + config.get_key(message.server.id, "cmd_prefix") \
+ cmd_c.command() + "\n"
acmd_fnd = True
break
else:
cmd = cmd + " - " + config.get_key(
message.server.id,
"cmd_prefix") + cmd_c.command() + "\n"
await client.send_message(
message.author,
i18n.get_localized_str(message.server.id, "help", {
"commands": cmd,
"version": bot_version,
}))
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
if len(args) == 1:
key_name = args[0]
key = config.get_key(message.server.id, key_name)
ret = "\n"
if key:
if isinstance(key, list):
for k in key:
ret += " - {}\n".format(k)
else:
ret = key
await client.send_message(
message.channel, """```yaml
{}: {}```""".format(key_name, ret))
return
await client.send_message(
message.channel,
i18n.get_localized_str(message.server.id, "cmd_getconf_help"))
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
text = ""
async for msg in client.logs_from(message.channel, limit=500):
if not (msg.content.startswith(
config.get_key(msg.server.id, "cmd_prefix"))
or msg.author == client.user):
text += msg.content + "\n"
text_model = markovify.Text(text)
ret = text_model.make_sentence(tries=100,
max_overlap_ratio=2147483647,
max_overlap_total=2147483647)
if ret is None:
ret = i18n.get_localized_str(message.server.id,
"cmd_markov_not_enough_msg")
else:
print("Generated markov chain: " + ret)
try:
await client.send_message(message.channel, ret)
except discord.errors.HTTPException:
pass
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
if len(args) > 1:
key_name = args.pop(0)
key = config.get_key(message.server.id, key_name)
if key:
val = " ".join(args)
if isinstance(key, list):
config.set_key(message.server.id, key_name,
list(val.split(",")))
await client.on_server_join(message.server)
return
config.set_key(message.server.id, key_name, val)
return
await client.send_message(
message.channel,
i18n.get_localized_str(message.server.id, "cmd_conf_nokey",
{"key": key_name}))
return
await client.send_message(
message.channel,
i18n.get_localized_str(message.server.id, "cmd_conf_help"))
async def on_server_join(self, server: discord.Server):
print("Loading config for server: {0} ({1})".format(
server.id, server.name))
config.load_server_config(server.id)
i18n.load_lang(server.id, config.get_key(server.id, "language"))
stuff.muted_chans[server.id] = defaultdict(dict)
for ch in server.channels:
await self.on_channel_create(ch)
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
if not sound.queue.get(message.server.id):
sound.mk_server_queue(message.server.id)
while not sound.queue[message.server.id].empty():
if not sound.player.get(message.server.id):
await sound.play(
message.server.id, client, message,
config.get_key(message.server.id, "music_chan"))
elif sound.player[message.server.id].is_done():
await sound.play(
message.server.id, client, message,
config.get_key(message.server.id, "music_chan"))
await asyncio.sleep(sound.player[message.server.id].duration + 1)
async def on_member_remove(self, member: discord.Member):
for dcmd in config.get_key(member.server.id, "disabled_commands"):
if dcmd == "_welcomes":
return
try:
await self.send_message(
member.server,
i18n.get_localized_str(member.server.id, "bot_goodbye",
{"name": member.display_name}))
except discord.errors.Forbidden:
pass
async def do(self, client: discord.Client, message: discord.Message, args: list, cfg={}):
if len(args) < 1:
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_cleverbot_nothing", {"mention":
message.author.mention}))
return
for chan in config.get_key(message.server.id, "cleverbot_channels"):
if chan == message.channel.name:
input = " ".join(args)
await client.send_message(message.channel,
message.author.mention + ", " +
self.cb.ask(input))
return
await client.send_message(message.channel, i18n.get_localized_str(message.server.id, "cmd_cleverbot_wrongchannel", {"mention":
message.author.mention}))
async def do(self,
client: discord.Client,
message: discord.Message,
args: list,
cfg={}):
if sound.voice.get(message.server.id):
await client.send_message(
message.channel,
i18n.get_localized_str(message.server.id, "cmd_snd_init"))
return
for channel in message.server.channels:
if channel.name == config.get_key(message.server.id, "voice_chan"):
sound.voice[message.server.
id] = await client.join_voice_channel(channel)
sound.mk_server_queue(message.server.id)
await client.send_message(
message.channel,
i18n.get_localized_str(
message.server.id, "cmd_snd_init_ok",
{"mention": message.author.mention}))
break
async def on_message(self, message: discord.Message):
if not self.works: return
if message.author == self.user: return
isAuthorAdmin = False
if message.channel.type == discord.ChannelType.private:
if message.author.name == self.cfg["speak_person"]["name"] and str(
message.author.discriminator) == str(
self.cfg["speak_person"]["iden"]):
if message.content.startswith('!id '):
stuff.msgChan = str(message.content[4:])
elif message.content.startswith("!name "):
await self.edit_profile(username=str(message.content[6:]))
else:
await self.send_message(self.get_channel(stuff.msgChan),
message.content)
else:
# Cannot translate due to there being no language configuration
# for private message servers.
await self.send_message(message.channel, "Please do not pm")
return
try:
if message.author.permissions_in(message.channel).administrator:
isAuthorAdmin = True
else:
for role in message.author.roles:
for check_role in config.get_key(message.server.id,
"admin_roles"):
if role.name == check_role:
isAuthorAdmin = True
except AttributeError:
return # Probably a webhook.
if stuff.muted_chans[message.server.id][message.channel.name]:
if not isAuthorAdmin:
await self.delete_message(message)
await self.send_message(
message.author,
i18n.get_localized_str(message.server.id,
"bot_channel_locked",
{"channel": message.channel.name}))
return
for usr in stuff.timeout[message.server.id]:
if usr != message.author.id:
stuff.timeout[message.server.id][usr] = 0
if message.content.startswith(
config.get_key(message.server.id, "cmd_prefix")):
if stuff.timeout[message.server.id].get(message.author.id):
if stuff.timeout[message.server.id][message.author.id] > 5:
print("User {0} timing out".format(message.author.name))
return
try:
_s_cmd = shlex.split(message.content[
len(config.get_key(message.server.id, "cmd_prefix")):])
except ValueError as e:
await self.send_message(
message.channel,
i18n.get_localized_str(message.server.id,
"bot_command_syntax_error"))
return
cmd = _s_cmd[0]
c_args = _s_cmd[1:]
cmd_class = stuff.find_cmd_class(cmd)
print("Komut: ({0} @ #{1}) {2} args: {3}".format(
message.author.name, message.channel.name, cmd, str(c_args)))
for dcmd in config.get_key(message.server.id, "disabled_commands"):
if dcmd == cmd:
await self.send_message(
message.channel,
i18n.get_localized_str(message.server.id,
"bot_command_disabled"))
return
if cmd_class.requiresAdmin():
if isAuthorAdmin:
try:
await cmd_class.do(self, message, c_args, self.cfg)
except discord.errors.Forbidden as e:
print("Forbidden while trying to DO")
print(e.response)
for chan in message.server.channels:
if chan.name == config.get_key(message.server.id,
"modlog_chan"):
for dcmd in config.get_key(message.server.id,
"disabled_commands"):
if dcmd == "_modlog":
return
try:
await self.send_message(
chan, "{0} (#{1}): {2}".format(
message.author.name,
message.channel.name, message.content))
except discord.errors.Forbidden:
return
if cmd_class.deleteCMDMsg():
try:
await self.delete_message(message)
except (discord.errors.NotFound,
discord.errors.Forbidden):
pass
else:
await self.send_message(
message.channel,
i18n.get_localized_str(
message.server.id, "bot_noperm",
{"mention": message.author.name}))
else:
try:
await cmd_class.do(self, message, c_args, self.cfg)
except discord.errors.Forbidden as e:
print("Forbidden while trying to DO")
print(e.response)
if cmd_class.deleteCMDMsg():
try:
await self.delete_message(message)
except (discord.errors.NotFound, discord.errors.Forbidden):
pass
if not stuff.timeout[message.server.id].get(message.author.id):
stuff.timeout[message.server.id][message.author.id] = 0
stuff.timeout[message.server.id][message.author.id] += 1
if stuff.timeout[message.server.id][message.author.id] == 4:
await self.send_message(
message.author,
i18n.get_localized_str(message.server.id,
"bot_possiblespam"))
def _command_is_disabled(self, server: str, cmd: str):
for dcmd in config.get_key(server, "disabled_commands"):
if cmd == dcmd:
return True
return False
