def test_image(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<image>http://servusai.com/aiml.png</image>")
self.assertEquals(mock_console._response, '<img src="http://servusai.com/aiml.png" />')
def test_delay(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<delay><seconds>0</seconds></delay>")
self.assertEquals(mock_console._response, '<div class="delay">...</div>')
def test_postback_button(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<button><text>Hello</text><postback>HELLO</postback></button>")
self.assertEquals(mock_console._response, '<a class="postback" postback="HELLO" href="#">Hello</a>')
def test_link(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<link><text>Hello</text><url>http://click.me</url></link>")
self.assertEquals(mock_console._response, '<a href="http://click.me">Hello</a>')
def test_create_postback_url(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
postback = renderer.create_postback_url()
self.assertIsNotNone(postback)
self.assertEquals(postback, "#")
def test_text_only(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "Hello world")
self.assertEquals(mock_console._response, "Hello world")
def test_location(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<location />")
self.assertEquals(mock_console._response, "")
def test_olist(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<olist><item>Item1</item><item>Item2</item></olist>")
self.assertEquals(mock_console._response, "<ol><li>Item1</li><li>Item2</li></ol>")
def test_split(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<split />")
self.assertEquals(mock_console._response, "<br />")
def test_carousel(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<carousel><card><image>http://servusai.com/aiml.png</image><title>Servusai</title><subtitle>Home of ProgramY</subtitle><button><text>Hello</text><url>http://click.me</url></button></card></carousel>")
self.assertEquals(mock_console._response, '<div class="carousel"><div class="card" ><img src="http://servusai.com/aiml.png" /><h1>Servusai</h1><h2>Home of ProgramY</h2><a href="http://click.me">Hello</a></div></div>')
def test_reply_without_postback(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<reply><text>Hello</text></reply>")
self.assertEquals(mock_console._response, '<a class="postback" postback="Hello" href="#">Hello</a>')
def test_video(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<video>http://servusai.com/aiml.mov</video>")
self.assertEquals(mock_console._response, """<video src="http://servusai.com/aiml.mov">
Sorry, your browser doesn't support embedded videos,
but don't worry, you can <a href="http://servusai.com/aiml.mov">download it</a>
and watch it with your favorite video player!
</video>""")
def test_postback_button(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render(
"testuser",
"<button><text>Hello</text><postback>HELLO</postback></button>")
self.assertEquals(
mock_console._response,
'<a class="postback" postback="HELLO" href="#">Hello</a>')
def test_video(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser", "<video>http://servusai.com/aiml.mov</video>")
self.assertEqual(mock_console._response, """<video class="programy" src="http://servusai.com/aiml.mov">
Sorry, your browser doesn't support embedded videos,
but don't worry, you can <a href="http://servusai.com/aiml.mov">download it</a>
and watch it with your favorite video player!
</video>""")
def test_carousel(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
texts1 = '<carousel><card><image>http://servusai.com/aiml.png</image><title>Servusai</title><subtitle>Home of ProgramY</subtitle>' + \
'<button><text>Hello</text><url>http://click.me</url></button></card></carousel>'
renderer.render("testuser", texts1)
texts2 = '<div class="carousel"><div class="card" ><img src="http://servusai.com/aiml.png" /><h1>Servusai</h1>' + \
'<h2>Home of ProgramY</h2><a href="http://click.me">Hello</a></div></div>'
self.assertEqual(mock_console._response, texts2)
def test_video(self):
mock_console = MockHtmlBotClient()
renderer = HtmlRenderer(mock_console)
self.assertIsNotNone(renderer)
renderer.render("testuser",
"<video>http://servusai.com/aiml.mov</video>")
texts = '<video src="http://servusai.com/aiml.mov">\n' + \
"Sorry, your browser doesn't support embedded videos, \n" + \
"but don't worry, you can " + '<a href="http://servusai.com/aiml.mov">download it</a>\n' + \
'and watch it with your favorite video player!\n' + \
'</video>'
self.assertEqual(mock_console._response, texts)
def get_default_renderer(self):
return HtmlRenderer()
def __init__(self, argument_parser=None):
FlaskRestBotClient.__init__(self, "WebChat", argument_parser)
# Enter you API keys, here, alternatively store in a db or file and load at startup
# This is an exmaple, and therefore not suitable for production
self._api_keys = []
self._renderer = HtmlRenderer()
class WebChatBotClient(FlaskRestBotClient):
def __init__(self, argument_parser=None):
FlaskRestBotClient.__init__(self, "WebChat", argument_parser)
# Enter you API keys, here, alternatively store in a db or file and load at startup
# This is an exmaple, and therefore not suitable for production
self._api_keys = []
self._renderer = HtmlRenderer()
def get_description(self):
return 'ProgramY AIML2.0 Webchat Client'
def get_client_configuration(self):
return WebChatConfiguration()
def is_apikey_valid(self, apikey):
return bool(apikey in self._api_keys)
def get_api_key(self, request):
if 'api_key' in request.args:
return request.args['api_key']
return None
def unauthorised_access_response(self, error_code=401):
return make_response(jsonify({'error': 'Unauthorized access'}),
error_code)
def check_api_key(self, request):
if self.configuration.client_configuration.use_api_keys is True:
api_key = self.get_api_key(request)
if api_key is None:
YLogger.error(
self, "Unauthorised access - api required but missing")
return self.unauthorised_access_response()
if self.is_apikey_valid(api_key) is False:
YLogger.error(self, "'Unauthorised access - invalid api key")
return self.unauthorised_access_response()
return None
def get_question(self, request):
if 'question' in request.args:
return request.args['question']
return None
def get_userid(self, request):
userid = request.cookies.get(
self.configuration.client_configuration.cookie_id)
if userid is None:
userid = str(uuid.uuid4().hex)
YLogger.debug(self, "Setting userid cookie to :%s" % userid)
else:
YLogger.debug(self, "Found userid cookie : %s" % userid)
return userid
def get_userid_cookie_expirary_date(self, duration):
expire_date = datetime.datetime.now()
expire_date = expire_date + datetime.timedelta(days=duration)
return expire_date
def create_success_response_data(self, question, answer):
return {"question": question, "answer": answer}
def get_default_response(self, client_context):
return client_context.bot.default_response
def create_error_response_data(self, client_context, question, error):
return {
"question": question,
"answer": self.get_default_response(client_context),
"error": error
}
def create_response(self, response_data, userid, userid_expire_date):
response = jsonify({'response': response_data})
response.set_cookie(self.configuration.client_configuration.cookie_id,
userid,
expires=userid_expire_date)
return response
def get_answer(self, client_context, question):
if question == 'YINITIALQUESTION':
answer = client_context.bot.get_initial_question(client_context)
else:
answer = client_context.bot.ask_question(client_context,
question,
responselogger=self)
return answer
def receive_message(self, request):
api_key_response = self.check_api_key(request)
if api_key_response is not None:
return api_key_response
question = self.get_question(request)
if question is None:
YLogger.error(self, "'question' missing from request")
abort(400)
userid = self.get_userid(request)
userid_expire_date = self.get_userid_cookie_expirary_date(
self.configuration.client_configuration.cookie_expires)
client_context = self.create_client_context(userid)
try:
answer = self.get_answer(client_context, question)
rendered = self._renderer.render(client_context, answer)
response_data = self.create_success_response_data(
question, rendered)
except Exception as excep:
YLogger.exception(self, excep)
response_data = self.create_error_response_data(
client_context, question, str(excep))
return self.create_response(response_data, userid, userid_expire_date)
def get_rest_question(self, rest_request):
if 'question' not in rest_request.args or rest_request.args[
'question'] is None:
YLogger.error(self, "'question' missing from request")
abort(400)
return rest_request.args['question']
def get_rest_userid(self, rest_request):
if 'userid' not in rest_request.args or rest_request.args[
'userid'] is None:
YLogger.error(self, "'userid' missing from request")
abort(400)
return rest_request.args['userid']
def dump_request(self, request):
if request.method == 'POST':
YLogger.debug(self, str(request))
elif request.method == 'GET':
YLogger.debug(self, str(request))
else:
YLogger.debug(
self,
"restsclient.dump_request(), only GET and POST supported!")
def process_rest_request(self, request):
question = "Unknown"
userid = "Unknown"
try:
response, status = self.verify_api_key_usage(request)
if response is not None:
return response, status
question = self.get_rest_question(request)
userid = self.get_rest_userid(request)
answer = self.ask_question(userid, question)
return self.format_success_response(userid, question, answer), 200
except Exception as excep:
return self.format_error_response(userid, question,
str(excep)), 500
def response_rest_message(self, request):
response_data, status = self.process_rest_request(request)
if self.configuration.client_configuration.debug is True:
self.dump_request(request)
YLogger.debug(
self, "restclient response data:{}".format({
'response': response_data,
'status': status
}))
return make_response(
jsonify({
'response': response_data,
'status': status
}))
def get_default_renderer(self, callback=True):
return HtmlRenderer()
