def welcome_token(token: str = '',
message_format: FormatEnum = Query(FormatEnum.txt,
alias='format')):
"""Return welcome message to user based on given response format. Endpoint only available to users with valid token
- token argument is used in decorator."""
return format_message('Welcome!', message_format)
def onMessage(self, author_id, message_object, thread_id, thread_type,
**kwargs):
if not self.isLoggedIn():
self.login(self.email, self.password)
with open("session.json", "w") as f:
json.dump(self.getSession(), f)
if author_id == self.uid:
return
if thread_id != self.thread_id:
return
user = self.fetchUserInfo(author_id)[author_id]
if message_object.text is not None:
text = (utils.format_message(
user.name + RandomMessageGenerator.get_random_said()) +
message_object.text)
else:
text = None
urls = [
self.fetchImageUrl(f.uid) for f in filter(
lambda x: not isinstance(x, fbchat.ShareAttachment),
message_object.attachments,
)
]
if urls == []:
urls = None
self.send_handler(self.get_client_name(), text, urls)
def give_access(self, sock):
'''
Host responds to client request IF passwords match.
'''
msg = {
'source': "give_access",
'message': None,
'_from': None,
'_to': None,
'_type': "authentication",
'_order': None,
}
while True:
data = sock.recv(1024)
if data:
string_data = data.decode('utf-8')
formatted_data = format_message(string_data)
if formatted_data.get(
"_type") == "authentication" and formatted_data.get(
"message") == self.password:
msg["message"] = "granted"
formatted_msg = json.dumps(msg)
sock.send(formatted_msg)
return True
else:
return False
def welcome_session(session_token: str = Cookie(''),
message_format: FormatEnum = Query(FormatEnum.txt,
alias='format')):
"""Return welcome message to user based on given response format. Endpoint only available to users with valid
session cookie - request argument is used in decorator."""
return format_message('Welcome!', message_format)
async def on_message(self, message):
if message.author == self.user:
return
if message.channel.id != self.channel:
return
try:
if message.content != None and len(message.content) > 0:
text = (utils.format_message(
message.author.name +
RandomMessageGenerator.get_random_said()) +
message.content)
else:
text = None
if len(message.attachments) > 0:
urls = [a.url for a in message.attachments]
else:
urls = None
self.send_handler(self.get_client_name(), text, urls)
except Exception as e:
print(e)
def receive(self, sock):
while True:
data = sock.recv(1024)
if data:
string_data = data.decode('utf-8')
print(string_data)
formatted_data = format_message(string_data)
self.recv_queue.put(formatted_data)
def join_chat():
"""Sent by clients when they enter a room.
A status message is broadcast to all people in the room."""
backend = get_backend()
uid = userid()
chat_info = backend.get_chat_info(uid)
backend.send(uid,
Event.JoinEvent(chat_info.agent_index, uid, str(time.time())))
return jsonify(message=format_message("You entered the room.", True))
async def guide(context):
""" Link to guide on the forum """
lookup, at_users, message = await init_command(context)
task, _ = get_task(message, list(lookup["tasks"].keys()))
if not task:
return
msg = "There's a guide for {} here: {}".format(
task.title(), lookup["url"] + lookup["tasks"][task])
msg = format_message(msg, at_users)
await context.send(msg)
async def faqs(context):
""" Link to FAQs """
lookup, at_users, message = await init_command(context)
is_task = True
tasks = faq_cache.contents
if "search" in message:
is_task = False
search_term = " ".join(message[message.index("search") + 1:])
logger.info("search_term: %s", search_term)
if not search_term:
is_task = True
task = None
else:
task = faq_cache.search(search_term)
logger.info("results: %s", task)
if len(task) > lookup["results"]:
logger.info("Too many results. Limiting: %s / %s",
lookup["results"], len(task))
task = None
if not task:
is_task = True
task = None
else:
task, _ = get_task(message, list(tasks.keys()))
logger.info("final task: %s", task)
if is_task:
url = lookup["url"] if task is None else lookup["url"] + tasks[task]
section = "on" if task is None else "in the {} section of".format(
task.title())
msg = "Your question is answered {} our FAQ page at: {}".format(
section, url)
msg = format_message(msg, at_users)
else:
urls = "\n\t".join([
"`{}`: {}".format(val, lookup["url"] + key)
for key, val in task.items()
])
msg = (
"Your question is answered on our FAQ page. Try one of these answers related to "
"the term `{}`: \n\t{}".format(search_term, urls))
msg = format_message(msg, at_users)
await context.send(msg)
async def forums(context):
""" Link to the forums """
lookup, at_users, message = await init_command(context)
task, _ = get_task(message, lookup["tasks"])
ext = "index.php" if task is None else "viewforum.php?f={}".format(
lookup["tasks"][task])
section = "" if task is None else "the {} section of ".format(task.title())
msg = "You should check out {}our Forum at: {}".format(
section, lookup["url"] + ext)
msg = format_message(msg, at_users)
await context.send(msg)
async def support(context):
""" Support section of forum command """
lookup, at_users, message = await init_command(context)
task, _ = get_task(message, list(lookup["tasks"].keys()))
url = "{}{}".format(lookup["url"],
"3" if task is None else lookup["tasks"][task])
section = "in" if task is None else "in the {} section of".format(
task.title())
msg = format_message(
"This question has been asked and answered {} our Support Forum at: "
"{}".format(section, url), at_users)
await context.send(msg)
def text():
backend = get_backend()
message = unicode(request.args.get('message'))
displayed_message = format_message(u"You: {}".format(message), False)
uid = userid()
time_taken = float(request.args.get('time_taken'))
received_time = time.time()
start_time = received_time - time_taken
chat_info = backend.get_chat_info(uid)
backend.send(
uid,
Event.MessageEvent(chat_info.agent_index, message, str(received_time),
str(start_time)))
return jsonify(message=displayed_message, timestamp=str(received_time))
async def tag(context):
""" Tag search command """
lookup, at_users, message = await init_command(context)
url = lookup["url"]
if len(message) != 2:
logger.debug("No or multiple tags provided")
return
tag = message[1]
url += tag
msg = "You should try these posts tagged `{}` at our forum: {}".format(
tag, url)
msg = format_message(msg, at_users)
await context.send(msg)
def send_message(update, ctx):
message_text = utils.format_message(update.message)
if len(message_text) == 0:
update.message.reply_text(storage.get_string("EMPTY_MSG"))
else:
try:
bot.send_message(storage.get_target_chat(),
message_text,
reply_markup=utils.make_report_keyboard(
update.message.from_user.id),
parse_mode=ParseMode.HTML)
update.message.reply_text(storage.get_string("MSG_SENT"))
except Exception as e:
template = Template(storage.get_string("CANT_SEND"))
update.message.reply_text(
template.safe_substitute(message=e.message))
async def search(context):
""" Search the forum command """
lookup, at_users, message = await init_command(context)
terms = None
url = lookup["url"]
if len(message) > 1:
terms = "+".join(message[1:])
url += "?keywords={}".format(terms)
if terms is None:
results = ""
else:
results = ". Here are the results for `{}`".format(" ".join(
terms.split("+")))
msg = "You should try the Search page at our forum{}: {}".format(
results, url)
msg = format_message(msg, at_users)
await context.send(msg)
def ask_access(self, sock):
'''
Client sends access request to Host and waits for response.
Client notifies TextEditor if access is denied.
'''
msg = {
'source': "ask_access",
'message': self.password,
'_from': None,
'_to': None,
'_type': "authentication",
'_order': None,
}
formatted_msg = json.dumps(msg)
sock.send(formatted_msg)
for ticks in range(0, 1000):
data = sock.recv(1024)
if data:
string_data = data.decode('utf-8')
formatted_data = format_message(string_data)
if formatted_data.get(
"_type") == "authentication" and formatted_data.get(
"message") == "granted":
return True
else:
break
failed_msg = {
'source': "ask_access",
'message': "denied",
'_from': None,
'_to': None,
'_type': "authentication",
'_order': None,
}
self.recv_queue.put(failed_msg)
return False
async def donate(context):
""" Display donation messages """
lookup, at_users, message = await init_command(context)
content = dict()
for key, val in lookup["tasks"].items():
kwargs = dict(embed=dict(title=val["title"], type="rich"),
author=dict(name=val["name"], icon_url=val["icon"]))
if "url" in val:
kwargs["embed"]["url"] = val["url"]
kwargs["author"]["url"] = val["url"]
embed = Embed(**kwargs["embed"])
embed.set_thumbnail(url=val["thumbnail"])
embed.set_author(**kwargs["author"])
if val.get("fields", None) is not None:
for field in val["fields"]:
embed.add_field(inline=False, **field)
content[key] = embed
logger.info("donator content: %s", content)
donatee, _ = get_task(message, list(content.keys()))
msg = format_message(lookup["msg"], at_users)
await context.send(msg)
await context.send(embed=content.pop("patreon"))
if donatee != "patreon":
embeds = [content[donatee]] if donatee else [
content[key] for key in list(content.keys())
]
msg = (
"Alternatively you can give a one off donation to any of our Devs below:"
)
await context.send(msg)
for embed in embeds:
await context.send(embed=embed)
def close(issue):
text = utils.format_message(issue, config.closing_message)
issue.add_comment(text)
issue.close()
def warn(issue):
text = utils.format_message(issue, config.warning_message)
issue.add_comment(text)
def get_message(message_id):
msg_list = current_user.db().search_messages("id:%s"%message_id)
if len(msg_list) != 1:
abort(404)
m = msg_list[0]
return jsonify(format_message(m))
async def log(context):
""" Request a crash report """
lookup, at_users, _ = await init_command(context)
msg = format_message(lookup["msg"], at_users)
await context.send(msg)
async def dfl(context):
""" Output that we don't support DFL """
lookup, at_users, _ = await init_command(context)
msg = format_message(lookup["msg"], at_users)
await context.send(msg)
async def sysinfo(context):
""" Output System Information """
lookup, at_users, _ = await init_command(context)
msg = format_message(lookup["msg"], at_users)
await context.send(msg)
def receive(self, sock):
'''
This listens to receiving socket all the time.
Large messages > 1024 bytes come in multiple messages, so those are handled aswell.
'''
msg = ""
remaining = -1 # -1 for unknown
while True:
try:
data = sock.recv(1024)
# The problem occurs if header is found from the end of previous message due latency.
if data:
string_data = data.decode('utf-8')
if (remaining <= 0):
# pass data to msg - start buffer if needed
if self.supportLongMessages:
try:
header_end_index = string_data.find(
'ALD', 0, 15)
json_started = string_data.find('{', 0, 15)
if header_end_index == -1 or json_started < header_end_index:
#Header not found
msg = string_data
else:
header_end = header_end_index + len("ALD")
header = string_data[:header_end - 1]
msg = string_data[header_end:]
msg_length = int(
header[len("HAR"):-(len("ALD") - 1)])
remaining = msg_length - 1024
except ValueError as e:
print(e)
print("ValueError on parsing header")
pass
else:
msg = string_data
else:
# buffer has been started
msg += string_data
remaining = remaining - 1024
if remaining <= 0:
# message is ready to parse
try:
formatted_data = format_message(msg)
self.socket_recv_queue.put(formatted_data)
except ValueError as e:
print(e)
print("Message lost..")
pass
#print("Harald received:", string_data)
except OSError:
if self.host_sock:
print(
'Lost connection to Host. Closing this receive thread.'
)
else:
print(
'Lost connection to a Client. Closing this receive thread.'
)
sock.close()
return
def logout(message_format: FormatEnum = Query(FormatEnum.txt, alias='format')):
"""Return message to user after log out."""
return format_message('Logged out!', message_format)
