def __init__(self, id, argument_parser=None):
BotClient.__init__(self, id, argument_parser)
self._api_keys = APIKeysHandler(
self.configuration.client_configuration)
self._authorization = None
self._v1_0_handler = APIHandler_V1_0(self)
self._v2_0_handler = APIHandler_V2_0(self)
def test_init(self):
config = RestConfiguration("test")
self.assertIsNotNone(config)
handler = APIKeysHandler(config)
self.assertIsNotNone(handler)
self.assertFalse(handler.use_api_keys())
def ask_question(self, client_context, question: str):
try:
botname, query = self._parse_question(question)
chatbot = self._get_openchatbot(client_context, botname)
headers = {}
if self.method == 'GET' and self.method in chatbot.methods:
full_url = self._format_get_url(chatbot.url,
client_context,
query,
api_key=chatbot.api_key)
if chatbot.authorization == 'Basic':
RestBasicAuthorizationHandler.add_authorisation_header(
client_context, headers)
response = self.api.get(full_url, headers=headers)
else:
response = self.api.get(full_url)
elif self.method == 'POST' and self.method in chatbot.methods:
payload = self._format_post_payload(client_context, query)
if chatbot.authorization == 'Basic' or chatbot.api_key is not None:
if chatbot.authorization == 'Basic':
RestBasicAuthorizationHandler.add_authorisation_header(
client_context, headers)
if chatbot.api_key is not None:
APIKeysHandler.add_post_api_key_header(
headers, chatbot.api_key)
response = self.api.post(chatbot.url,
data=payload,
headers=headers)
else:
response = self.api.post(chatbot.url, data=payload)
else:
raise Exception("Unsupported REST method [%s]" % self.method)
if response.status_code != 200:
YLogger.error(client_context, "[%s] return status code [%d]",
self.host, response.status_code)
else:
return self._parse_response(client_context, response.text)
except Exception as excep:
YLogger.exception(client_context, "Failed to resolve", excep)
return ""
def test_get_api_key(self):
config = RestConfiguration("test")
self.assertIsNotNone(config)
handler = APIKeysHandler(config)
self.assertIsNotNone(handler)
request = MockRequest()
request.args['apikey'] = '11111111'
self.assertEquals('11111111', handler.get_api_key(request))
def _format_get_url(self, url, client_context, question, lang=None, location=None, api_key=None):
get_url = "%s?query=%s&userId=%s" % (url, quote(question), client_context.userid)
if lang is not None:
get_url = "%s&lang=%s" % (get_url, lang)
if location is not None:
get_url = "%s&location=%s" % (get_url, location)
if api_key is not None:
get_url = "%s&%s" % (get_url, APIKeysHandler.format_get_api_key_param(api_key))
return get_url
class RestBotClient(BotClient):
__metaclass__ = ABCMeta
def __init__(self, id, argument_parser=None):
BotClient.__init__(self, id, argument_parser)
self._api_keys = APIKeysHandler(
self.configuration.client_configuration)
self._authorization = None
self._v1_0_handler = APIHandler_V1_0(self)
self._v2_0_handler = APIHandler_V2_0(self)
@property
def api_keys(self):
return self._api_keys
def get_client_configuration(self):
return RestConfiguration(self.id)
def initialise(self):
self._api_keys.load_api_keys()
self._authorization = RestAuthorizationHandler.load_authorisation(self)
def get_variable(self, rest_request, name, method='GET'):
if method == 'GET':
if name not in rest_request.args or rest_request.args[name] is None:
YLogger.error(self, "'%s' missing from GET request", name)
self.server_abort(400)
return rest_request.args[name]
elif method == 'POST':
if name not in rest_request.json or rest_request.json[name] is None:
YLogger.error(self, "'%s' missing from POST request", name)
self.server_abort(400)
return rest_request.json[name]
else:
YLogger.error(self, "Invalid REST request type '%s'", method)
self.server_abort(400)
@abstractmethod
def server_abort(self, message, status_code):
raise NotImplementedError()
@abstractmethod
def create_response(self, response_data, status_code, version=1.0):
raise NotImplementedError()
def _get_metadata(self, client_context, metadata):
if client_context.brain.properties.has_property("fullname"):
metadata['botName'] = client_context.brain.properties.property(
"fullname")
else:
metadata['botName'] = "Program-y"
if client_context.brain.properties.has_property("app_version"):
metadata['version'] = client_context.brain.properties.property(
"app_version")
else:
metadata['version'] = "1.0.0"
if client_context.brain.properties.has_property("copyright"):
metadata['copyright'] = client_context.brain.properties.property(
"copyright")
else:
metadata['copyright'] = "Copyright 2016-2019 keithsterling.com"
if client_context.brain.properties.has_property("botmaster"):
metadata['authors'] = [
client_context.brain.properties.property("botmaster")
]
else:
metadata['authors'] = ["Keith Sterling"]
def ask_question(self, userid, question, metadata=None):
response = ""
try:
self._questions += 1
client_context = self.create_client_context(userid)
response = client_context.bot.ask_question(client_context,
question,
responselogger=self)
if metadata is not None:
self._get_metadata(client_context, metadata)
except Exception as e:
YLogger.exception_nostack(self, "Failed to ask question", e)
return response
def process_request(self, request, version=1.0):
if self._authorization is not None:
if self._authorization.authorise(request) is False:
return "Access denied", 403
if self._api_keys is not None:
if self._api_keys.use_api_keys():
if self._api_keys.verify_api_key_usage(request) is False:
return 'Unauthorized access', 401
if version == 1.0:
return self._v1_0_handler.process_request(request)
elif version == 2.0:
return self._v2_0_handler.process_request(request)
else:
return 'Invalid API version', 400
def dump_request(self, request):
YLogger.debug(self, str(request))