def on_message_create(self, event):
self.initialize(event)
if self.is_bot(event):
return
if self.has_inputchannel(self.get_server_id(event)):
input_channel_id = jsonstorage.get(self.get_server_id(event),
Constants.input_channel.fget())
if event.raw_data['message']['channel_id'] != input_channel_id:
return
if self.has_outputchannel(self.get_server_id(event)):
output_channel_id = int(
jsonstorage.get(self.get_server_id(event),
Constants.output_channel.fget()))
output_channel = self.bot.client.state.channels.get(
output_channel_id)
if self.is_valid_server_channel_id(output_channel_id):
keywords = self.get_triggered_keywords(
self.get_server_id(event), event.message.content)
for word in event.message.content.split(' '):
if word in keywords:
response = self.get_triggered_response(
self.get_server_id(event), word)
event.reply(response)
else:
event.reply("No outputchannel has been set")
async def handle_url_input_channel(self, event):
channel_id = event.raw_data['message']['channel_id']
urls = self.get_urls(event.message.content)
url_input_channel_id = jsonstorage.get(self.get_server_id(event), Constants.url_input_channel.fget())
if channel_id != url_input_channel_id:
return
# Return if there are valid URLS found
if len(urls) == 0:
return
# Check if output channel is set
if not self.has_outputchannel(self.get_server_id(event)):
event.reply("No outputchannel has been set")
return
url_output_channel_id = int(jsonstorage.get(self.get_server_id(event), Constants.url_output_channel.fget()))
url_output_channel = self.bot.client.state.channels.get(url_output_channel_id)
# Do not handle invalid channel
if not self.is_valid_server_channel_id(url_output_channel_id):
return
for url in urls:
if not self.url_is_blacklisted(self.get_server_id(event), url):
url_output_channel.send_message(url)
def has_migration_version(self):
try:
version = jsonstorage.get(self.server_id,
Constants.migration_version.fget())
return True
except Exception:
return False
def has_outputchannel(self, server_id):
try:
channel = jsonstorage.get(server_id,
Constants.output_channel.fget())
return True
except Exception:
return False
def is_admin_only_control(self, server_id):
try:
value = jsonstorage.get(server_id, Constants.adminonlycontrol.fget())
except:
value = None
if value in ['True', 'true']:
return True
else:
return False
def update_one(self):
try:
if self.has_storage_field("listen_channel"):
old_input_value = jsonstorage.get(self.server_id,
"listen_channel")
jsonstorage.add(self.server_id,
Constants.url_input_channel.fget(),
old_input_value)
jsonstorage.remove(self.server_id, "listen_channel")
if self.has_storage_field("response_channel"):
old_output_value = jsonstorage.get(self.server_id,
"response_channel")
jsonstorage.add(self.server_id,
Constants.url_output_channel.fget(),
old_output_value)
jsonstorage.remove(self.server_id, "response_channel")
except:
# Todo, notify discord server of failed migration and advice reconfiguration
pass
async def handle_linkonly_channel(self, event):
channel_id = event.raw_data['message']['channel_id']
urls = self.get_urls(event.message.content)
linkonly_channel_id = jsonstorage.get(self.get_server_id(event), Constants.linkonly_channel.fget())
if channel_id != linkonly_channel_id:
return
# Return if there are URLS found or the message is from a moderator.
if len(urls) > 0: #or self.is_msg_moderator(event):
return
# Wait a minute before deleting the message
await asyncio.sleep(5)
# Delete the non-link, non-moderator message since this is link-only channel
event.message.delete()
def has_linkonlychannel(self, server_id):
try:
channel = jsonstorage.get(server_id, Constants.linkonly_channel.fget())
return True
except Exception:
return False
def url_is_blacklisted(self, server_id, url):
blacklist = jsonstorage.get(server_id, Constants.blacklisted_domains.fget()).items()
for entry in blacklist:
if self.get_stripped_domain(entry[1]) == self.get_stripped_domain(url):
return True
return False
def has_storage_field(self, key):
try:
value = jsonstorage.get(self.server_id, key)
return True
except Exception:
return False
def command_set_showkeywords(self, event):
if not self.is_allowed(event):
return
keywordlist = jsonstorage.get(self.get_server_id(event),
Constants.keyword_list.fget())
event.msg.reply("Keywords: {}".format(keywordlist.items()))
def get_triggered_response(self, server_id, key):
keywordlist = jsonstorage.get(server_id, Constants.keyword_list.fget())
return keywordlist[key]
def get_triggered_keywords(self, server_id, text):
keywordlist = jsonstorage.get(server_id, Constants.keyword_list.fget())
return [x for x in keywordlist]
def get_migration_version(self):
return jsonstorage.get(self.server_id,
Constants.migration_version.fget())
def has_blacklisted_domains(self, server_id):
try:
blacklist = jsonstorage.get(server_id, Constants.blacklisted_domains.fget())
return True
except Exception:
return False
def command_set_domainblacklistshow(self, event):
if not self.is_allowed(event):
return
blacklist = jsonstorage.get(self.get_server_id(event), Constants.blacklisted_domains.fget())
event.msg.reply("Blacklist: {}".format(blacklist.items()))
def has_keywords(self, server_id):
try:
keylist = jsonstorage.get(server_id, Constants.keyword_list.fget())
return True
except Exception:
return False
